/*
 * Copyright 2008, Andrej Spielmann <andrej.spielmann@seh.ox.ac.uk>.
 * All rights reserved. Distributed under the terms of the MIT License.
 *
 * Copyright 2002-2004 Maxim Shemanarev (http://www.antigrain.com)
 *
 *
 * Class scanline_storage_subpix, a slightly modified version of
 * scanline_storage customized to store 3 covers per pixel
 *
 */

#ifndef AGG_SCANLINE_STORAGE_SUBPIX_INCLUDED
#define AGG_SCANLINE_STORAGE_SUBPIX_INCLUDED

#include <string.h>
#include <stdlib.h>
#include <math.h>
#include "agg_array.h"
#include "agg_scanline_storage_aa.h"


namespace agg
{
        //--------------------------------------------scanline_storage_subpix
        template<class T> class scanline_storage_subpix
        {
        public:
                typedef T cover_type;

                //---------------------------------------------------------------
                struct span_data
                {
                        int32 x;
                        int32 len;               // If negative, it's a solid span, covers is valid
                        int       covers_id; // The index of the cells in the scanline_cell_storage
                };

                //---------------------------------------------------------------
                struct scanline_data
                {
                        int              y;
                        unsigned num_spans;
                        unsigned start_span;
                };


                //---------------------------------------------------------------
                class embedded_scanline
                {
                public:

                        //-----------------------------------------------------------
                        class const_iterator
                        {
                        public:
                                struct span
                                {
                                        int32    x;
                                        int32    len; // If negative, it's a solid span, covers is valid
                                        const T* covers;
                                };

                                const_iterator() : m_storage(0) {}
                                const_iterator(const embedded_scanline& sl) :
                                        m_storage(sl.m_storage),
                                        m_span_idx(sl.m_scanline.start_span)
                                {
                                        init_span();
                                }

                                const span& operator*()  const { return m_span;  }
                                const span* operator->() const { return &m_span; }

                                void operator ++ ()
                                {
                                        ++m_span_idx;
                                        init_span();
                                }

                        private:
                                void init_span()
                                {
                                        const span_data& s = m_storage->span_by_index(m_span_idx);
                                        m_span.x          = s.x;
                                        m_span.len        = s.len;
                                        m_span.covers = m_storage->covers_by_index(s.covers_id);
                                }

                                const scanline_storage_subpix* m_storage;
                                unsigned                                   m_span_idx;
                                span                                       m_span;
                        };

                        friend class const_iterator;


                        //-----------------------------------------------------------
                        embedded_scanline(const scanline_storage_subpix& storage) :
                                m_storage(&storage)
                        {
                                init(0);
                        }

                        //-----------------------------------------------------------
                        void     reset(int, int)         {}
                        unsigned num_spans()   const { return m_scanline.num_spans;      }
                        int              y()               const { return m_scanline.y;                  }
                        const_iterator begin() const { return const_iterator(*this); }

                        //-----------------------------------------------------------
                        void init(unsigned scanline_idx)
                        {
                                m_scanline_idx = scanline_idx;
                                m_scanline = m_storage->scanline_by_index(m_scanline_idx);
                        }

                private:
                        const scanline_storage_subpix* m_storage;
                        scanline_data                      m_scanline;
                        unsigned                                   m_scanline_idx;
                };


                //---------------------------------------------------------------
                scanline_storage_subpix() :
                        m_covers(),
                        m_spans(256-2),                 // Block increment size
                        m_scanlines(),
                        m_min_x( 0x7FFFFFFF),
                        m_min_y( 0x7FFFFFFF),
                        m_max_x(-0x7FFFFFFF),
                        m_max_y(-0x7FFFFFFF),
                        m_cur_scanline(0)
                {
                        m_fake_scanline.y = 0;
                        m_fake_scanline.num_spans = 0;
                        m_fake_scanline.start_span = 0;
                        m_fake_span.x = 0;
                        m_fake_span.len = 0;
                        m_fake_span.covers_id = 0;
                }

                // Renderer Interface
                //---------------------------------------------------------------
                void prepare()
                {
                        m_covers.remove_all();
                        m_scanlines.remove_all();
                        m_spans.remove_all();
                        m_min_x =  0x7FFFFFFF;
                        m_min_y =  0x7FFFFFFF;
                        m_max_x = -0x7FFFFFFF;
                        m_max_y = -0x7FFFFFFF;
                        m_cur_scanline = 0;
                }

                //---------------------------------------------------------------
                template<class Scanline> void render(const Scanline& sl)
                {
                        scanline_data sl_this;

                        int y = sl.y();
                        if(y < m_min_y) m_min_y = y;
                        if(y > m_max_y) m_max_y = y;

                        sl_this.y = y;
                        sl_this.num_spans = sl.num_spans();
                        sl_this.start_span = m_spans.size();
                        typename Scanline::const_iterator span_iterator = sl.begin();

                        unsigned num_spans = sl_this.num_spans;
                        for(;;)
                        {
                                span_data sp;

                                sp.x             = span_iterator->x;
                                sp.len           = span_iterator->len;
                                int len          = abs(int(sp.len));
                                sp.covers_id =
                                        m_covers.add_cells(span_iterator->covers,
                                                                           (unsigned(len)));
                                m_spans.add(sp);
                                int x1 = sp.x;
                                int x2 = sp.x + len/3 - 1;
                                if(x1 < m_min_x) m_min_x = x1;
                                if(x2 > m_max_x) m_max_x = x2;
                                if(--num_spans == 0) break;
                                ++span_iterator;
                        }
                        m_scanlines.add(sl_this);
                }


                //---------------------------------------------------------------
                // Iterate scanlines interface
                int min_x() const { return m_min_x; }
                int min_y() const { return m_min_y; }
                int max_x() const { return m_max_x; }
                int max_y() const { return m_max_y; }

                //---------------------------------------------------------------
                bool rewind_scanlines()
                {
                        m_cur_scanline = 0;
                        return m_scanlines.size() > 0;
                }


                //---------------------------------------------------------------
                template<class Scanline> bool sweep_scanline(Scanline& sl)
                {
                        sl.reset_spans();
                        for(;;)
                        {
                                if(m_cur_scanline >= m_scanlines.size()) return false;
                                const scanline_data& sl_this = m_scanlines[m_cur_scanline];

                                unsigned num_spans = sl_this.num_spans;
                                unsigned span_idx  = sl_this.start_span;
                                do
                                {
                                        const span_data& sp = m_spans[span_idx++];
                                        const T* covers = covers_by_index(sp.covers_id);
                                        if(sp.len < 0)
                                        {
                                                sl.add_span(sp.x, unsigned(-sp.len), *covers);
                                        }
                                        else
                                        {
                                                sl.add_cells(sp.x, sp.len, covers);
                                        }
                                }
                                while(--num_spans);
                                ++m_cur_scanline;
                                if(sl.num_spans())
                                {
                                        sl.finalize(sl_this.y);
                                        break;
                                }
                        }
                        return true;
                }


                //---------------------------------------------------------------
                // Specialization for embedded_scanline
                bool sweep_scanline(embedded_scanline& sl)
                {
                        do
                        {
                                if(m_cur_scanline >= m_scanlines.size()) return false;
                                sl.init(m_cur_scanline);
                                ++m_cur_scanline;
                        }
                        while(sl.num_spans() == 0);
                        return true;
                }

                //---------------------------------------------------------------
                unsigned byte_size() const
                {
                        unsigned i;
                        unsigned size = sizeof(int32) * 4; // min_x, min_y, max_x, max_y

                        for(i = 0; i < m_scanlines.size(); ++i)
                        {
                                size += sizeof(int32) * 3; // scanline size in bytes

                                const scanline_data& sl_this = m_scanlines[i];

                                unsigned num_spans = sl_this.num_spans;
                                unsigned span_idx  = sl_this.start_span;
                                do
                                {
                                        const span_data& sp = m_spans[span_idx++];

                                        size += sizeof(int32) * 2;                                // X, span_len
                                        if(sp.len < 0)
                                        {
                                                size += sizeof(T);                                        // cover
                                        }
                                        else
                                        {
                                                size += sizeof(T) * unsigned(sp.len); // covers
                                        }
                                }
                                while(--num_spans);
                        }
                        return size;
                }


                //---------------------------------------------------------------
                static void write_int32(int8u* dst, int32 val)
                {
                        dst[0] = ((const int8u*)&val)[0];
                        dst[1] = ((const int8u*)&val)[1];
                        dst[2] = ((const int8u*)&val)[2];
                        dst[3] = ((const int8u*)&val)[3];
                }


                //---------------------------------------------------------------
                void serialize(int8u* data) const
                {
                        unsigned i;

                        write_int32(data, min_x()); // min_x
                        data += sizeof(int32);
                        write_int32(data, min_y()); // min_y
                        data += sizeof(int32);
                        write_int32(data, max_x()); // max_x
                        data += sizeof(int32);
                        write_int32(data, max_y()); // max_y
                        data += sizeof(int32);

                        for(i = 0; i < m_scanlines.size(); ++i)
                        {
                                const scanline_data& sl_this = m_scanlines[i];

                                int8u* size_ptr = data;
                                data += sizeof(int32);  // Reserve space for scanline size in bytes

                                write_int32(data, sl_this.y);                    // Y
                                data += sizeof(int32);

                                write_int32(data, sl_this.num_spans);    // num_spans
                                data += sizeof(int32);

                                unsigned num_spans = sl_this.num_spans;
                                unsigned span_idx  = sl_this.start_span;
                                do
                                {
                                        const span_data& sp = m_spans[span_idx++];
                                        const T* covers = covers_by_index(sp.covers_id);

                                        write_int32(data, sp.x);                        // X
                                        data += sizeof(int32);

                                        write_int32(data, sp.len);                      // span_len
                                        data += sizeof(int32);

                                        if(sp.len < 0)
                                        {
                                                memcpy(data, covers, sizeof(T));
                                                data += sizeof(T);
                                        }
                                        else
                                        {
                                                memcpy(data, covers, unsigned(sp.len) * sizeof(T));
                                                data += sizeof(T) * unsigned(sp.len);
                                        }
                                }
                                while(--num_spans);
                                write_int32(size_ptr, int32(unsigned(data - size_ptr)));
                        }
                }


                //---------------------------------------------------------------
                const scanline_data& scanline_by_index(unsigned i) const
                {
                        return (i < m_scanlines.size()) ? m_scanlines[i] : m_fake_scanline;
                }

                //---------------------------------------------------------------
                const span_data& span_by_index(unsigned i) const
                {
                        return (i < m_spans.size()) ? m_spans[i] : m_fake_span;
                }

                //---------------------------------------------------------------
                const T* covers_by_index(int i) const
                {
                        return m_covers[i];
                }

        private:
                scanline_cell_storage<T>          m_covers;
                pod_bvector<span_data, 10>        m_spans;
                pod_bvector<scanline_data, 8> m_scanlines;
                span_data         m_fake_span;
                scanline_data m_fake_scanline;
                int                       m_min_x;
                int                       m_min_y;
                int                       m_max_x;
                int                       m_max_y;
                unsigned          m_cur_scanline;
        };


