//
//  Created by Ada <ada@thingvellir.net> on 2025-02-04
//  Copyright 2025 Overte e.V.
//
//  Distributed under the Apache license, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html

#include "CanvasEntityItem.h"

#include <QtCore/QDebug>
#include <QImage>
#include <QPainter>

#include "EntitiesLogging.h"
#include "EntityItemProperties.h"
#include "EntityTreeElement.h"

EntityItemPointer CanvasEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
    std::shared_ptr<CanvasEntityItem> entity(new CanvasEntityItem(entityID), [](CanvasEntityItem* ptr) { ptr->deleteLater(); });
    entity->setProperties(properties);
    return entity;
}

CanvasEntityItem::CanvasEntityItem(const EntityItemID& entityItemID) : EntityItem(entityItemID) {
    _type = EntityTypes::Canvas;
}

CanvasEntityItem::~CanvasEntityItem() {}

void CanvasEntityItem::debugDump() const {
    qCDebug(entities) << "CanvasEntityItem id:" << getEntityItemID() << "---------------------------------------------";
    qCDebug(entities) << "    name:" << _name;
    qCDebug(entities) << "    position:" << debugTreeVector(getWorldPosition());
    qCDebug(entities) << "    dimensions:" << debugTreeVector(getScaledDimensions());
    qCDebug(entities) << "    editedAgo:" << debugTime(getLastEdited(), usecTimestampNow());
    qCDebug(entities) << "    pointer:" << this;

@Canvas_ENTITY_DEBUG@

}

void CanvasEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
                                          EntityTreeElementExtraEncodeDataPointer entityTreeElementExtraEncodeData,
                                          EntityPropertyFlags& requestedProperties,
                                          EntityPropertyFlags& propertyFlags,
                                          EntityPropertyFlags& propertiesDidntFit,
                                          int& propertyCount,
                                          OctreeElement::AppendState& appendState) const {

    bool successPropertyFits = true;

@Canvas_ENTITY_APPEND@

}

int CanvasEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
                                                       ReadBitstreamToTreeParams& args,
                                                       EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
                                                       bool& somethingChanged) {
    int bytesRead = 0;
    const unsigned char* dataAt = data;

@Canvas_ENTITY_READ@

    return bytesRead;
}

EntityPropertyFlags CanvasEntityItem::getEntityProperties(EncodeBitstreamParams& params) const {
    EntityPropertyFlags requestedProperties = EntityItem::getEntityProperties(params);

@Canvas_REQUESTED_PROPS@

    return requestedProperties;
}

bool CanvasEntityItem::setSubClassProperties(const EntityItemProperties& properties) {
    bool somethingChanged = false;

@Canvas_ENTITY_SET_FROM@

    return somethingChanged;
}

EntityItemProperties CanvasEntityItem::getProperties(const EntityPropertyFlags& desiredProperties, bool allowEmptyDesiredProperties) const {
    EntityItemProperties properties = EntityItem::getProperties(desiredProperties, allowEmptyDesiredProperties); // get the properties from our base class

@Canvas_ENTITY_COPY_TO@

    return properties;
}

int CanvasEntityItem::expectedSize() const {
    return (4 * getWidth() * getHeight());
}

void CanvasEntityItem::updateBufferSize() {
    const std::lock_guard<std::recursive_mutex> dataLock(_imageDataMutex);

    auto size = expectedSize();

    // size is correct, don't need to resize
    if (_imageData.length() == size) { return; }

    _imageData.resize(size);

    // initialize the whole canvas to black, old pixels don't make sense anymore
    std::memset(_imageData.data(), 0, size);
    _imageDataWidth = getWidth();
    _imageDataHeight = getHeight();
}

void CanvasEntityItem::setImageData(const CanvasImage& image) {
    const std::lock_guard<std::recursive_mutex> dataLock(_imageDataMutex);

    updateBufferSize();

    if (
        image.buffer.length() != _imageData.length() ||
        _imageDataWidth != image.width ||
        _imageDataHeight != image.height
    ) {
        return;
    }

    std::memcpy(_imageData.data(), image.buffer.constData(), _imageData.length());
}

