/**
 *  Copyright 2022 Rive Inc.
 */

#ifdef TESTING
#else

#include "imagediff_arguments.hpp"
#include "image_cmp.hpp"
#include "SkImage.h"
#include "SkData.h"
#include "SkPixmap.h"
#include "common/write_png_file.hpp"

#include <assert.h>
#include <string>
#include <stdio.h>

class WFile
{
    FILE* m_File = nullptr;
    bool m_DoClose;

public:
    WFile(FILE* existingFile) : m_File(existingFile) { m_DoClose = false; }

    WFile(const char path[], const char mode[]) : m_File(fopen(path, mode))
    {
        m_DoClose = true;
    }

    ~WFile() { this->close(); }

    bool isOpen() const { return m_File != nullptr; }

    bool open(const char path[], const char mode[])
    {
        this->close();
        m_File = fopen(path, mode);
        return m_File != nullptr;
    }

    void close()
    {
        if (m_DoClose && m_File)
        {
            fclose(m_File);
        }
        m_File = nullptr;
    }

    void write(const void* data, size_t length)
    {
        assert(m_File);
        fwrite(data, 1, length, m_File);
    }

    void write(const std::string& str) { this->write(str.c_str(), str.size()); }

    void writeln(const std::string& str)
    {
        this->write(str);
        this->write("\n");
    }
};

static sk_sp<SkImage> file_to_image(const char path[])
{
    auto data = SkData::MakeFromFileName(path);
    if (!data)
    {
        return nullptr;
    }
    auto img = SkImage::MakeFromEncoded(data);
    if (img)
    {
        img = img->makeRasterImage();
    }
    return img;
}

static void write_file(const char dir[],
                       const char name[],
                       const char suffix[],
                       sk_sp<SkImage> img)
{
    auto path = std::string(dir) + std::string("/") + std::string(name) +
                std::string(suffix);

    SkColorInfo colorInfo(kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr);
    std::vector<uint8_t> pixels(img->height() * img->width() * 4);
    img->readPixels(
        nullptr,
        SkPixmap(SkImageInfo::Make({img->width(), img->height()}, colorInfo),
                 pixels.data(),
                 img->width() * 4),
        0,
        0);

    //    printf("creating %s\n", path.c_str());
    WritePNGFile(pixels.data(),
                 img->width(),
                 img->height(),
                 false,
                 path.c_str(),
                 PNGCompression::fast_rle);
}

void image_diff(const char name[],
                const char pathA[],
                const char pathB[],
                const char statusPath[],
                const char diffDir[])
{
    WFile status =
        statusPath && statusPath[0] ? WFile(statusPath, "a") : WFile(stdout);
    if (!status.isOpen())
    {
        throw "failed to open status file";
    }

    status.write(std::string(name) + "\t");

    auto imgA = file_to_image(pathA);
    auto imgB = file_to_image(pathB);
    if (!imgA || !imgB)
    {
        status.writeln("failed");
        return;
    }

    const auto cmp = image_cmp(imgA, imgB);
    if (!cmp.images_loaded)
    {
        status.writeln("failed");
        return;
    }

    if (cmp.identical())
    {
        status.writeln("identical");
        return;
    }

    if (!cmp.dimensions_equal)
    {
        status.writeln("sizemismatch");
        return;
    }

    status.writeln(std::to_string(cmp.max_component_diff) + '\t' +
                   std::to_string(cmp.ave_component_diff) + '\t' +
                   std::to_string(cmp.pixel_diffcount) + '\t' +
                   std::to_string(imgA->height() * imgA->width()));

    if (diffDir && diffDir[0])
    {
        auto diff0 = make_diff_image(imgA, imgB, compute_diff0);
        auto diff1 = make_diff_image(imgA, imgB, compute_diff1);

        write_file(diffDir, name, ".diff0.png", diff0);
        write_file(diffDir, name, ".diff1.png", diff1);
    }
}

int main(int argc, const char* argv[])
{
    try
    {
        ImageDiffArguments args(argc, argv);

        image_diff(args.name().c_str(),
                   args.golden().c_str(),
                   args.candidate().c_str(),
                   args.status().c_str(),
                   args.output().c_str());
    }
    catch (const args::Completion& e)
    {
        return 0;
    }
    catch (const args::Help&)
    {
        return 0;
    }
    catch (const args::ParseError& e)
    {
        return 1;
    }
    catch (args::ValidationError e)
    {
        return 1;
    }

    return 0;
}

#endif