#include "utils/serializing_factory.hpp"
#include "rive/decoders/bitmap_decoder.hpp"
#include "rive/core/binary_reader.hpp"
#include "rive/artboard.hpp"
#include <cstring>
#include <stdlib.h>
#include <filesystem>
#include <inttypes.h>
#include <unordered_map>

using namespace rive;

// Threshold for floating point tests.
static const float epsilon = 0.001f;

enum class SerializeOp : unsigned char
{
    makeRenderBuffer = 0,
    makeLinearGradient = 1,
    makeRadialGradient = 2,
    makeRenderPath = 3,
    makeRenderPaint = 5,
    decodeImage = 6,
    save = 7,
    restore = 8,
    transform = 9,
    drawPath = 10,
    clipPath = 11,
    drawImage = 12,
    drawImageMesh = 13,

    // RenderBuffer
    setVertexBufferData = 14,
    setIndexBufferData = 15,

    // RenderPath
    addRawPath = 16,
    rewind = 17,
    fillRule = 18,

    // RenderPaint
    style = 20,
    color = 21,
    thickness = 22,
    join = 23,
    cap = 24,
    feather = 25,
    blendMode = 26,
    shader = 27,

    frame = 28,
    frameSize = 29,
    modulateOpacity = 30,

};

static const char* opToName(SerializeOp op)
{
    switch (op)
    {
        case SerializeOp::makeRenderBuffer:
            return "makeRenderBuffer";
        case SerializeOp::makeLinearGradient:
            return "makeLinearGradient";
        case SerializeOp::makeRadialGradient:
            return "makeRadialGradient";
        case SerializeOp::makeRenderPath:
            return "makeRenderPath";
        case SerializeOp::makeRenderPaint:
            return "makeRenderPaint";
        case SerializeOp::decodeImage:
            return "decodeImage";
        case SerializeOp::save:
            return "save";
        case SerializeOp::restore:
            return "restore";
        case SerializeOp::transform:
            return "transform";
        case SerializeOp::drawPath:
            return "drawPath";
        case SerializeOp::clipPath:
            return "clipPath";
        case SerializeOp::drawImage:
            return "drawImage";
        case SerializeOp::drawImageMesh:
            return "drawImageMesh";

        // RenderBuffer
        case SerializeOp::setVertexBufferData:
            return "setVertexBufferData";
        case SerializeOp::setIndexBufferData:
            return "setIndexBufferData";

        // RenderPath
        case SerializeOp::addRawPath:
            return "addRawPath";
        case SerializeOp::rewind:
            return "rewind";
        case SerializeOp::fillRule:
            return "fillRule";

        // RenderPaint
        case SerializeOp::style:
            return "style";
        case SerializeOp::color:
            return "color";
        case SerializeOp::thickness:
            return "thickness";
        case SerializeOp::join:
            return "join";
        case SerializeOp::cap:
            return "cap";
        case SerializeOp::feather:
            return "feather";
        case SerializeOp::blendMode:
            return "blendMode";
        case SerializeOp::shader:
            return "shader";

        case SerializeOp::frame:
            return "frame";
        case SerializeOp::frameSize:
            return "frameSize";
        case SerializeOp::modulateOpacity:
            return "modulateOpacity";
    }
    return "???";
}

class SerializingRenderImage : public RenderImage
{
public:
    SerializingRenderImage(uint64_t id, uint32_t width, uint32_t height) :
        m_id(id)
    {
        m_Width = width;
        m_Height = height;
    }

    uint64_t id() const { return m_id; }

private:
    uint64_t m_id;
};

static void serializeRawPath(BinaryWriter* writer, const RawPath& path)
{
    auto verbs = path.verbs();
    auto points = path.points();
    writer->writeVarUint((uint64_t)verbs.size());
    for (auto verb : verbs)
    {
        writer->writeVarUint((uint64_t)verb);
    }
    writer->writeVarUint((uint64_t)points.size());
    for (auto point : points)
    {
        writer->writeFloat(point.x);
        writer->writeFloat(point.y);
    }
}

class SerializingRenderShader : public RenderShader
{
public:
    SerializingRenderShader(uint64_t id) : m_id(id) {}
    uint64_t id() const { return m_id; }

private:
    uint64_t m_id;
};

class SerializingRenderPaint : public RenderPaint
{
public:
    SerializingRenderPaint(BinaryWriter* writer, uint64_t id) :
        m_id(id), m_writer(writer)
    {
        m_writer->writeVarUint((uint32_t)SerializeOp::makeRenderPaint);
        m_writer->writeVarUint(m_id);
    }

