//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.4
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mcseem@antigrain.com
//          mcseemagg@yahoo.com
//          http://www.antigrain.com
//----------------------------------------------------------------------------

#include "agg_math.h"
#include "agg_trans_double_path.h"

namespace agg
{

    //------------------------------------------------------------------------
    trans_double_path::trans_double_path() :
        m_kindex1(0.0),
        m_kindex2(0.0),
        m_base_length(0.0),
        m_base_height(1.0),
        m_status1(initial),
        m_status2(initial),
        m_preserve_x_scale(true)
    {
    }


        //------------------------------------------------------------------------
    void trans_double_path::reset()
    {
        m_src_vertices1.remove_all();
        m_src_vertices2.remove_all();
        m_kindex1 = 0.0;
        m_kindex1 = 0.0;
        m_status1 = initial;
        m_status2 = initial;
    }


    //------------------------------------------------------------------------
    void trans_double_path::move_to1(double x, double y)
    {
        if(m_status1 == initial)
        {
            m_src_vertices1.modify_last(vertex_dist(x, y));
            m_status1 = making_path;
        }
        else
        {
            line_to1(x, y);
        }
    }


    //------------------------------------------------------------------------
    void trans_double_path::line_to1(double x, double y)
    {
        if(m_status1 == making_path)
        {
            m_src_vertices1.add(vertex_dist(x, y));
        }
    }


    //------------------------------------------------------------------------
    void trans_double_path::move_to2(double x, double y)
    {
        if(m_status2 == initial)
        {
            m_src_vertices2.modify_last(vertex_dist(x, y));
            m_status2 = making_path;
        }
        else
        {
            line_to2(x, y);
        }
    }


    //------------------------------------------------------------------------
    void trans_double_path::line_to2(double x, double y)
    {
        if(m_status2 == making_path)
        {
            m_src_vertices2.add(vertex_dist(x, y));
        }
    }


    //------------------------------------------------------------------------
    double trans_double_path::finalize_path(vertex_storage& vertices)
    {
        unsigned i;
        double dist;
        double d;

        vertices.close(false);
        if(vertices.size() > 2)
        {
            if(vertices[vertices.size() - 2].dist * 10.0 < 
               vertices[vertices.size() - 3].dist)
            {
                d = vertices[vertices.size() - 3].dist + 
                    vertices[vertices.size() - 2].dist;

                vertices[vertices.size() - 2] = 
                    vertices[vertices.size() - 1];

                vertices.remove_last();
                vertices[vertices.size() - 2].dist = d;
            }
        }

        dist = 0;
        for(i = 0; i < vertices.size(); i++)
        {
            vertex_dist& v = vertices[i];
            d = v.dist;
            v.dist = dist;
            dist += d;
        }

        return (vertices.size() - 1) / dist;
    }


    //------------------------------------------------------------------------
    void trans_double_path::finalize_paths()
    {
        if(m_status1 == making_path && m_src_vertices1.size() > 1 &&
           m_status2 == making_path && m_src_vertices2.size() > 1)
        {
            m_kindex1 = finalize_path(m_src_vertices1);
            m_kindex2 = finalize_path(m_src_vertices2);
            m_status1 = ready;
            m_status2 = ready;
        }
    }


    //------------------------------------------------------------------------
    double trans_double_path::total_length1() const
    {
        if(m_base_length >= 1e-10) return m_base_length;
        return (m_status1 == ready) ? 
            m_src_vertices1[m_src_vertices1.size() - 1].dist :
            0.0;
    }


    //------------------------------------------------------------------------
    double trans_double_path::total_length2() const
    {
        if(m_base_length >= 1e-10) return m_base_length;
        return (m_status2 == ready) ? 
            m_src_vertices2[m_src_vertices2.size() - 1].dist :
            0.0;
    }


    //------------------------------------------------------------------------
    void trans_double_path::transform1(const vertex_storage& vertices, 
                                       double kindex, double kx, 
                                       double *x, double* y) const
    {
        double x1 = 0.0;
        double y1 = 0.0;
        double dx = 1.0;
        double dy = 1.0;
        double d  = 0.0;
        double dd = 1.0;
        *x *= kx;
        if(*x < 0.0)
        {
            // Extrapolation on the left
            //--------------------------
            x1 = vertices[0].x;
            y1 = vertices[0].y;
            dx = vertices[1].x - x1;
            dy = vertices[1].y - y1;
            dd = vertices[1].dist - vertices[0].dist;
            d  = *x;
        }
        else
        if(*x > vertices[vertices.size() - 1].dist)
        {
            // Extrapolation on the right
            //--------------------------
            unsigned i = vertices.size() - 2;
            unsigned j = vertices.size() - 1;
            x1 = vertices[j].x;
            y1 = vertices[j].y;
            dx = x1 - vertices[i].x;
            dy = y1 - vertices[i].y;
            dd = vertices[j].dist - vertices[i].dist;
            d  = *x - vertices[j].dist;
        }
        else
        {
            // Interpolation
            //--------------------------
            unsigned i = 0;
            unsigned j = vertices.size() - 1;
            if(m_preserve_x_scale)
            {
                unsigned k;
                for(i = 0; (j - i) > 1; ) 
                {
                    if(*x < vertices[k = (i + j) >> 1].dist) 
                    {
                        j = k; 
                    }
                    else 
                    {
                        i = k;
                    }
                }
                d  = vertices[i].dist;
                dd = vertices[j].dist - d;
                d  = *x - d;
            }
            else
            {
                i = unsigned(*x * kindex);
                j = i + 1;
                dd = vertices[j].dist - vertices[i].dist;
                d = ((*x * kindex) - i) * dd;
            }
            x1 = vertices[i].x;
            y1 = vertices[i].y;
            dx = vertices[j].x - x1;
            dy = vertices[j].y - y1;
        }
        *x = x1 + dx * d / dd;
        *y = y1 + dy * d / dd;
    }


    //------------------------------------------------------------------------
    void trans_double_path::transform(double *x, double *y) const
    {
        if(m_status1 == ready && m_status2 == ready)
        {
            if(m_base_length > 1e-10)
            {
                *x *= m_src_vertices1[m_src_vertices1.size() - 1].dist / 
                      m_base_length;
            }

            double x1 = *x;
            double y1 = *y;
            double x2 = *x;
            double y2 = *y;
            double dd = m_src_vertices2[m_src_vertices2.size() - 1].dist /
                        m_src_vertices1[m_src_vertices1.size() - 1].dist;

            transform1(m_src_vertices1, m_kindex1, 1.0, &x1, &y1);
            transform1(m_src_vertices2, m_kindex2, dd,  &x2, &y2);

            *x = x1 + *y * (x2 - x1) / m_base_height;
            *y = y1 + *y * (y2 - y1) / m_base_height;
        }
    }

}