void CanvasEntityItem::paintCommands(const QVector<CanvasCommand>& queue) {
    using Variant = CanvasCommand::Variant;
    using RenderHint = CanvasCommand::RenderHint;

    const std::lock_guard<std::recursive_mutex> dataLock(_imageDataMutex);
    const std::lock_guard<std::recursive_mutex> commandQueueLock(_commandQueueMutex);

    if (_commandQueue.length() == 0) { return; }

    updateBufferSize();

    // NOTE: The Qt docs say that ARGB32_Premultiplied performs better,
    // but we can't use it as a texture without shader magic to un-premultiply
    // the alpha ourselves.
    auto destImage = QImage(reinterpret_cast<uint8_t *>(_imageData.data()), _imageDataWidth, _imageDataHeight, QImage::Format_RGBA8888);
    QPen pen(Qt::black, 1.0, Qt::SolidLine, Qt::SquareCap, Qt::MiterJoin);
    QBrush brush(Qt::black);
    QPainter p;
    p.begin(&destImage);
    p.setCompositionMode(QPainter::CompositionMode_SourceOver);
    p.setRenderHint(QPainter::Antialiasing, true);
    p.setRenderHint(QPainter::TextAntialiasing, true);
    p.setRenderHint(QPainter::SmoothPixmapTransform, true);

    for (int i = 0; i < queue.length(); i++) {
        auto cmd = queue[i];

        switch (cmd.kind) {
            case Variant::SetStrokeWidth: {
                pen.setWidthF(cmd._float[0]);
                p.setPen(pen);
                break;
            }

            case Variant::SetColor: {
                auto color = cmd._color;
                pen.setColor(color);
                brush.setColor(color);
                p.setPen(pen);
                p.setBrush(brush);
                break;
            }

            case Variant::SetHints: {
                p.setRenderHint(QPainter::Antialiasing, (cmd._int[0] & RenderHint::NoPrimitiveAntialiasing) == 0);
                p.setRenderHint(QPainter::TextAntialiasing, (cmd._int[0] & RenderHint::NoTextAntialiasing) == 0);
                p.setRenderHint(QPainter::SmoothPixmapTransform, (cmd._int[0] & RenderHint::NearestImageScaling) == 0);
                break;
            }

            case Variant::SetBlendMode: {
                p.setCompositionMode(static_cast<QPainter::CompositionMode>(cmd._int[0]));
                break;
            }

            case Variant::SetFont: {
                // QT6TODO: Qt6 uses normal 1-1000 OpenType weight units,
                // this hack won't be necessary there.

                // Sigh… why did you have to do your own thing, Qt?
                // Basically everything else uses 1-1000, Qt uses 0-99.
                // CSS normal and bold are 400 and 700, they're 50 and 75 in Qt.
                // For now, divide by 10 and add 10, which isn't perfect, but close enough
                int weight = (cmd._int[1] / 10) + 10;
                p.setFont(QFont(cmd._text, cmd._int[0], weight, cmd._int[2]));
                break;
            }

            case Variant::ClearRect: {
                // FIXME: why is eraseRect not working??
                #if 0
                auto currentBlendMode = p.compositionMode();
                p.setCompositionMode(QPainter::CompositionMode_Clear);
                p.eraseRect(cmd._rect);
                p.setCompositionMode(currentBlendMode);
                #else
                _imageData.fill(0);
                #endif
                break;
            }

            case Variant::FillPath: {
                p.fillPath(cmd._paintPath, brush);
                break;
            }

            case Variant::FillRect: {
                p.fillRect(cmd._rect, brush);
                break;
            }

            case Variant::FillEllipse: {
                auto pathHack = QPainterPath();
                pathHack.addEllipse(cmd._rect);
                p.fillPath(pathHack, brush);
                break;
            }

            case Variant::FillText: {
                // unbounded text
                if (cmd._rect.width() == 0.0 && cmd._rect.height() == 0.0) {
                    p.drawText(QPointF(cmd._rect.x(), cmd._rect.y()), cmd._text);
                } else {
                    p.drawText(cmd._rect, cmd._int[0], cmd._text);
                }
                break;
            }

            case Variant::StrokePath: {
                auto prevFill = p.brush();
                p.setBrush(Qt::transparent);
                p.strokePath(cmd._paintPath, pen);
                p.setBrush(prevFill);
                break;
            }

            case Variant::StrokeRect: {
                auto prevFill = p.brush();
                p.setBrush(Qt::transparent);
                p.drawRect(cmd._rect);
                p.setBrush(prevFill);
                break;
            }

            case Variant::StrokeArc: {
                auto prevFill = p.brush();
                p.setBrush(Qt::transparent);
                p.drawArc(cmd._rect, cmd._float[0] * 16, cmd._float[1] * 16);
                p.setBrush(prevFill);
                break;
            }

            case Variant::StrokeEllipse: {
                auto prevFill = p.brush();
                p.setBrush(Qt::transparent);
                p.drawEllipse(cmd._rect);
                p.setBrush(prevFill);
                break;
            }

            case Variant::Point: {
                p.drawPoint(cmd._point);
                break;
            }

            case Variant::Line: {
                p.drawLine(cmd._line);
                break;
            }

            case Variant::ImageCopy: {
                if (cmd._image.buffer.length() != static_cast<int>(4 * cmd._image.width * cmd._image.height)) {
                    qCCritical(entities) << "CanvasEntityItem::paintCommands: Source CanvasImage buffer has incorrect size, expected " << (4 * cmd._image.width * cmd._image.height) << ", got " << cmd._image.buffer.length();
                    break;
                }
                auto img = QImage(reinterpret_cast<const uint8_t*>(cmd._image.buffer.constData()), cmd._image.width, cmd._image.height, QImage::Format_RGBA8888);
                p.drawImage(cmd._rect2, img, cmd._rect);
                break;
            }

            default:
                qCCritical(entities) << "CanvasEntityItem::paintCommands: Invalid command at index " << i;
                break;

        }
    }

    p.end();
    _commandQueue.clear();
}

void CanvasEntityItem::commit() {
    paintCommands(_commandQueue);
    _imageDataDirty.store(true);
    setNeedsRenderUpdate(true);
    somethingChangedNotification();
}