    void color(unsigned int value) override
    {
        if (m_color == value)
        {
            return;
        }
        m_color = value;
        m_writer->writeVarUint((uint32_t)SerializeOp::color);
        m_writer->writeVarUint(m_id);
        m_writer->writeVarUint(m_color);
    }

    void style(RenderPaintStyle value) override
    {
        if (m_stroked == (value == RenderPaintStyle::stroke))
        {
            return;
        }
        m_stroked = value == RenderPaintStyle::stroke;
        m_writer->writeVarUint((uint32_t)SerializeOp::style);
        m_writer->writeVarUint(m_id);
        m_writer->writeVarUint((uint32_t)(m_stroked ? 0 : 1));
    }

    void thickness(float value) override
    {
        if (m_thickness == value)
        {
            return;
        }
        m_thickness = value;
        m_writer->writeVarUint((uint32_t)SerializeOp::thickness);
        m_writer->writeVarUint(m_id);
        m_writer->writeFloat(m_thickness);
    }

    void join(StrokeJoin value) override
    {
        if (m_join == value)
        {
            return;
        }
        m_join = value;
        m_writer->writeVarUint((uint32_t)SerializeOp::join);
        m_writer->writeVarUint(m_id);
        m_writer->writeVarUint((uint32_t)m_join);
    }

    void cap(StrokeCap value) override
    {
        if (m_cap == value)
        {
            return;
        }
        m_cap = value;
        m_writer->writeVarUint((uint32_t)SerializeOp::cap);
        m_writer->writeVarUint(m_id);
        m_writer->writeVarUint((uint32_t)m_cap);
    }

    void blendMode(BlendMode value) override
    {
        if (m_blendMode == value)
        {
            return;
        }
        m_blendMode = value;
        m_writer->writeVarUint((uint32_t)SerializeOp::blendMode);
        m_writer->writeVarUint(m_id);
        m_writer->writeVarUint((uint32_t)m_blendMode);
    }

    void shader(rcp<RenderShader> shader) override
    {
        if (m_shader == shader)
        {
            return;
        }
        m_shader = shader;
        m_writer->writeVarUint((uint32_t)SerializeOp::shader);
        m_writer->writeVarUint(m_id);
        m_writer->writeVarUint(
            shader == nullptr
                ? 0
                : static_cast<SerializingRenderShader*>(shader.get())->id());
    }
    void invalidateStroke() override {}
    void feather(float value) override
    {
        if (m_feather == value)
        {
            return;
        }
        m_feather = value;
        m_writer->writeVarUint((uint32_t)SerializeOp::feather);
        m_writer->writeVarUint(m_id);
        m_writer->writeFloat(m_feather);
    }

    uint64_t id() const { return m_id; }

private:
    uint64_t m_id;
    BinaryWriter* m_writer;
    rcp<RenderShader> m_shader;

    unsigned int m_color = 0xFF000000;
    float m_thickness = 1;
    StrokeJoin m_join = StrokeJoin::miter;
    StrokeCap m_cap = StrokeCap::butt;
    float m_feather = 0;
    BlendMode m_blendMode = BlendMode::srcOver;
    bool m_stroked = false;
};

class SerializingRenderPath : public RenderPath
{
public:
    void rewind() override
    {
        m_writer->writeVarUint((uint32_t)SerializeOp::rewind);
        m_writer->writeVarUint(m_id);
    }

    void fillRule(FillRule value) override
    {
        if (m_fillRule == value)
        {
            return;
        }
        m_fillRule = value;
        m_writer->writeVarUint((uint32_t)SerializeOp::fillRule);
        m_writer->writeVarUint(m_id);
        m_writer->writeVarUint((uint64_t)value);
    }

    void addPath(CommandPath* path, const Mat2D& transform) override
    {
        RIVE_UNREACHABLE();
    }
    void addRenderPath(RenderPath* path, const Mat2D& transform) override
    {
        RIVE_UNREACHABLE();
    }

    void moveTo(float x, float y) override { RIVE_UNREACHABLE(); }
    void lineTo(float x, float y) override { RIVE_UNREACHABLE(); }
    void cubicTo(float ox, float oy, float ix, float iy, float x, float y)
        override
    {
        RIVE_UNREACHABLE();
    }
    void close() override { RIVE_UNREACHABLE(); }

