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

#include "IconRenderer.h"

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

#include <Bitmap.h>
#include <List.h>

#include <agg_image_accessors.h>
#include <agg_span_image_filter_rgba.h>
#include <agg_span_gradient.h>
#include <agg_span_interpolator_linear.h>
#include <agg_span_interpolator_trans.h>

#include "CompoundStyleTransformer.h"
#include "GradientTransformable.h"
#include "Icon.h"
#include "Shape.h"
#include "Style.h"
#include "StyleTransformer.h"
#include "VectorPath.h"

using std::nothrow;

class IconRenderer::StyleHandler {
        struct StyleItem {
                const Style*                    style;
                StyleTransformer*               transformer;
        };

 public:
#ifdef ICON_O_MATIC
                                                                StyleHandler(::GammaTable& gammaTable,
                                                                        bool showReferences);
#else
                                                                StyleHandler(::GammaTable& gammaTable);
#endif

                                                                ~StyleHandler();

                        bool                            AddStyle(const Style* style,
                                                                        const Transformable& transformation,
                                                                        const Container<Transformer>* transformers);

                        bool                            is_solid(unsigned styleIndex) const;
                        const agg::rgba8&       color(unsigned styleIndex);
                        void                            generate_span(agg::rgba8* span, int x, int y,
                                                                        unsigned len, unsigned styleIndex);
 private:
                        StyleTransformer*       _MergeTransformers(
                                                                        const Transformable* styleTransformation,
                                                                        const Container<Transformer>* transformers,
                                                                        const Transformable* shapeTransformation);

                        template<class GradientFunction>
                        void                            _GenerateGradient(agg::rgba8* span,
                                                                        int x, int y, unsigned len,
                                                                        GradientFunction function,
                                                                        int32 start, int32 end,
                                                                        const agg::rgba8* gradientColors,
                                                                        StyleTransformer* transformer);
#ifdef ICON_O_MATIC
                        void                            _GenerateImage(agg::rgba8* span,
                                                                        int x, int y, unsigned len,
                                                                        const Style* style,
                                                                        StyleTransformer* transformer);
#endif

 private:
                        BList                                   fStyles;
                        ::GammaTable&                   fGammaTable;
#ifdef ICON_O_MATIC
                        bool                                    fShowReferences;
#endif
                        agg::rgba8                              fTransparent;
                        agg::rgba8                              fColor;
};



#ifdef ICON_O_MATIC
IconRenderer::StyleHandler::StyleHandler(::GammaTable& gammaTable, bool showReferences)
        : fStyles(20),
          fGammaTable(gammaTable),
          fShowReferences(showReferences),
          fTransparent(0, 0, 0, 0),
          fColor(0, 0, 0, 0)
{}
#else
IconRenderer::StyleHandler::StyleHandler(::GammaTable& gammaTable)
        : fStyles(20),
          fGammaTable(gammaTable),
          fTransparent(0, 0, 0, 0),
          fColor(0, 0, 0, 0)
{}
#endif


IconRenderer::StyleHandler::~StyleHandler()
{
        int32 count = fStyles.CountItems();
        for (int32 i = 0; i < count; i++) {
                StyleItem* item = (StyleItem*)fStyles.ItemAtFast(i);
                delete item->transformer;
                delete item;
        }
}


bool
IconRenderer::StyleHandler::AddStyle(const Style* style,
        const Transformable& transformation, const Container<Transformer>* transformers)
{
        if (!style)
                return false;

        StyleItem* item = new (nothrow) StyleItem;
        if (!item)
                return false;

        item->style = style;

        item->transformer = _MergeTransformers(style->Gradient(), transformers, &transformation);
        item->transformer->Invert();

        return fStyles.AddItem((void*)item);
}


bool
IconRenderer::StyleHandler::is_solid(unsigned styleIndex) const
{
        StyleItem* styleItem = (StyleItem*)fStyles.ItemAt(styleIndex);
        if (!styleItem)
                return true;

        if (styleItem->style->Gradient())
                return false;

#ifdef ICON_O_MATIC
        if (styleItem->style->Bitmap() && fShowReferences)
                return false;
#endif // ICON_O_MATIC

        return true;
}


const agg::rgba8&
IconRenderer::StyleHandler::color(unsigned styleIndex)
{
        StyleItem* styleItem = (StyleItem*)fStyles.ItemAt(styleIndex);
        if (!styleItem) {
                printf("no style at index: %u!\n", styleIndex);
                return fTransparent;
        }

#ifdef ICON_O_MATIC
        if (styleItem->style->Bitmap() && !fShowReferences) {
                fColor = agg::rgba8(0,0,0,0);
                return fColor;
        }
#endif

        const rgb_color& c = styleItem->style->Color();
        fColor = agg::rgba8(fGammaTable.dir(c.red), fGammaTable.dir(c.green),
                fGammaTable.dir(c.blue), c.alpha);
        fColor.premultiply();
    return fColor;
}


