/*
 * Copyright 2006, 2023, Haiku. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus <superstippi@gmx.de>
 *              Zardshard
 */

#include "FlatIconImporter.h"

#include <new>
#include <stdio.h>

#include <Archivable.h>
#include <DataIO.h>
#include <Message.h>

#include "AffineTransformer.h"
#include "AutoDeleter.h"
#include "ContourTransformer.h"
#include "FlatIconFormat.h"
#include "GradientTransformable.h"
#include "Icon.h"
#include "LittleEndianBuffer.h"
#include "PathCommandQueue.h"
#include "PathSourceShape.h"
#include "PerspectiveTransformer.h"
#include "Shape.h"
#include "StrokeTransformer.h"
#include "Style.h"
#include "VectorPath.h"

using std::nothrow;

_USING_ICON_NAMESPACE


// constructor
FlatIconImporter::FlatIconImporter()
#ifdef ICON_O_MATIC
        : Importer()
#endif
{
}

// destructor
FlatIconImporter::~FlatIconImporter()
{
}

// Import
status_t
FlatIconImporter::Import(Icon* icon, BPositionIO* stream)
{
#ifdef ICON_O_MATIC
        status_t ret = Init(icon);
        if (ret < B_OK)
                return ret;
#else
        status_t ret;
#endif

        // seek around in the stream to figure out the size
        off_t size = stream->Seek(0, SEEK_END);
        if (stream->Seek(0, SEEK_SET) != 0)
                return B_ERROR;

        // we chicken out on anything larger than 256k
        if (size <= 0 || size > 256 * 1024)
                return B_BAD_VALUE;

        // read the entire stream into a buffer
        LittleEndianBuffer buffer(size);
        if (!buffer.Buffer())
                return B_NO_MEMORY;

        if (stream->Read(buffer.Buffer(), size) != size)
                return B_ERROR;

        ret = _ParseSections(buffer, icon);

        return ret;
}

// Import
status_t
FlatIconImporter::Import(Icon* icon, uint8* _buffer, size_t size)
{
#ifdef ICON_O_MATIC
        status_t ret = Init(icon);
        if (ret < B_OK)
                return ret;
#endif

        if (!_buffer)
                return B_BAD_VALUE;

        // attach LittleEndianBuffer to buffer
        LittleEndianBuffer buffer(_buffer, size);

        return _ParseSections(buffer, icon);
}

// #pragma mark -

// _ParseSections
status_t
FlatIconImporter::_ParseSections(LittleEndianBuffer& buffer, Icon* icon)
{
        // test if this is an icon at all
        uint32 magic;
        if (!buffer.Read(magic) || magic != FLAT_ICON_MAGIC)
                return B_BAD_TYPE;

        // styles
        Container<Style>* styles = icon->Styles();
        status_t ret = _ParseStyles(buffer, styles);
        if (ret < B_OK) {
                printf("FlatIconImporter::_ParseSections() - "
                           "error parsing styles: %s\n", strerror(ret));
                return ret;
        }

        // paths
        Container<VectorPath>* paths = icon->Paths();
        ret = _ParsePaths(buffer, paths);
        if (ret < B_OK) {
                printf("FlatIconImporter::_ParseSections() - "
                           "error parsing paths: %s\n", strerror(ret));
                return ret;
        }

        // shapes
        ret = _ParseShapes(buffer, styles, paths, icon->Shapes());
        if (ret < B_OK) {
                printf("FlatIconImporter::_ParseSections() - "
                           "error parsing shapes: %s\n", strerror(ret));
                return ret;
        }

        return B_OK;
}

// _ReadTransformable
static bool
_ReadTransformable(LittleEndianBuffer& buffer, Transformable* transformable)
{
        int32 matrixSize = Transformable::matrix_size;
        double matrix[matrixSize];
        for (int32 i = 0; i < matrixSize; i++) {
                float value;
                if (!read_float_24(buffer, value))
                        return false;
                matrix[i] = value;
        }
        transformable->LoadFrom(matrix);
        return true;
}

// _ReadTranslation
static bool
_ReadTranslation(LittleEndianBuffer& buffer, Transformable* transformable)
{
        BPoint t;
        if (read_coord(buffer, t.x) && read_coord(buffer, t.y)) {
                transformable->TranslateBy(t);
                return true;
        }

        return false;
}

// _ReadColorStyle
static Style*
_ReadColorStyle(LittleEndianBuffer& buffer, bool alpha, bool gray)
{
        rgb_color color;
        if (alpha) {
                if (gray) {
                        if (!buffer.Read(color.red)
                                || !buffer.Read(color.alpha))
                                return NULL;
                        color.green = color.blue = color.red;
                } else {
                        if (!buffer.Read((uint32&)color))
                                return NULL;
                }
        } else {
                color.alpha = 255;
                if (gray) {
                        if (!buffer.Read(color.red))
                                return NULL;
                        color.green = color.blue = color.red;
                } else {
                        if (!buffer.Read(color.red)
                                || !buffer.Read(color.green)
                                || !buffer.Read(color.blue))
                                return NULL;
                }
        }
        return new (nothrow) Style(color);
}