        typedef scanline_storage_subpix<int8u>  scanline_storage_subpix8;  //--------scanline_storage_subpix8
        typedef scanline_storage_subpix<int16u> scanline_storage_subpix16; //--------scanline_storage_subpix16
        typedef scanline_storage_subpix<int32u> scanline_storage_subpix32; //--------scanline_storage_subpix32


        //--------------------------------------serialized_scanlines_adaptor_subpix
        template<class T> class serialized_scanlines_adaptor_subpix
        {
        public:
                typedef T cover_type;

                //---------------------------------------------------------------------
                class embedded_scanline
                {
                public:
                        typedef T cover_type;

                        //-----------------------------------------------------------------
                        class const_iterator
                        {
                        public:
                                struct span
                                {
                                        int32    x;
                                        int32    len; // If negative, it's a solid span, "covers" is valid
                                        const T* covers;
                                };

                                const_iterator() : m_ptr(0) {}
                                const_iterator(const embedded_scanline& sl) :
                                        m_ptr(sl.m_ptr),
                                        m_dx(sl.m_dx)
                                {
                                        init_span();
                                }

                                const span& operator*()  const { return m_span;  }
                                const span* operator->() const { return &m_span; }

                                void operator ++ ()
                                {
                                        if(m_span.len < 0)
                                        {
                                                m_ptr += sizeof(T);
                                        }
                                        else
                                        {
                                                m_ptr += m_span.len * sizeof(T);
                                        }
                                        init_span();
                                }

                        private:
                                int read_int32()
                                {
                                        int32 val;
                                        ((int8u*)&val)[0] = *m_ptr++;
                                        ((int8u*)&val)[1] = *m_ptr++;
                                        ((int8u*)&val)[2] = *m_ptr++;
                                        ((int8u*)&val)[3] = *m_ptr++;
                                        return val;
                                }

                                void init_span()
                                {
                                        m_span.x          = read_int32() + m_dx;
                                        m_span.len        = read_int32();
                                        m_span.covers = m_ptr;
                                }

                                const int8u* m_ptr;
                                span             m_span;
                                int                      m_dx;
                        };

                        friend class const_iterator;


                        //-----------------------------------------------------------------
                        embedded_scanline() : m_ptr(0), m_y(0), m_num_spans(0) {}

                        //-----------------------------------------------------------------
                        void     reset(int, int)         {}
                        unsigned num_spans()   const { return m_num_spans;      }
                        int              y()               const { return m_y;                  }
                        const_iterator begin() const { return const_iterator(*this); }


                private:
                        //-----------------------------------------------------------------
                        int read_int32()
                        {
                                int32 val;
                                ((int8u*)&val)[0] = *m_ptr++;
                                ((int8u*)&val)[1] = *m_ptr++;
                                ((int8u*)&val)[2] = *m_ptr++;
                                ((int8u*)&val)[3] = *m_ptr++;
                                return val;
                        }

                public:
                        //-----------------------------------------------------------------
                        void init(const int8u* ptr, int dx, int dy)
                        {
                                m_ptr           = ptr;
                                m_y                     = read_int32() + dy;
                                m_num_spans = unsigned(read_int32());
                                m_dx            = dx;
                        }

                private:
                        const int8u* m_ptr;
                        int                      m_y;
                        unsigned         m_num_spans;
                        int                      m_dx;
                };



        public:
                //--------------------------------------------------------------------
                serialized_scanlines_adaptor_subpix() :
                        m_data(0),
                        m_end(0),
                        m_ptr(0),
                        m_dx(0),
                        m_dy(0),
                        m_min_x(0x7FFFFFFF),
                        m_min_y(0x7FFFFFFF),
                        m_max_x(-0x7FFFFFFF),
                        m_max_y(-0x7FFFFFFF)
                {}

                //--------------------------------------------------------------------
                serialized_scanlines_adaptor_subpix(const int8u* data, unsigned size,
                                                                                double dx, double dy) :
                        m_data(data),
                        m_end(data + size),
                        m_ptr(data),
                        m_dx(iround(dx)),
                        m_dy(iround(dy)),
                        m_min_x(0x7FFFFFFF),
                        m_min_y(0x7FFFFFFF),
                        m_max_x(-0x7FFFFFFF),
                        m_max_y(-0x7FFFFFFF)
                {}

                //--------------------------------------------------------------------
                void init(const int8u* data, unsigned size, double dx, double dy)
                {
                        m_data  = data;
                        m_end   = data + size;
                        m_ptr   = data;
                        m_dx    = iround(dx);
                        m_dy    = iround(dy);
                        m_min_x = 0x7FFFFFFF;
                        m_min_y = 0x7FFFFFFF;
                        m_max_x = -0x7FFFFFFF;
                        m_max_y = -0x7FFFFFFF;
                }

        private:
                //--------------------------------------------------------------------
                int read_int32()
                {
                        int32 val;
                        ((int8u*)&val)[0] = *m_ptr++;
                        ((int8u*)&val)[1] = *m_ptr++;
                        ((int8u*)&val)[2] = *m_ptr++;
                        ((int8u*)&val)[3] = *m_ptr++;
                        return val;
                }

                //--------------------------------------------------------------------
                unsigned read_int32u()
                {
                        int32u val;
                        ((int8u*)&val)[0] = *m_ptr++;
                        ((int8u*)&val)[1] = *m_ptr++;
                        ((int8u*)&val)[2] = *m_ptr++;
                        ((int8u*)&val)[3] = *m_ptr++;
                        return val;
                }

        public:
                // Iterate scanlines interface
                //--------------------------------------------------------------------
                bool rewind_scanlines()
                {
                        m_ptr = m_data;
                        if(m_ptr < m_end)
                        {
                                m_min_x = read_int32() + m_dx;
                                m_min_y = read_int32() + m_dy;
                                m_max_x = read_int32() + m_dx;
                                m_max_y = read_int32() + m_dy;
                        }
                        return m_ptr < m_end;
                }

                //--------------------------------------------------------------------
                int min_x() const { return m_min_x; }
                int min_y() const { return m_min_y; }
                int max_x() const { return m_max_x; }
                int max_y() const { return m_max_y; }

                //--------------------------------------------------------------------
                template<class Scanline> bool sweep_scanline(Scanline& sl)
                {
                        sl.reset_spans();
                        for(;;)
                        {
                                if(m_ptr >= m_end) return false;

                                read_int32();      // Skip scanline size in bytes
                                int y = read_int32() + m_dy;
                                unsigned num_spans = read_int32();

                                do
                                {
                                        int x = read_int32() + m_dx;
                                        int len = read_int32();

                                        if(len < 0)
                                        {
                                                sl.add_span(x, unsigned(-len), *m_ptr);
                                                m_ptr += sizeof(T);
                                        }
                                        else
                                        {
                                                sl.add_cells(x, len, m_ptr);
                                                m_ptr += len * sizeof(T);
                                        }
                                }
                                while(--num_spans);

                                if(sl.num_spans())
                                {
                                        sl.finalize(y);
                                        break;
                                }
                        }
                        return true;
                }


                //--------------------------------------------------------------------
                // Specialization for embedded_scanline
                bool sweep_scanline(embedded_scanline& sl)
                {
                        do
                        {
                                if(m_ptr >= m_end) return false;

                                unsigned byte_size = read_int32u();
                                sl.init(m_ptr, m_dx, m_dy);
                                m_ptr += byte_size - sizeof(int32);
                        }
                        while(sl.num_spans() == 0);
                        return true;
                }

        private:
                const int8u* m_data;
                const int8u* m_end;
                const int8u* m_ptr;
                int                      m_dx;
                int                      m_dy;
                int                      m_min_x;
                int                      m_min_y;
                int                      m_max_x;
                int                      m_max_y;
        };



        typedef serialized_scanlines_adaptor_subpix<int8u>
        serialized_scanlines_adaptor_subpix8; //serialized_scanlines_adaptor_subpix8

        typedef serialized_scanlines_adaptor_subpix<int16u>
        serialized_scanlines_adaptor_subpix16; //serialized_scanlines_adaptor_subpix16

        typedef serialized_scanlines_adaptor_subpix<int32u>
        serialized_scanlines_adaptor_subpix32; //serialized_scanlines_adaptor_subpix32

}


#endif