    void addRawPath(const RawPath& path) override
    {
        m_rawPath.addPath(path, nullptr);

        m_writer->writeVarUint((uint32_t)SerializeOp::addRawPath);
        m_writer->writeVarUint(m_id);
        serializeRawPath(m_writer, path);
    }

    SerializingRenderPath(BinaryWriter* writer, uint64_t id) :
        m_id(id), m_writer(writer)
    {
        m_writer->writeVarUint((uint32_t)SerializeOp::makeRenderPath);
        m_writer->writeVarUint(m_id);
    }

    SerializingRenderPath(BinaryWriter* writer,
                          uint64_t id,
                          const RawPath& path,
                          FillRule fillRule) :
        m_id(id), m_fillRule(fillRule), m_rawPath(path), m_writer(writer)
    {
        m_writer->writeVarUint((uint32_t)SerializeOp::makeRenderPath);
        m_writer->writeVarUint(m_id);
        this->fillRule(fillRule);
        addRawPath(path);
    }

    uint64_t id() const { return m_id; }

private:
    uint64_t m_id;
    FillRule m_fillRule = FillRule::nonZero;
    RawPath m_rawPath;
    BinaryWriter* m_writer;
};

class SerializingRenderBuffer : public RenderBuffer
{
public:
    SerializingRenderBuffer(BinaryWriter* writer,
                            uint64_t id,
                            RenderBufferType type,
                            RenderBufferFlags flags,
                            size_t sizeInBytes) :
        RenderBuffer(type, flags, sizeInBytes),
        m_writer(writer),
        m_bytes(sizeInBytes),
        m_id(id)
    {
        m_writer->writeVarUint((uint32_t)SerializeOp::makeRenderBuffer);
        m_writer->writeVarUint(m_id);
        m_writer->writeVarUint((uint64_t)sizeInBytes);
        m_writer->writeVarUint((uint32_t)type);
        m_writer->writeVarUint((uint32_t)flags);
    }

    uint64_t id() const { return m_id; }
    void* onMap() override { return m_bytes.data(); }
    void onUnmap() override
    {
        switch (type())
        {
            case RenderBufferType::index:
                m_writer->writeVarUint(
                    (uint32_t)SerializeOp::setIndexBufferData);
                break;
            case RenderBufferType::vertex:
                m_writer->writeVarUint(
                    (uint32_t)SerializeOp::setVertexBufferData);
                break;
            default:
                RIVE_UNREACHABLE();
        }
        m_writer->writeVarUint(m_id);
        switch (type())
        {
            case RenderBufferType::vertex:
            {
                auto count = m_bytes.size() / sizeof(float);
                auto floatBuffer = reinterpret_cast<float*>(m_bytes.data());
                for (size_t i = 0; i < count; i++)
                {
                    m_writer->writeFloat(floatBuffer[i]);
                }
                break;
            }
            case RenderBufferType::index:
            {
                auto count = m_bytes.size() / sizeof(uint16_t);
                auto shortBuffer = reinterpret_cast<uint16_t*>(m_bytes.data());
                for (size_t i = 0; i < count; i++)
                {
                    m_writer->writeVarUint((uint32_t)shortBuffer[i]);
                }
                break;
            }
        }
    }

private:
    BinaryWriter* m_writer;
    std::vector<uint8_t> m_bytes;
    uint64_t m_id;
};

rcp<RenderBuffer> SerializingFactory::makeRenderBuffer(RenderBufferType type,
                                                       RenderBufferFlags flags,
                                                       size_t size)
{
    return make_rcp<SerializingRenderBuffer>(&m_writer,
                                             m_renderBufferId++,
                                             type,
                                             flags,
                                             size);
}

rcp<RenderShader> SerializingFactory::makeLinearGradient(
    float sx,
    float sy,
    float ex,
    float ey,
    const ColorInt colors[], // [count]
    const float stops[],     // [count]
    size_t count)
{
    auto id = m_renderShaderId++;
    m_writer.writeVarUint((uint32_t)SerializeOp::makeLinearGradient);
    m_writer.writeVarUint(id);
    m_writer.writeVarUint((uint64_t)count);
    for (auto i = 0; i < count; i++)
    {
        m_writer.writeVarUint(colors[i]);
        m_writer.writeFloat(stops[i]);
    }
    m_writer.writeFloat(sx);
    m_writer.writeFloat(sy);
    m_writer.writeFloat(ex);
    m_writer.writeFloat(ey);

    return make_rcp<SerializingRenderShader>(id);
}