// _ReadGradientStyle
static Style*
_ReadGradientStyle(LittleEndianBuffer& buffer)
{
        Style* style = new (nothrow) Style();
        if (!style)
                return NULL;

        ObjectDeleter<Style> styleDeleter(style);

        uint8 gradientType;
        uint8 gradientFlags;
        uint8 gradientStopCount;
        if (!buffer.Read(gradientType)
                || !buffer.Read(gradientFlags)
                || !buffer.Read(gradientStopCount)) {
                return NULL;
        }

        Gradient gradient(true);
                // empty gradient

        gradient.SetType((gradients_type)gradientType);
        // TODO: support more stuff with flags
        // ("inherits transformation" and so on)
        if (gradientFlags & GRADIENT_FLAG_TRANSFORM) {
                if (!_ReadTransformable(buffer, &gradient))
                        return NULL;
        }

        bool alpha = !(gradientFlags & GRADIENT_FLAG_NO_ALPHA);
        bool gray = gradientFlags & GRADIENT_FLAG_GRAYS;

        for (int32 i = 0; i < gradientStopCount; i++) {
                uint8 stopOffset;
                rgb_color color;

                if (!buffer.Read(stopOffset))
                        return NULL;

                if (alpha) {
                        if (gray) {
                                if (!buffer.Read(color.red)
                                        || !buffer.Read(color.alpha))
                                        return NULL;
                                color.green = color.blue = color.red;
                        } else {
                                if (!buffer.Read((uint32&)color))
                                        return NULL;
                        }
                } else {
                        color.alpha = 255;
                        if (gray) {
                                if (!buffer.Read(color.red))
                                        return NULL;
                                color.green = color.blue = color.red;
                        } else {
                                if (!buffer.Read(color.red)
                                        || !buffer.Read(color.green)
                                        || !buffer.Read(color.blue)) {
                                        return NULL;
                                }
                        }
                }

                gradient.AddColor(color, stopOffset / 255.0);
        }

        style->SetGradient(&gradient);

        styleDeleter.Detach();
        return style;
}

// _ParseStyles
status_t
FlatIconImporter::_ParseStyles(LittleEndianBuffer& buffer,
                                                           Container<Style>* styles)
{
        uint8 styleCount;
        if (!buffer.Read(styleCount))
                return B_ERROR;

        for (int32 i = 0; i < styleCount; i++) {
                uint8 styleType;
                if (!buffer.Read(styleType))
                        return B_ERROR;
                Style* style = NULL;
                if (styleType == STYLE_TYPE_SOLID_COLOR) {
                        // solid color
                        style = _ReadColorStyle(buffer, true, false);
                        if (!style)
                                return B_NO_MEMORY;
                } else if (styleType == STYLE_TYPE_SOLID_COLOR_NO_ALPHA) {
                        // solid color without alpha
                        style = _ReadColorStyle(buffer, false, false);
                        if (!style)
                                return B_NO_MEMORY;
                } else if (styleType == STYLE_TYPE_SOLID_GRAY) {
                        // solid gray plus alpha
                        style = _ReadColorStyle(buffer, true, true);
                        if (!style)
                                return B_NO_MEMORY;
                } else if (styleType == STYLE_TYPE_SOLID_GRAY_NO_ALPHA) {
                        // solid gray without alpha
                        style = _ReadColorStyle(buffer, false, true);
                        if (!style)
                                return B_NO_MEMORY;
                } else if (styleType == STYLE_TYPE_GRADIENT) {
                        // gradient
                        style = _ReadGradientStyle(buffer);
                        if (!style)
                                return B_NO_MEMORY;
                } else {
                        // unkown style type, skip tag
                        uint16 tagLength;
                        if (!buffer.Read(tagLength))
                                return B_ERROR;
                        buffer.Skip(tagLength);
                        continue;
                }
                // add style if we were able to read one
                if (style && !styles->AddItem(style)) {
                        delete style;
                        return B_NO_MEMORY;
                }
        }

        return B_OK;
}

// read_path_no_curves
static bool
read_path_no_curves(LittleEndianBuffer& buffer, VectorPath* path,
                                        uint8 pointCount)
{
        for (uint32 p = 0; p < pointCount; p++) {
                BPoint point;
                if (!read_coord(buffer, point.x)
                        || !read_coord(buffer, point.y))
                        return false;

                if (!path->AddPoint(point))
                        return false;
        }
        return true;
}

