#include <stdio.h>
#include <stdlib.h>
#include "agg_rendering_buffer.h"
#include "agg_rasterizer_scanline_aa.h"
#include "agg_conv_transform.h"
#include "agg_bspline.h"
#include "agg_ellipse.h"
#include "agg_gsv_text.h"
#include "agg_scanline_p.h"
#include "agg_renderer_scanline.h"
#include "ctrl/agg_slider_ctrl.h"
#include "ctrl/agg_scale_ctrl.h"
#include "platform/agg_platform_support.h"

#define AGG_BGR24
//#define AGG_RGB24
//#define AGG_BGR96
//#define AGG_BGRA32 
//#define AGG_RGBA32 
//#define AGG_ARGB32 
//#define AGG_ABGR32
//#define AGG_BGRA128
//#define AGG_RGB565
//#define AGG_RGB555
#include "pixel_formats.h"

enum flip_y_e { flip_y = true };
enum default_num_points_e { default_num_points = 10000 };

enum start_size_e
{
    start_width  = 400,
    start_height = 400
};

static double spline_r_x[] = { 0.000000, 0.200000, 0.400000, 0.910484, 0.957258, 1.000000 };
static double spline_r_y[] = { 1.000000, 0.800000, 0.600000, 0.066667, 0.169697, 0.600000 };

static double spline_g_x[] = { 0.000000, 0.292244, 0.485655, 0.564859, 0.795607, 1.000000 };
static double spline_g_y[] = { 0.000000, 0.607260, 0.964065, 0.892558, 0.435571, 0.000000 };

static double spline_b_x[] = { 0.000000, 0.055045, 0.143034, 0.433082, 0.764859, 1.000000 };
static double spline_b_y[] = { 0.385480, 0.128493, 0.021416, 0.271507, 0.713974, 1.000000 };


struct scatter_point
{
    double     x;
    double     y;
    double     z;
    agg::rgba  color;
};


double random_dbl(double start, double end)
{
    unsigned r = rand() & 0x7FFF;
    return double(r) * (end - start) / 32768.0 + start;
}


class the_application : public agg::platform_support
{
    unsigned       m_num_points;
    scatter_point* m_points;

    agg::scale_ctrl<color_type>  m_scale_ctrl_z;
    agg::slider_ctrl<color_type> m_slider_ctrl_sel;
    agg::slider_ctrl<color_type> m_slider_ctrl_size;

    agg::bspline m_spline_r;
    agg::bspline m_spline_g;
    agg::bspline m_spline_b;

public:
    virtual ~the_application()
    {
        delete [] m_points;
    }

    the_application(agg::pix_format_e format, bool flip_y, unsigned num_points) :
        agg::platform_support(format, flip_y),
        m_num_points(num_points),
        m_points(new scatter_point [num_points]),
        m_scale_ctrl_z    (5, 5,  start_width-5, 12, !flip_y),
        m_slider_ctrl_sel (5, 20, start_width-5, 27, !flip_y),
        m_slider_ctrl_size(5, 35, start_width-5, 42, !flip_y)
    {

        m_spline_r.init(6, spline_r_x, spline_r_y);
        m_spline_g.init(6, spline_g_x, spline_g_y);
        m_spline_b.init(6, spline_b_x, spline_b_y);

        add_ctrl(m_scale_ctrl_z);
        add_ctrl(m_slider_ctrl_sel);
        add_ctrl(m_slider_ctrl_size);

        m_slider_ctrl_size.label("Size");
        m_slider_ctrl_sel.label("Selectivity");
    }

    
    void generate()
    {
        unsigned i;

        double rx = initial_width()/3.5;
        double ry = initial_height()/3.5;

        for(i = 0; i < m_num_points; i++)
        {
            double z = m_points[i].z = random_dbl(0.0, 1.0);
            double x = cos(z * 2.0 * agg::pi) * rx;
            double y = sin(z * 2.0 * agg::pi) * ry;

            double dist  = random_dbl(0.0, rx/2.0);
            double angle = random_dbl(0.0, agg::pi * 2.0);

            m_points[i].x = initial_width()/2.0  + x + cos(angle) * dist;
            m_points[i].y = initial_height()/2.0 + y + sin(angle) * dist;
            m_points[i].color = agg::rgba(m_spline_r.get(z)*0.8, 
                                          m_spline_g.get(z)*0.8, 
                                          m_spline_b.get(z)*0.8, 
                                          1.0);
        }
    }