rcp<RenderShader> SerializingFactory::makeRadialGradient(
    float cx,
    float cy,
    float radius,
    const ColorInt colors[], // [count]
    const float stops[],     // [count]
    size_t count)
{
    auto id = m_renderShaderId++;
    m_writer.writeVarUint((uint32_t)SerializeOp::makeRadialGradient);
    m_writer.writeVarUint(id);
    m_writer.writeVarUint((uint64_t)count);
    for (auto i = 0; i < count; i++)
    {
        m_writer.writeVarUint(colors[i]);
        m_writer.writeFloat(stops[i]);
    }
    m_writer.writeFloat(cx);
    m_writer.writeFloat(cy);
    m_writer.writeFloat(radius);

    return make_rcp<SerializingRenderShader>(id);
}

rcp<RenderPath> SerializingFactory::makeRenderPath(RawPath& rawPath,
                                                   FillRule fillRule)
{
    return make_rcp<SerializingRenderPath>(&m_writer,
                                           m_renderPathId++,
                                           rawPath,
                                           fillRule);
}

rcp<RenderPath> SerializingFactory::makeEmptyRenderPath()
{
    return make_rcp<SerializingRenderPath>(&m_writer, m_renderPathId++);
}

rcp<RenderPaint> SerializingFactory::makeRenderPaint()
{
    return make_rcp<SerializingRenderPaint>(&m_writer, m_renderPaintId++);
}

rcp<RenderImage> SerializingFactory::decodeImage(Span<const uint8_t> data)
{
    auto id = m_renderImageId++;
    m_writer.writeVarUint((uint32_t)SerializeOp::decodeImage);
    m_writer.writeVarUint(id);
    m_writer.writeVarUint((uint64_t)data.size());
    m_writer.write(data.data(), data.size());

    auto bitmap = Bitmap::decode(data.data(), data.size());
    if (!bitmap)
    {
        return nullptr;
    }

    return make_rcp<SerializingRenderImage>(id,
                                            bitmap->width(),
                                            bitmap->height());
}

class SerializingRenderer : public Renderer
{
public:
    SerializingRenderer(BinaryWriter* writer) : m_writer(writer) {}

    void save() override
    {
        m_writer->writeVarUint((uint32_t)SerializeOp::save);
    }
    void restore() override
    {
        m_writer->writeVarUint((uint32_t)SerializeOp::restore);
    }
    void transform(const Mat2D& mat) override
    {
        m_writer->writeVarUint((uint32_t)SerializeOp::transform);
        for (int i = 0; i < 6; i++)
        {
            m_writer->writeFloat(mat[i]);
        }
    }

    void modulateOpacity(float opacity) override
    {
        m_writer->writeVarUint((uint32_t)SerializeOp::modulateOpacity);
        m_writer->writeFloat(opacity);
    }

    void drawPath(RenderPath* path, RenderPaint* paint) override
    {
        m_writer->writeVarUint((uint32_t)SerializeOp::drawPath);
        m_writer->writeVarUint(static_cast<SerializingRenderPath*>(path)->id());
        m_writer->writeVarUint(
            static_cast<SerializingRenderPaint*>(paint)->id());
    }

    void clipPath(RenderPath* path) override
    {
        m_writer->writeVarUint((uint32_t)SerializeOp::clipPath);
        m_writer->writeVarUint(static_cast<SerializingRenderPath*>(path)->id());
    }

    virtual void drawImage(const RenderImage* image,
                           ImageSampler samplerOptions,
                           BlendMode blendMode,
                           float opacity) override
    {
        m_writer->writeVarUint((uint32_t)SerializeOp::drawImage);
        m_writer->writeVarUint(
            static_cast<const SerializingRenderImage*>(image)->id());
        m_writer->writeVarUint((uint32_t)blendMode);
        m_writer->writeFloat(opacity);
    }

    virtual void drawImageMesh(const RenderImage* image,
                               ImageSampler samplerOptions,
                               rcp<RenderBuffer> positions,
                               rcp<RenderBuffer> uvs,
                               rcp<RenderBuffer> indices,
                               uint32_t vertexCount,
                               uint32_t indexCount,
                               BlendMode blendMode,
                               float opacity) override
    {
        m_writer->writeVarUint((uint32_t)SerializeOp::drawImageMesh);
        m_writer->writeVarUint(
            static_cast<const SerializingRenderImage*>(image)->id());
        m_writer->writeVarUint((uint32_t)blendMode);
        m_writer->writeFloat(opacity);
        m_writer->writeVarUint(
            static_cast<SerializingRenderBuffer*>(positions.get())->id());
        m_writer->writeVarUint(
            static_cast<SerializingRenderBuffer*>(uvs.get())->id());
        m_writer->writeVarUint(
            static_cast<SerializingRenderBuffer*>(indices.get())->id());
    }

private:
    BinaryWriter* m_writer;
};