// read_path_curves
static bool
read_path_curves(LittleEndianBuffer& buffer, VectorPath* path,
                                 uint8 pointCount)
{
        for (uint32 p = 0; p < pointCount; p++) {
                BPoint point;
                if (!read_coord(buffer, point.x)
                        || !read_coord(buffer, point.y))
                        return false;

                BPoint pointIn;
                if (!read_coord(buffer, pointIn.x)
                        || !read_coord(buffer, pointIn.y))
                        return false;

                BPoint pointOut;
                if (!read_coord(buffer, pointOut.x)
                        || !read_coord(buffer, pointOut.y))
                        return false;

                if (!path->AddPoint(point, pointIn, pointOut, false))
                        return false;
        }
        return true;
}

// read_path_with_commands
static bool
read_path_with_commands(LittleEndianBuffer& buffer, VectorPath* path,
                                                uint8 pointCount)
{
        PathCommandQueue queue;
        return queue.Read(buffer, path, pointCount);
}


// _ParsePaths
status_t
FlatIconImporter::_ParsePaths(LittleEndianBuffer& buffer,
                                                          Container<VectorPath>* paths)
{
        uint8 pathCount;
        if (!buffer.Read(pathCount))
                return B_ERROR;

        for (int32 i = 0; i < pathCount; i++) {
                uint8 pathFlags;
                uint8 pointCount;
                if (!buffer.Read(pathFlags) || !buffer.Read(pointCount))
                        return B_ERROR;

                VectorPath* path = new (nothrow) VectorPath();
                if (!path)
                        return B_NO_MEMORY;

                // chose path reading strategy depending on path flags
                bool error = false;
                if (pathFlags & PATH_FLAG_NO_CURVES) {
                        if (!read_path_no_curves(buffer, path, pointCount))
                                error = true;
                } else if (pathFlags & PATH_FLAG_USES_COMMANDS) {
                        if (!read_path_with_commands(buffer, path, pointCount))
                                error = true;
                } else {
                        if (!read_path_curves(buffer, path, pointCount))
                                error = true;
                }

                if (error) {
                        delete path;
                        return B_ERROR;
                }
                // post process path to clean it up
                path->CleanUp();
                if (pathFlags & PATH_FLAG_CLOSED)
                        path->SetClosed(true);
                // add path to container
                if (!paths->AddItem(path)) {
                        delete path;
                        return B_NO_MEMORY;
                }
        }

        return B_OK;
}

// _ReadTransformer
static Transformer*
_ReadTransformer(LittleEndianBuffer& buffer, VertexSource& source, Shape* shape)
{
        uint8 transformerType;
        if (!buffer.Read(transformerType))
                return NULL;

        switch (transformerType) {
                case TRANSFORMER_TYPE_AFFINE: {
                        AffineTransformer* affine
                                = new (nothrow) AffineTransformer(source);
                        if (!affine)
                                return NULL;
                        double matrix[6];
                        for (int32 i = 0; i < 6; i++) {
                                float value;
                                if (!buffer.Read(value)) {
                                        delete affine;
                                        return NULL;
                                }
                                matrix[i] = value;
                        }
                        affine->load_from(matrix);
                        return affine;
                }
                case TRANSFORMER_TYPE_CONTOUR: {
                        ContourTransformer* contour
                                = new (nothrow) ContourTransformer(source);
                        uint8 width;
                        uint8 lineJoin;
                        uint8 miterLimit;
                        if (!contour
                                || !buffer.Read(width)
                                || !buffer.Read(lineJoin)
                                || !buffer.Read(miterLimit)) {
                                delete contour;
                                return NULL;
                        }
                        contour->width(width - 128.0);
                        contour->line_join((agg::line_join_e)lineJoin);
                        contour->miter_limit(miterLimit);
                        return contour;
                }
                case TRANSFORMER_TYPE_PERSPECTIVE: {
                        PerspectiveTransformer* perspective
                                = new (nothrow) PerspectiveTransformer(source, shape);
                        if (!perspective)
                                return NULL;
                        double matrix[9];
                        for (int32 i = 0; i < 9; i++) {
                                float value;
                                if (!read_float_24(buffer, value)) {
                                        delete perspective;
                                        return NULL;
                                }
                                matrix[i] = value;
                        }
                        perspective->load_from(matrix);
                        return perspective;
                }
                case TRANSFORMER_TYPE_STROKE: {
                        StrokeTransformer* stroke
                                = new (nothrow) StrokeTransformer(source);
                        uint8 width;
                        uint8 lineOptions;
                        uint8 miterLimit;
//                      uint8 shorten;
                        if (!stroke
                                || !buffer.Read(width)
                                || !buffer.Read(lineOptions)
                                || !buffer.Read(miterLimit)) {
                                delete stroke;
                                return NULL;
                        }
                        stroke->width(width - 128.0);
                        uint8 lineJoin = lineOptions & 15;
                        stroke->line_join((agg::line_join_e)lineJoin);
                        uint8 lineCap = lineOptions >> 4;
                        stroke->line_cap((agg::line_cap_e)lineCap);
                        stroke->miter_limit(miterLimit);
                        return stroke;
                }
                default: {
                        // unkown transformer, skip tag
                        uint16 tagLength;
                        if (!buffer.Read(tagLength))
                                return NULL;
                        buffer.Skip(tagLength);
                        return NULL;
                }
        }
}