void
IconRenderer::StyleHandler::generate_span(agg::rgba8* span, int x, int y,
        unsigned len, unsigned styleIndex)
{
        StyleItem* styleItem = (StyleItem*)fStyles.ItemAt(styleIndex);
        if (!styleItem
                        || (!styleItem->style->Gradient()
#ifdef ICON_O_MATIC
                                && !styleItem->style->Bitmap()
#endif
                )) {
                printf("no style/gradient at index: %u!\n", styleIndex);
                // TODO: memset() span?
                return;
        }

#ifdef ICON_O_MATIC
        if (styleItem->style->Bitmap()) {
                _GenerateImage(span, x, y, len, styleItem->style, styleItem->transformer);
                return;
        }
#endif // ICON_O_MATIC

        const Style* style = styleItem->style;
        Gradient* gradient = style->Gradient();
        const agg::rgba8* colors = style->GammaCorrectedColors(fGammaTable);

        switch (gradient->Type()) {
                case GRADIENT_LINEAR: {
                    agg::gradient_x function;
                        _GenerateGradient(span, x, y, len, function, -64, 64, colors,
                                styleItem->transformer);
                        break;
                }
                case GRADIENT_CIRCULAR: {
                    agg::gradient_radial function;
                        _GenerateGradient(span, x, y, len, function, 0, 64, colors,
                                styleItem->transformer);
                        break;
                }
                case GRADIENT_DIAMOND: {
                    agg::gradient_diamond function;
                        _GenerateGradient(span, x, y, len, function, 0, 64, colors,
                                styleItem->transformer);
                        break;
                }
                case GRADIENT_CONIC: {
                    agg::gradient_conic function;
                        _GenerateGradient(span, x, y, len, function, 0, 64, colors,
                                styleItem->transformer);
                        break;
                }
                case GRADIENT_XY: {
                    agg::gradient_xy function;
                        _GenerateGradient(span, x, y, len, function, 0, 64, colors,
                                styleItem->transformer);
                        break;
                }
                case GRADIENT_SQRT_XY: {
                    agg::gradient_sqrt_xy function;
                        _GenerateGradient(span, x, y, len, function, 0, 64, colors,
                                styleItem->transformer);
                        break;
                }
        }
}


StyleTransformer*
IconRenderer::StyleHandler::_MergeTransformers(const Transformable* styleTransformation,
        const Container<Transformer>* transformers, const Transformable* shapeTransformation)
{
        // Figure out how large to make the array
        int32 count = 0;
        if (styleTransformation != NULL)
                count++;
        for (int i = 0; i < transformers->CountItems(); i++) {
                if (dynamic_cast<StyleTransformer*>(transformers->ItemAtFast(i)))
                        count++;
        }
        count++;

        // Populate the array
        StyleTransformer** styleTransformers = new (nothrow) StyleTransformer*[count];
        if (styleTransformers == NULL)
                return NULL;

        int i = 0;
        if (styleTransformation != NULL)
                styleTransformers[i++] = new (nothrow) Transformable(*styleTransformation);
        for (int j = 0; j < transformers->CountItems(); j++) {
                Transformer* transformer = transformers->ItemAtFast(j);
                if (dynamic_cast<StyleTransformer*>(transformer) != NULL) {
                        styleTransformers[i++]
                                = dynamic_cast<StyleTransformer*>(transformer->Clone());
                }
        }
        styleTransformers[i++] = new (nothrow) Transformable(*shapeTransformation);

        CompoundStyleTransformer* styleTransformer
                = new (nothrow) CompoundStyleTransformer(styleTransformers, count);
        if (styleTransformer == NULL) {
                delete[] styleTransformers;
                return NULL;
        }

        return styleTransformer;
}


template<class GradientFunction>
void
IconRenderer::StyleHandler::_GenerateGradient(agg::rgba8* span, int x, int y,
        unsigned len, GradientFunction function, int32 start, int32 end,
        const agg::rgba8* gradientColors, StyleTransformer* transformer)
{
        // TODO: performance could potentially be improved by avoiding recreating
        // these objects on every span
        typedef agg::pod_auto_array<agg::rgba8, 256>    ColorArray;
        ColorArray array(gradientColors);

        if (transformer->IsLinear()) {
                typedef agg::span_interpolator_linear
                        <StyleTransformer>                                              Interpolator;
                typedef agg::span_gradient<agg::rgba8,
                                                                Interpolator,
                                                                GradientFunction,
                                                                ColorArray>                     GradientGenerator;

                Interpolator interpolator(*transformer);

                GradientGenerator gradientGenerator(interpolator, function, array,
                        start, end);

                gradientGenerator.generate(span, x, y, len);
        } else {
                typedef agg::span_interpolator_trans
                        <StyleTransformer>                                              Interpolator;
                typedef agg::span_gradient<agg::rgba8,
                                                                Interpolator,
                                                                GradientFunction,
                                                                ColorArray>                     GradientGenerator;

                Interpolator interpolator(*transformer);

                GradientGenerator gradientGenerator(interpolator, function, array,
                        start, end);

                gradientGenerator.generate(span, x, y, len);
        }
}


