//========================================================================
//
// PNGWriter.cc
//
// This file is licensed under the GPLv2 or later
//
// Copyright (C) 2009 Warren Toomey <wkt@tuhs.org>
// Copyright (C) 2009 Shen Liang <shenzhuxi@gmail.com>
// Copyright (C) 2009, 2011-2023, 2025, 2026 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2009 Stefan Thomas <thomas@eload24.com>
// Copyright (C) 2010, 2011, 2013, 2017 Adrian Johnson <ajohnson@redneon.com>
// Copyright (C) 2011 Thomas Klausner <wiz@danbala.tuwien.ac.at>
// Copyright (C) 2012 Pino Toscano <pino@kde.org>
//
//========================================================================

#include "PNGWriter.h"

#if ENABLE_LIBPNG

#    include <zlib.h>
#    include <cstdlib>
#    include <cstring>

#    include "poppler/Error.h"
#    include "goo/gmem.h"

#    include <png.h>

struct PNGWriterPrivate
{
    explicit PNGWriterPrivate(PNGWriter::Format f) : format(f) { }

    PNGWriter::Format format;
    png_structp png_ptr = nullptr;
    png_infop info_ptr = nullptr;
    unsigned char *icc_data = nullptr;
    int icc_data_size = 0;
    char *icc_name = nullptr;
    bool sRGB_profile = false;

    PNGWriterPrivate(const PNGWriterPrivate &) = delete;
    PNGWriterPrivate &operator=(const PNGWriterPrivate &) = delete;
};

PNGWriter::PNGWriter(Format formatA)
{
    priv = new PNGWriterPrivate(formatA);
}

PNGWriter::~PNGWriter()
{
    /* cleanup heap allocation */
    png_destroy_write_struct(&priv->png_ptr, &priv->info_ptr);
    if (priv->icc_data) {
        gfree(priv->icc_data);
        free(priv->icc_name);
    }

    delete priv;
}

void PNGWriter::setICCProfile(const char *name, unsigned char *data, int size)
{
    priv->icc_data = static_cast<unsigned char *>(gmalloc(size));
    memcpy(priv->icc_data, data, size);
    priv->icc_data_size = size;
    priv->icc_name = strdup(name);
}

void PNGWriter::setSRGBProfile()
{
    priv->sRGB_profile = true;
}

bool PNGWriter::init(FILE *f, int width, int height, double hDPI, double vDPI)
{
    const auto *icc_data_ptr = const_cast<png_const_bytep>(priv->icc_data);

    if (hDPI < 0 || vDPI < 0) {
        error(errInternal, -1, "PNGWriter::init: hDPI or vDPI values are invalid {0:f} {1:f}", hDPI, vDPI);
        return false;
    }

    const double png_res_x = hDPI / 0.0254;
    const double png_res_y = vDPI / 0.0254;
    if (png_res_x > std::numeric_limits<png_uint_32>::max() || png_res_y > std::numeric_limits<png_uint_32>::max()) {
        error(errInternal, -1, "PNGWriter::init: hDPI or vDPI values are invalid {0:f} {1:f}", hDPI, vDPI);
        return false;
    }

    /* initialize stuff */
    priv->png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
    if (!priv->png_ptr) {
        error(errInternal, -1, "png_create_write_struct failed");
        return false;
    }

    priv->info_ptr = png_create_info_struct(priv->png_ptr);
    if (!priv->info_ptr) {
        error(errInternal, -1, "png_create_info_struct failed");
        return false;
    }

    if (setjmp(png_jmpbuf(priv->png_ptr))) {
        error(errInternal, -1, "png_jmpbuf failed");
        return false;
    }

    /* write header */
    png_init_io(priv->png_ptr, f);
    if (setjmp(png_jmpbuf(priv->png_ptr))) {
        error(errInternal, -1, "Error during writing header");
        return false;
    }

    // Set up the type of PNG image and the compression level
    png_set_compression_level(priv->png_ptr, Z_BEST_COMPRESSION);

    // Silence silly gcc
    png_byte bit_depth = -1;
    png_byte color_type = -1;
    switch (priv->format) {
    case RGB:
        bit_depth = 8;
        color_type = PNG_COLOR_TYPE_RGB;
        break;
    case RGB48:
        bit_depth = 16;
        color_type = PNG_COLOR_TYPE_RGB;
        break;
    case RGBA:
        bit_depth = 8;
        color_type = PNG_COLOR_TYPE_RGB_ALPHA;
        break;
    case GRAY:
        bit_depth = 8;
        color_type = PNG_COLOR_TYPE_GRAY;
        break;
    case MONOCHROME:
        bit_depth = 1;
        color_type = PNG_COLOR_TYPE_GRAY;
        break;
    }
    png_byte interlace_type = PNG_INTERLACE_NONE;

    png_set_IHDR(priv->png_ptr, priv->info_ptr, width, height, bit_depth, color_type, interlace_type, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

    png_set_pHYs(priv->png_ptr, priv->info_ptr, static_cast<png_uint_32>(png_res_x), static_cast<png_uint_32>(png_res_y), PNG_RESOLUTION_METER);

    if (priv->icc_data) {
        png_set_iCCP(priv->png_ptr, priv->info_ptr, priv->icc_name, PNG_COMPRESSION_TYPE_BASE, icc_data_ptr, priv->icc_data_size);
    } else if (priv->sRGB_profile) {
        png_set_sRGB(priv->png_ptr, priv->info_ptr, PNG_sRGB_INTENT_RELATIVE);
    }

    png_write_info(priv->png_ptr, priv->info_ptr);
    if (setjmp(png_jmpbuf(priv->png_ptr))) {
        error(errInternal, -1, "error during writing png info bytes");
        return false;
    }

    return true;
}

bool PNGWriter::writePointers(unsigned char **rowPointers, int /*rowCount*/)
{
    png_write_image(priv->png_ptr, rowPointers);
    /* write bytes */
    if (setjmp(png_jmpbuf(priv->png_ptr))) {
        error(errInternal, -1, "Error during writing bytes");
        return false;
    }

    return true;
}

bool PNGWriter::writeRow(unsigned char **row)
{
    // Write the row to the file
    png_write_rows(priv->png_ptr, row, 1);
    if (setjmp(png_jmpbuf(priv->png_ptr))) {
        error(errInternal, -1, "error during png row write");
        return false;
    }

    return true;
}

bool PNGWriter::close()
{
    /* end write */
    png_write_end(priv->png_ptr, priv->info_ptr);
    if (setjmp(png_jmpbuf(priv->png_ptr))) {
        error(errInternal, -1, "Error during end of write");
        return false;
    }

    return true;
}

#endif
