/*
    Hyperbolic Tessellations
    Copyright (C) 2007 Dmitry Brant
    http://dmitrybrant.com

    Based largely on code from
    http://www.plunk.org/~hatch/HyperbolicApplet/
*/
//---------------------------------------------------------------------------
#ifndef schwarzpolygonsH
#define schwarzpolygonsH

#include "mycomplex.h"

class PickableSchwarzPolygon
{
public:
    Vector<complex> SchwarzPolygon;

    PickableSchwarzPolygon(): SchwarzPolygon() { }
    ~PickableSchwarzPolygon(){ }

    void setVertices(Vector<complex>& vertices, Isometry& I){
        SchwarzPolygon.Resize(vertices.length);
        for (int i=0; i<vertices.length; ++i){
             I.apply(vertices[i], SchwarzPolygon[i]);
        }
    }


    bool pick(complex p, Isometry& return_IsometryThatSendsPointInsideSchwarzPolygon, int& return_nFlips){
        // Refine curI and curP=curI(p)
        // so that curP gets closer and closer to the Schwarz polygon...
        Isometry curI = Isometry(one,zero,1);
        complex curP = p;

        int n = SchwarzPolygon.length;
        double eps = 1e-6;

        // Make sure the polygon is actually counterclockwise,
        // or else we're doomed to fail
        if(pointIsToRightSideOfLinePoincare(
                SchwarzPolygon[2],
                SchwarzPolygon[0],
                SchwarzPolygon[1],
                eps))
        {
            // Note we're changing the array, which is kind of strange,
            // but no big deal

            //reverse the array
            //Arrays.reverse(SchwarzPolygon, SchwarzPolygon);
            complex temp;
            //for(int i=0; i<SchwarzPolygon.length/2; i++){
            //    temp = SchwarzPolygon[i];
            //    SchwarzPolygon[i] = SchwarzPolygon[SchwarzPolygon.length-1-i];
            //    SchwarzPolygon[SchwarzPolygon.length-1-i] = temp;
            //}
            temp = SchwarzPolygon[0];
            SchwarzPolygon[0] = SchwarzPolygon[2];
            SchwarzPolygon[2] = temp;

        }

        Isometry* reflections = new Isometry[n]; // reflections about edges, lazily calculated when needed
        try{
            // go round and round until we see that we are inside all n...
            int totalIterations;
            int totalIterationsLimit = 200;
            int nInside = 0;
            int totalFlips = 0;
            for(int i = 0, totalIterations = 0; totalIterations < totalIterationsLimit; i = (i+1)%n, totalIterations++){
                if(pointIsToRightSideOfLinePoincare(curP, SchwarzPolygon[i], SchwarzPolygon[(i+1)%n], eps))
                {
                    reflections[i] = Isometry::reflectionAcrossLine(SchwarzPolygon[i], SchwarzPolygon[(i+1)%n]);
                    Isometry incI = reflections[i];

                    curI = incI * curI;
                    incI.apply(curP, curP);
                    totalFlips++;
                    nInside = 0; // start over
                }
                else{
                    if (++nInside == n){
                        // Got it
                        return_IsometryThatSendsPointInsideSchwarzPolygon = curI;
                        return_nFlips = totalFlips;
                        return true;
                    }
                }
            }
        }__finally{
            delete [] reflections;
        }
        return false;
    }
};



//---------------------------------------------------------------------------
#endif