package Current.search.basic;

import java.util.LinkedList;
import java.awt.geom.GeneralPath;
import java.util.ListIterator;
import java.awt.geom.Point2D;
import java.awt.Dimension;
import java.awt.geom.AffineTransform;

import Current.basic.*;

/**
 * This is a version of the unfolding used in searching.
 * It only keeps track of enough information to run
 * the slalom test.
 */
public class MarkedSlalomUnfolding {
    public MarkedSlalomHull sh;
    public ListenTriangle t0,t1;
    int first_side,last_side;
    boolean first_even, last_even;
    
    public static class DataBackup{
        ListenTriangle t0, t1;
        int first_side, last_side;
        boolean first_even,last_even;
        MarkedSlalomHull.DataBackup db;
        
        public DataBackup(MarkedSlalomUnfolding su){
            t0=new ListenTriangle(su.t0);
            t1=new ListenTriangle(su.t1);
            last_side=su.last_side;
            first_side=su.first_side;
            first_even=su.first_even;
            last_even=su.last_even;
            db=su.sh.backup();
        }
    }
    
    /** Compute an unfolding using the given triangle.
     * Add the triangle obtained by reflection in edge i (i=0,1,2)
     */
    public MarkedSlalomUnfolding(Complex z, int i, boolean mark_left, boolean mark_right){
        t0=ListenTriangle.init2(z);
        t1=ListenTriangle.init2(z);
        sh=new MarkedSlalomHull(new MarkedComplex(t0.z[(i+2)%3],mark_left),new MarkedComplex(t0.z[(i+1)%3],mark_right));
        first_even=false;
        last_even=true;
        first_side=last_side=i;
        //t=t.reflect(i);
        t1.reflectMe(i);
    }
    
    public final DataBackup backup(){
        return new DataBackup(this);
    }
    
    public final void recover(DataBackup db){
        t0=db.t0;
        t1=db.t1;
        last_side=db.last_side;
        first_side=db.first_side;
        first_even=db.first_even;
        last_even=db.last_even;
        sh.recover(db.db);
    }
    
    /** Copy Constructor */
    //    public SlalomUnfolding(SlalomUnfolding su){
    //        sh=new SlalomHull(su.sh);
    //        t=new ListenTriangle(su.t);
    //
    //        even=su.even;
    //        last_side=su.last_side;
    //    }
    
    
    /** Return the size of the SlalomHull */
    public final int size(){
        return sh.size();
    }
    
    /**
     * add the triangle obtained by reflection in edge i (i=0,1,2)
     */
    public final boolean addLastEdge(int i){
        int ls=last_side;
        t1.reflectMe(i);
        //t=t.reflect(i);
        
        last_even=!last_even;
        if (last_even) {
            if (i==(last_side+1)%3) {
                last_side=i;
                return sh.addToLeftLast(t1.z[ls]);
            } else {
                last_side=i;
                return sh.addToRightLast(t1.z[ls]);
            }
        } else {
            if (i==(last_side+1)%3) {
                last_side=i;
                return sh.addToRightLast(t1.z[ls]);
            } else {
                last_side=i;
                return sh.addToLeftLast(t1.z[ls]);
            }
        }
    }
    
    
    
    /** Return false if the hull will be destroyed
     * when i is added.
     */
    public final boolean survivesAddLast(int i){
        if (last_even) {
            if (i==(last_side+1)%3) {
                return sh.survivesRightLastAdd(t1.z[last_side]);
            } else {
                return sh.survivesLeftLastAdd(t1.z[last_side]);
            }
        } else {
            if (i==(last_side+1)%3) {
                return sh.survivesLeftLastAdd(t1.z[last_side]);
            } else {
                return sh.survivesRightLastAdd(t1.z[last_side]);
            }
        }
    }
    
    /**
     * add the triangle obtained by reflection in edge i (i=0,1,2)
     */
    public final boolean addFirstEdge(int i){
        int ls=first_side;
        t0.reflectMe(i);
        //t=t.reflect(i);
        
        first_even=!first_even;
        if (first_even) {
            if (i==(first_side+1)%3) {
                first_side=i;
                return sh.addToRightFirst(t0.z[ls]);
            } else {
                first_side=i;
                return sh.addToLeftFirst(t0.z[ls]);
            }
        } else {
            if (i==(first_side+1)%3) {
                first_side=i;
                return sh.addToLeftFirst(t0.z[ls]);
            } else {
                first_side=i;
                return sh.addToRightFirst(t0.z[ls]);
            }
        }
    }
    
    
    
    /** Return false if the hull will be destroyed
     * when i is added.
     */
    public final boolean survivesAddFirst(int i){
        if (first_even) {
            if (i==(first_side+1)%3) {
                return sh.survivesLeftFirstAdd(t0.z[first_side]);
            } else {
                return sh.survivesRightFirstAdd(t0.z[first_side]);
            }
        } else {
            if (i==(first_side+1)%3) {
                return sh.survivesRightFirstAdd(t0.z[first_side]);
            } else {
                return sh.survivesLeftFirstAdd(t0.z[first_side]);
            }
        }
    }
    
    
    /** z is a vector pointing in the direction of holonomy of the unfolding */
    public final boolean strongTest(){
        // this depends on the fact that the initial triangle satisfies t.z[0]=0
        return sh.strongTest(t1.z[0].minus(t0.z[0]));
    }
    
    public void printDebug() {
        System.out.println("t0="+t0+" and t1="+t1);
        System.out.println("first_side="+first_side+" and last_side="+last_side);
        System.out.println("first_even="+first_even+" and last_even="+last_even);
        sh.printDebug();
    }
}