    virtual void on_init()
    {
        generate();
    }


    virtual void on_draw()
    {
        agg::rasterizer_scanline_aa<> pf;
        agg::scanline_p8 sl;

        typedef agg::renderer_base<pixfmt> renderer_base;

        pixfmt pixf(rbuf_window());
        renderer_base rb(pixf);

        rb.clear(agg::rgba(1,1,1));
      
        agg::ellipse e1;
        agg::conv_transform<agg::ellipse> t1(e1, trans_affine_resizing());


        unsigned i;
        unsigned n_drawn = 0;
        for(i = 0; i < m_num_points; i++)
        {
            double z = m_points[i].z;
            double alpha = 1.0;
            if(z < m_scale_ctrl_z.value1())
            {
                alpha = 
                    1.0 - 
                    (m_scale_ctrl_z.value1() - z) * 
                        m_slider_ctrl_sel.value() * 100.0;
            }

            if(z > m_scale_ctrl_z.value2())
            {
                alpha = 
                    1.0 - 
                    (z - m_scale_ctrl_z.value2()) * 
                        m_slider_ctrl_sel.value() * 100.0;
            }



            if(alpha > 1.0) alpha = 1.0;
            if(alpha < 0.0) alpha = 0.0;

            if(alpha > 0.0)
            {
                e1.init(m_points[i].x, 
                        m_points[i].y, 
                        m_slider_ctrl_size.value() * 5.0, 
                        m_slider_ctrl_size.value() * 5.0, 
                        8);
                pf.add_path(t1);

                agg::render_scanlines_aa_solid(
                    pf, sl, rb,
                    agg::rgba(m_points[i].color.r, 
                                   m_points[i].color.g,
                                   m_points[i].color.b,
                                   alpha));
                n_drawn++;
            }
        }

        agg::render_ctrl(pf, sl, rb, m_scale_ctrl_z);
        agg::render_ctrl(pf, sl, rb, m_slider_ctrl_sel);
        agg::render_ctrl(pf, sl, rb, m_slider_ctrl_size);

        char buf[10];
        sprintf(buf, "%08u", n_drawn);

        agg::gsv_text txt;
        txt.size(15.0);
        txt.text(buf);
        txt.start_point(10.0, initial_height() - 20.0);
        agg::gsv_text_outline<> txt_o(txt, trans_affine_resizing());
        pf.add_path(txt_o);
        agg::render_scanlines_aa_solid(pf, sl, rb, agg::rgba(0,0,0));

    }


    virtual void on_idle()
    {
        unsigned i;
        for(i = 0; i < m_num_points; i++)
        {
            m_points[i].x += random_dbl(0, m_slider_ctrl_sel.value()) - m_slider_ctrl_sel.value()*0.5;
            m_points[i].y += random_dbl(0, m_slider_ctrl_sel.value()) - m_slider_ctrl_sel.value()*0.5;
            m_points[i].z += random_dbl(0, m_slider_ctrl_sel.value()*0.01) - m_slider_ctrl_sel.value()*0.005;
            if(m_points[i].z < 0.0) m_points[i].z = 0.0;
            if(m_points[i].z > 1.0) m_points[i].z = 1.0;
        }
        force_redraw();
    }


    virtual void on_mouse_button_down(int x, int y, unsigned flags)
    {
        if(flags & agg::mouse_left)
        {
            generate();
            force_redraw();
        }

        if(flags & agg::mouse_right)
        {
            wait_mode(!wait_mode());
        }
    }

};



int agg_main(int argc, char* argv[])
{
    unsigned num_points = default_num_points;
    if(argc > 1)
    {
        num_points = atoi(argv[1]);
        if(num_points == 0)    num_points = default_num_points;
        if(num_points > 20000) num_points = 20000;
    }

    the_application app(pix_format, flip_y, num_points);
    app.caption("AGG Drawing random circles - A scatter plot prototype");

    if(app.init(start_width, start_height, agg::window_resize | agg::window_keep_aspect_ratio))
    {
        return app.run();
    }
    return 1;
}