// _ReadPathSourceShape
Shape*
FlatIconImporter::_ReadPathSourceShape(LittleEndianBuffer& buffer,
                                                                           Container<Style>* styles,
                                                                           Container<VectorPath>* paths)
{
        // find out which style this shape uses
        uint8 styleIndex;
        uint8 pathCount;
        if (!buffer.Read(styleIndex) || !buffer.Read(pathCount))
                return NULL;

#ifdef ICON_O_MATIC
        Style* style = styles->ItemAt(StyleIndexFor(styleIndex));
#else
        Style* style = styles->ItemAt(styleIndex);
#endif

        if (!style) {
                printf("_ReadPathSourceShape() - "
                           "shape references non-existing style %d\n", styleIndex);
                return NULL;
        }

        // create the shape
        PathSourceShape* shape = new (nothrow) PathSourceShape(style);
        ObjectDeleter<Shape> shapeDeleter(shape);

        if (!shape || shape->InitCheck() < B_OK)
                return NULL;

        // find out which paths this shape uses
        for (uint32 i = 0; i < pathCount; i++) {
                uint8 pathIndex;
                if (!buffer.Read(pathIndex))
                        return NULL;

#ifdef ICON_O_MATIC
                VectorPath* path = paths->ItemAt(PathIndexFor(pathIndex));
#else
                VectorPath* path = paths->ItemAt(pathIndex);
#endif
                if (!path) {
                        printf("_ReadPathSourceShape() - "
                                   "shape references non-existing path %d\n", pathIndex);
                        continue;
                }
                shape->Paths()->AddItem(path);
        }

        // shape flags
        uint8 shapeFlags;
        if (!buffer.Read(shapeFlags))
                return NULL;

        shape->SetHinting(shapeFlags & SHAPE_FLAG_HINTING);

        if (shapeFlags & SHAPE_FLAG_TRANSFORM) {
                // transformation
                if (!_ReadTransformable(buffer, shape))
                        return NULL;
        } else if (shapeFlags & SHAPE_FLAG_TRANSLATION) {
                // translation
                if (!_ReadTranslation(buffer, shape))
                        return NULL;
        }

        if (shapeFlags & SHAPE_FLAG_LOD_SCALE) {
                // min max visibility scale
                uint8 minScale;
                uint8 maxScale;
                if (!buffer.Read(minScale) || !buffer.Read(maxScale))
                        return NULL;
                shape->SetMinVisibilityScale(minScale / 63.75);
                shape->SetMaxVisibilityScale(maxScale / 63.75);
        }

        // transformers
        if (shapeFlags & SHAPE_FLAG_HAS_TRANSFORMERS) {
                uint8 transformerCount;
                if (!buffer.Read(transformerCount))
                        return NULL;
                for (uint32 i = 0; i < transformerCount; i++) {
                        Transformer* transformer
                                = _ReadTransformer(buffer, shape->VertexSource(), shape);
                        if (transformer && !shape->Transformers()->AddItem(transformer)) {
                                delete transformer;
                                return NULL;
                        }
                }
        }

        shapeDeleter.Detach();
        return shape;
}

// _ParseShapes
status_t
FlatIconImporter::_ParseShapes(LittleEndianBuffer& buffer,
                                                           Container<Style>* styles,
                                                           Container<VectorPath>* paths,
                                                           Container<Shape>* shapes)
{
        uint8 shapeCount;
        if (!buffer.Read(shapeCount))
                return B_ERROR;

        for (uint32 i = 0; i < shapeCount; i++) {
                uint8 shapeType;
                if (!buffer.Read(shapeType))
                        return B_ERROR;
                Shape* shape = NULL;
                if (shapeType == SHAPE_TYPE_PATH_SOURCE) {
                        // path source shape
                        shape = _ReadPathSourceShape(buffer, styles, paths);
                        if (!shape)
                                return B_NO_MEMORY;
                } else {
                        // unkown shape type, skip tag
                        uint16 tagLength;
                        if (!buffer.Read(tagLength))
                                return B_ERROR;
                        buffer.Skip(tagLength);
                        continue;
                }
                // add shape if we were able to read one
                if (shape && !shapes->AddItem(shape)) {
                        delete shape;
                        return B_NO_MEMORY;
                }
        }

        return B_OK;
}