#ifdef ICON_O_MATIC
void
IconRenderer::StyleHandler::_GenerateImage(agg::rgba8* span, int x, int y,
        unsigned len, const Style* style, StyleTransformer* transformer)
{
        // bitmap
        BBitmap* bbitmap = style->Bitmap();
        agg::rendering_buffer bitmap;
        bitmap.attach(static_cast<unsigned char*>(bbitmap->Bits()), bbitmap->Bounds().Width() + 1,
                bbitmap->Bounds().Height() + 1, bbitmap->BytesPerRow());

        // pixel format attached to bitmap
        PixelFormat pixf_img(bitmap);

        // image interpolator
        // TODO: performance could be improved by using agg_interpolator_linear
        //       where possible, similar to what _GenerateGradient does.
        typedef agg::span_interpolator_trans<StyleTransformer>
                interpolator_type;
        interpolator_type interpolator(*transformer);

        // image accessor attached to pixel format of bitmap
        typedef agg::image_accessor_clip<PixelFormat> source_type;
        agg::rgba8 background(0, 0, 0, 0);
        source_type source(pixf_img, background);

        // image filter (nearest neighbor)
        typedef agg::span_image_filter_rgba_nn<
                source_type, interpolator_type> span_gen_type;
        span_gen_type spanGenerator(source, interpolator);

        // generate the requested span
        spanGenerator.generate(span, x, y, len);

        // apply postprocessing
        for (unsigned i = 0; i < len; i++) {
                span[i].apply_gamma_dir(fGammaTable);
                span[i].a = (uint8) ((float) span[i].a * style->Alpha() / 255);
                span[i].premultiply();
        }
}
#endif // ICON_O_MATIC


// #pragma mark -


class HintingTransformer {
 public:

        void transform(double* x, double* y) const
        {
                *x = floor(*x + 0.5);
                *y = floor(*y + 0.5);
        }
};


// #pragma mark -


IconRenderer::IconRenderer(BBitmap* bitmap)
        : fBitmap(bitmap),
          fBackground(NULL),
          fBackgroundColor(0, 0, 0, 0),
          fIcon(NULL),

          fGammaTable(2.2),

          fRenderingBuffer(),
          fPixelFormat(fRenderingBuffer),
          fPixelFormatPre(fRenderingBuffer),
          fBaseRenderer(fPixelFormat),
          fBaseRendererPre(fPixelFormatPre),

          fScanline(),
          fBinaryScanline(),
          fSpanAllocator(),

          fRasterizer(),

          fGlobalTransform()
{
        // attach rendering buffer to bitmap
        fRenderingBuffer.attach((uint8*)bitmap->Bits(),
                bitmap->Bounds().IntegerWidth() + 1,
                bitmap->Bounds().IntegerHeight() + 1, bitmap->BytesPerRow());

        fBaseRendererPre.clip_box(0, 0, bitmap->Bounds().IntegerWidth(),
                bitmap->Bounds().IntegerHeight());
}


IconRenderer::~IconRenderer()
{
}


void
IconRenderer::SetIcon(const Icon* icon)
{
        if (fIcon == icon)
                return;

        fIcon = icon;
        // TODO: ... ?
}


void
#ifdef ICON_O_MATIC
IconRenderer::Render(bool showReferences)
#else
IconRenderer::Render()
#endif
{
#ifdef ICON_O_MATIC
        _Render(fBitmap->Bounds(), showReferences);
#else
        _Render(fBitmap->Bounds());
#endif
}


void
#ifdef ICON_O_MATIC
IconRenderer::Render(const BRect& area, bool showReferences)
#else
IconRenderer::Render(const BRect& area)
#endif
{
#ifdef ICON_O_MATIC
        _Render(fBitmap->Bounds() & area, showReferences);
#else
        _Render(fBitmap->Bounds() & area);
#endif
}


void
IconRenderer::SetScale(double scale)
{
        fGlobalTransform.reset();
        fGlobalTransform.multiply(agg::trans_affine_scaling(scale));
}


void
IconRenderer::SetBackground(const BBitmap* background)
{
        fBackground = background;
}