SerializingFactory::SerializingFactory() : m_writer(&m_buffer)
{
    m_writer.write((const uint8_t*)"SRIV", 4);
    m_writer.writeVarUint((uint32_t)1);
}

std::unique_ptr<Renderer> SerializingFactory::makeRenderer()
{
    return rivestd::make_unique<SerializingRenderer>(&m_writer);
}

void SerializingFactory::addFrame()
{
    Artboard::incFrameId();
    m_writer.writeVarUint((uint32_t)SerializeOp::frame);
}

void SerializingFactory::frameSize(uint32_t width, uint32_t height)
{
    m_writer.writeVarUint((uint32_t)SerializeOp::frameSize);
    m_writer.writeVarUint(width);
    m_writer.writeVarUint(height);
}

void SerializingFactory::save(const char* filename)
{
    FILE* fp = fopen(filename, "wb");
    fwrite(m_buffer.data(), 1, m_buffer.size(), fp);
    fclose(fp);
}

void SerializingFactory::saveTarnished(const char* filename)
{
    auto path = std::string("silvers/tarnished/");
    if (!std::filesystem::exists(path))
    {
        if (!std::filesystem::create_directories(path))
        {
            fprintf(stderr, "failed to create directory %s\n", path.c_str());
        }
    }
    auto fullFileName = path + std::string(filename) + std::string(".sriv");
    save(fullFileName.c_str());
}

static bool varUintMatches(uint64_t op,
                           std::string name,
                           BinaryReader& readerA,
                           BinaryReader& readerB,
                           uint64_t* value = nullptr)
{
    auto valueA = readerA.readVarUint64();
    auto valueB = readerB.readVarUint64();
    if (valueA != valueB)
    {
        fprintf(stderr,
                "%s for %s doesn't match %" PRIu64 " != %" PRIu64 "\n",
                name.c_str(),
                opToName((SerializeOp)op),
                valueA,
                valueB);
        return false;
    }
    if (value != nullptr)
    {
        *value = valueA;
    }
    return true;
}

static bool bytesMatches(uint64_t op,
                         std::string name,
                         uint64_t size,
                         BinaryReader& readerA,
                         BinaryReader& readerB)
{
    for (int i = 0; i < size; i++)
    {
        auto valueA = readerA.readByte();
        auto valueB = readerB.readByte();
        if (valueA != valueB)
        {
            fprintf(stderr,
                    "%s [%i] for %s doesn't match %hhu != %hhu\n",
                    name.c_str(),
                    i,
                    opToName((SerializeOp)op),
                    valueA,
                    valueB);
            return false;
        }
    }
    return true;
}

static bool floatMatches(uint64_t op,
                         std::string name,
                         BinaryReader& readerA,
                         BinaryReader& readerB,
                         float* value = nullptr)
{
    auto valueA = readerA.readFloat32();
    auto valueB = readerB.readFloat32();
    if (std::abs(valueA - valueB) > epsilon)
    {
        fprintf(stderr,
                "%s for %s doesn't match %f != %f\n",
                name.c_str(),
                opToName((SerializeOp)op),
                valueA,
                valueB);
        return false;
    }
    if (value != nullptr)
    {
        *value = valueA;
    }
    return true;
}

static bool shortMatches(uint64_t op,
                         std::string name,
                         BinaryReader& readerA,
                         BinaryReader& readerB,
                         uint16_t* value = nullptr)
{
    auto valueA = readerA.readUint16();
    auto valueB = readerB.readUint16();
    if (valueA != valueB)
    {
        fprintf(stderr,
                "%s for %s doesn't match %i != %i\n",
                name.c_str(),
                opToName((SerializeOp)op),
                valueA,
                valueB);
        return false;
    }
    if (value != nullptr)
    {
        *value = valueA;
    }
    return true;
}

static bool vec2DMatches(uint64_t op,
                         std::string name,
                         BinaryReader& readerA,
                         BinaryReader& readerB,
                         Vec2D* value = nullptr)
{
    auto ax = readerA.readFloat32();
    auto ay = readerA.readFloat32();

    auto bx = readerB.readFloat32();
    auto by = readerB.readFloat32();

    // if (ax != bx || ay != by)
    if (rive::Vec2D::distance(Vec2D(ax, ay), Vec2D(bx, by)) > epsilon)
    {
        fprintf(stderr,
                "%s for %s doesn't match (%f, %f) != (%f, %f)\n",
                name.c_str(),
                opToName((SerializeOp)op),
                ax,
                ay,
                bx,
                by);
        return false;
    }
    if (value != nullptr)
    {
        *value = Vec2D(ax, ay);
    }
    return true;
}

static bool gradientMatches(uint64_t op,
                            std::string name,
                            BinaryReader& readerA,
                            BinaryReader& readerB,
                            Vec2D* value = nullptr)
{
    if (!varUintMatches(op,
                        std::string("make_") + name + std::string("_id"),
                        readerA,
                        readerB))
    {
        return false;
    }
    uint64_t count = 0;
    if (!varUintMatches(op,
                        std::string("make_") + name + std::string("_count"),
                        readerA,
                        readerB,
                        &count))
    {
        return false;
    }
    for (size_t i = 0; i < count; i++)
    {
        std::string colorName = std::string("make_") + name +
                                std::string("_color_") + std::to_string(i);
        if (!varUintMatches(op, colorName, readerA, readerB))
        {
            return false;
        }
        std::string stopName = std::string("make_") + name +
                               std::string("_stop_") + std::to_string(i);
        if (!floatMatches(op, stopName, readerA, readerB))
        {
            return false;
        }
    }
    return true;
}