void
IconRenderer::SetBackground(const agg::rgba8& background)
{
        fBackgroundColor.r = fGammaTable.dir(background.r);
        fBackgroundColor.g = fGammaTable.dir(background.g);
        fBackgroundColor.b = fGammaTable.dir(background.b);
        fBackgroundColor.a = background.a;
}


void
IconRenderer::Demultiply()
{
        uint8* bits = (uint8*)fBitmap->Bits();
        uint32 bpr = fBitmap->BytesPerRow();
        uint32 width = fBitmap->Bounds().IntegerWidth() + 1;
        uint32 height = fBitmap->Bounds().IntegerHeight() + 1;

        for (uint32 y = 0; y < height; y++) {
                uint8* b = bits;
                for (uint32 x = 0; x < width; x++) {
                        if (b[3] < 255 && b[3] > 0) {
                                b[0] = (uint8)((int)b[0] * 255 / b[3]);
                                b[1] = (uint8)((int)b[1] * 255 / b[3]);
                                b[2] = (uint8)((int)b[2] * 255 / b[3]);
                        }
                        b += 4;
                }
                bits += bpr;
        }
}


// #pragma mark -


typedef agg::conv_transform<VertexSource, Transformable> ScaledPath;
typedef agg::conv_transform<ScaledPath, HintingTransformer> HintedPath;


void
#ifdef ICON_O_MATIC
IconRenderer::_Render(const BRect& r, bool showReferences)
#else
IconRenderer::_Render(const BRect& r)
#endif
{
        if (!fIcon)
                return;

// TODO: fix clip box for "clear" and "apply_gamma_inv"
//      fBaseRendererPre.clip_box((int)floorf(r.left), (int)floorf(r.top),
//              (int)ceilf(r.right), (int)ceilf(r.bottom));

        if (fBackground)
                memcpy(fBitmap->Bits(), fBackground->Bits(), fBitmap->BitsLength());
        else
                fBaseRendererPre.clear(fBackgroundColor);

//bigtime_t start = system_time();
#ifdef ICON_O_MATIC
        StyleHandler styleHandler(fGammaTable, showReferences);
#else
        StyleHandler styleHandler(fGammaTable);
#endif

        fRasterizer.reset();
        // iterate over the shapes in the icon,
        // add the vector paths to the rasterizer
        // and associate each shapes style
        int32 shapeCount = fIcon->Shapes()->CountItems();
        int32 styleIndex = 0;
        for (int32 i = 0; i < shapeCount; i++) {
                Shape* shape = fIcon->Shapes()->ItemAtFast(i);

                if (!shape->Visible(fGlobalTransform.scale())) {
                        continue;
                }

                Transformable transform(*shape);
                transform.multiply(fGlobalTransform);

                Style* style = shape->Style();
                if (!style)
                        continue;

                // add the style either with global transformation or with
                // the shapes transformation, depending on whether there
                // is a gradient and its settings
                Gradient* gradient = style->Gradient();
                bool styleAdded = false;
                if (gradient && !gradient->InheritTransformation()) {
                        styleAdded = styleHandler.AddStyle(
                                style, fGlobalTransform, NULL);
                } else {
                        styleAdded = styleHandler.AddStyle(
                                style, transform, shape->Transformers());
                }

                if (!styleAdded) {
                        printf("IconRenderer::_Render() - out of memory\n");
                        break;
                }

                // if this is not the first shape, and the style contains
                // transparency, commit a render pass of previous shapes
                if (i > 0
                                && (style->HasTransparency()
#ifdef ICON_O_MATIC
                                        || style->Bitmap() != NULL
#endif
                        ))
                        _CommitRenderPass(styleHandler);

                fRasterizer.styles(styleIndex, -1);
                styleIndex++;

                // global scale
                shape->SetGlobalScale(max_c(1.0, transform.scale()));
                ScaledPath scaledPath(shape->VertexSource(), transform);
                if (shape->Hinting()) {
                        // additional hinting
                        HintingTransformer hinter;
                        HintedPath hintedPath(scaledPath, hinter);
                        fRasterizer.add_path(hintedPath);
                } else {
                        fRasterizer.add_path(scaledPath);
                }
        }

        _CommitRenderPass(styleHandler, false);

        if (fGammaTable.gamma() != 1.0)
                fPixelFormat.apply_gamma_inv(fGammaTable);

//if (fRenderingBuffer.width() == 64)
//printf("rendering 64x64: %lld\n", system_time() - start);
}


void
IconRenderer::_CommitRenderPass(StyleHandler& styleHandler, bool reset)
{
        agg::render_scanlines_compound(fRasterizer, fScanline, fBinaryScanline,
                fBaseRendererPre, fSpanAllocator, styleHandler);

        if (reset)
                fRasterizer.reset();
}