bool advancedMatch(std::vector<uint8_t>& fileA, std::vector<uint8_t>& fileB)
{
    BinaryReader readerA(fileA);
    BinaryReader readerB(fileB);
    if (readerA.readByte() != 'S' || readerA.readByte() != 'R' ||
        readerA.readByte() != 'I' || readerA.readByte() != 'V')
    {
        fprintf(stderr, "advancedMatch: invalid header A\n");
        return false;
    }
    if (readerB.readByte() != 'S' || readerB.readByte() != 'R' ||
        readerB.readByte() != 'I' || readerB.readByte() != 'V')
    {
        fprintf(stderr, "advancedMatch: invalid header B\n");
        return false;
    }

    if (readerA.readVarUint64() != 1 || readerB.readVarUint64() != 1)
    {
        fprintf(stderr, "advancedMatch: invalid version\n");
        return false;
    }
    std::unordered_map<uint64_t, uint64_t> renderBufferSizes;
    while (!readerA.reachedEnd())
    {
        if (readerB.reachedEnd())
        {
            fprintf(stderr, "generated file is shorter.\n");
            return false;
        }
        auto opA = readerA.readVarUint64();
        auto opB = readerB.readVarUint64();
        if (opA != opB)
        {
            fprintf(stderr,
                    "expected %s but got %s\n",
                    opToName((SerializeOp)opA),
                    opToName((SerializeOp)opB));
        }
        switch ((SerializeOp)opA)
        {
            case SerializeOp::makeRenderBuffer:
            {
                uint64_t id = 0;
                uint64_t size = 0;
                if (!varUintMatches(opA,
                                    "make_renderbuffer_id",
                                    readerA,
                                    readerB,
                                    &id))
                {
                    return false;
                }
                if (!varUintMatches(opA,
                                    "make_renderbuffer_size",
                                    readerA,
                                    readerB,
                                    &size))
                {
                    return false;
                }
                if (!varUintMatches(opA,
                                    "make_renderbuffer_flags",
                                    readerA,
                                    readerB))
                {
                    return false;
                }
                renderBufferSizes[id] = size;
                break;
            }
            case SerializeOp::makeLinearGradient:
                if (!gradientMatches(opA, "lineargradient", readerA, readerB))
                {
                    return false;
                }
                if (!vec2DMatches(opA,
                                  "make_lineargradient_start",
                                  readerA,
                                  readerB))
                {
                    return false;
                }
                if (!vec2DMatches(opA,
                                  "make_lineargradient_end",
                                  readerA,
                                  readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::makeRadialGradient:
                if (!gradientMatches(opA, "lineargradient", readerA, readerB))
                {
                    return false;
                }
                if (!vec2DMatches(opA,
                                  "make_lineargradient_center",
                                  readerA,
                                  readerB))
                {
                    return false;
                }
                if (!floatMatches(opA,
                                  "make_lineargradient_radius",
                                  readerA,
                                  readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::makeRenderPath:
                if (!varUintMatches(opA,
                                    "make_renderpath_id",
                                    readerA,
                                    readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::makeRenderPaint:
                if (!varUintMatches(opA,
                                    "make_renderpaint_id",
                                    readerA,
                                    readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::decodeImage:
            {
                if (!varUintMatches(opA, "decodeimage_id", readerA, readerB))
                {
                    return false;
                }
                uint64_t size = 0;
                if (!varUintMatches(opA,
                                    "decodeimage_size",
                                    readerA,
                                    readerB,
                                    &size))
                {
                    return false;
                }
                if (!bytesMatches(opA,
                                  "decodeimage_bytes",
                                  size,
                                  readerA,
                                  readerB))
                {
                    return false;
                }
                break;
            }
            case SerializeOp::save:
                break;
            case SerializeOp::restore:
                break;
            case SerializeOp::transform:
                for (int i = 0; i < 6; i++)
                {
                    if (!floatMatches(opA,
                                      std::string("transform[") +
                                          std::to_string(i) + std::string("]"),
                                      readerA,
                                      readerB))
                    {
                        return false;
                    }
                }
                break;
            case SerializeOp::drawPath:
                if (!varUintMatches(opA, "drawpath_id", readerA, readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA, "drawpath_paint_id", readerA, readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::clipPath:
                if (!varUintMatches(opA, "clippath_id", readerA, readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::drawImage:
                if (!varUintMatches(opA, "drawimage_id", readerA, readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA,
                                    "drawimage_blendmode",
                                    readerA,
                                    readerB))
                {
                    return false;
                }
                if (!floatMatches(opA, "drawimage_opacity", readerA, readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::drawImageMesh:
                if (!varUintMatches(opA, "drawimagemesh_id", readerA, readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA,
                                    "drawimagemesh_blendmode",
                                    readerA,
                                    readerB))
                {
                    return false;
                }
                if (!floatMatches(opA,
                                  "drawimagemesh_opacity",
                                  readerA,
                                  readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA,
                                    "drawimagemesh_vertex_id",
                                    readerA,
                                    readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA,
                                    "drawimagemesh_uv_id",
                                    readerA,
                                    readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA,
                                    "drawimagemesh_index_id",
                                    readerA,
                                    readerB))
                {
                    return false;
                }
                break;

            case SerializeOp::setVertexBufferData:
            {
                uint64_t id = 0;
                if (!varUintMatches(opA,
                                    "setvertexbufferdata_id",
                                    readerA,
                                    readerB,
                                    &id))
                {
                    return false;
                }
                if (renderBufferSizes.find(id) == renderBufferSizes.end())
                {
                    fprintf(stderr,
                            "could not find render buffer with id: %" PRIu64
                            "\n",
                            id);
                    return false;
                }
                uint64_t size = renderBufferSizes[id];
                uint64_t floatCount = size / sizeof(float);
                for (int i = 0; i < floatCount; i++)
                {
                    if (!floatMatches(opA,
                                      std::string("setvertexbufferdata_[") +
                                          std::to_string(i) + std::string("]"),
                                      readerA,
                                      readerB))
                    {
                        return false;
                    }
                }
                break;
            }
            case SerializeOp::setIndexBufferData:
            {
                uint64_t id = 0;
                if (!varUintMatches(opA,
                                    "setindexbufferdata_id",
                                    readerA,
                                    readerB,
                                    &id))
                {
                    return false;
                }
                if (renderBufferSizes.find(id) == renderBufferSizes.end())
                {
                    fprintf(stderr,
                            "could not find render buffer with id: %" PRIu64
                            "\n",
                            id);
                    return false;
                }
                uint64_t size = renderBufferSizes[id];
                uint64_t shortCount = size / sizeof(uint16_t);
                for (int i = 0; i < shortCount; i++)
                {
                    if (!shortMatches(opA,
                                      std::string("setindexbufferdata_[") +
                                          std::to_string(i) + std::string("]"),
                                      readerA,
                                      readerB))
                    {
                        return false;
                    }
                }
                break;
            }

            // RenderPath
            case SerializeOp::addRawPath:
            {
                uint64_t verbCount = 0;
                uint64_t pointCount = 0;
                if (!varUintMatches(opA, "addrawpath_id", readerA, readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA,
                                    "addrawpath_verb_count",
                                    readerA,
                                    readerB,
                                    &verbCount))
                {
                    return false;
                }
                for (int i = 0; i < verbCount; i++)
                {
                    if (!varUintMatches(opA,
                                        std::string("addrawpath_verb[") +
                                            std::to_string(i) +
                                            std::string("]"),
                                        readerA,
                                        readerB))
                    {
                        return false;
                    }
                }
                if (!varUintMatches(opA,
                                    "addrawpath_point_count",
                                    readerA,
                                    readerB,
                                    &pointCount))
                {
                    return false;
                }
                for (int i = 0; i < pointCount; i++)
                {
                    if (!vec2DMatches(opA,
                                      std::string("addrawpath_point[") +
                                          std::to_string(i) + std::string("]"),
                                      readerA,
                                      readerB))
                    {
                        return false;
                    }
                }
            }
            break;
            case SerializeOp::rewind:
                if (!varUintMatches(opA, "rewind_path_id", readerA, readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::fillRule:
                if (!varUintMatches(opA, "fillrule_path_id", readerA, readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA, "fillrule_value", readerA, readerB))
                {
                    return false;
                }
                break;

            // RenderPaint
            case SerializeOp::style:
                if (!varUintMatches(opA, "style_paint_id", readerA, readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA, "style_value", readerA, readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::color:
                if (!varUintMatches(opA, "color_paint_id", readerA, readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA, "color_value", readerA, readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::thickness:
                if (!varUintMatches(opA,
                                    "thickness_paint_id",
                                    readerA,
                                    readerB))
                {
                    return false;
                }
                if (!floatMatches(opA, "thickness_value", readerA, readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::join:
                if (!varUintMatches(opA, "join_paint_id", readerA, readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA, "join_value", readerA, readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::cap:
                if (!varUintMatches(opA, "cap_paint_id", readerA, readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA, "cap_value", readerA, readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::feather:
                if (!varUintMatches(opA, "feather_paint_id", readerA, readerB))
                {
                    return false;
                }
                if (!floatMatches(opA, "feather_value", readerA, readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::blendMode:
                if (!varUintMatches(opA,
                                    "blendmode_paint_id",
                                    readerA,
                                    readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA, "blendmode_value", readerA, readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::shader:
                if (!varUintMatches(opA,
                                    "setgradient_paint_id",
                                    readerA,
                                    readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA, "setgradient_value", readerA, readerB))
                {
                    return false;
                }
                break;

            case SerializeOp::frame:
                break;
            case SerializeOp::frameSize:
                if (!varUintMatches(opA, "framesize_width", readerA, readerB))
                {
                    return false;
                }
                if (!varUintMatches(opA, "framesize_height", readerA, readerB))
                {
                    return false;
                }
                break;
            case SerializeOp::modulateOpacity:
                if (!floatMatches(opA,
                                  "modulateopacity_value",
                                  readerA,
                                  readerB))
                {
                    return false;
                }
                break;
        }
    }
    if (!readerB.reachedEnd())
    {
        fprintf(stderr, "generated file is longer, otherwise matches.\n");
        return false;
    }
    // for (size_t i = 0; i < length; i++)
    // {
    //     if (fileA[i] != fileB[i])
    //     {
    //         fprintf(stderr,
    //                 "SerializingFactory::matches - %s buffer did not match "
    //                 "generated one.\n",
    //                 filename);

    //         return false;
    //     }
    // }
    return true;
}

bool SerializingFactory::matches(const char* filename)
{
    auto fullFileName =
        std::string("silvers/") + std::string(filename) + std::string(".sriv");
    const char* rebaseline = getenv("REBASELINE_SILVERS");
    if (rebaseline != nullptr)
    {
        save(fullFileName.c_str());
        return true;
    }

    FILE* fp = fopen(fullFileName.c_str(), "rb");
    if (fp == nullptr)
    {
        fprintf(stderr,
                "SerializingFactory::matches - %s is missing\n",
                fullFileName.c_str());
        return false;
    }
    fseek(fp, 0, SEEK_END);
    const size_t length = ftell(fp);
    if (m_buffer.size() != length)
    {
        fprintf(stderr,
                "SerializingFactory::matches - %s size differs from generated "
                "one %zu != %zu.\n",
                filename,
                m_buffer.size(),
                length);
        fclose(fp);
        saveTarnished(filename);
        return false;
    }

    fseek(fp, 0, SEEK_SET);
    std::vector<uint8_t> existing(length);
    if (fread(existing.data(), 1, length, fp) != length)
    {
        fprintf(stderr,
                "SerializingFactory::matches - %s could not be read.\n",
                filename);
        return false;
    }
    fclose(fp);

    if (!advancedMatch(existing, m_buffer))
    {
        saveTarnished(filename);
        return false;
    }
    return true;
}