import java.applet.Applet;
import java.awt.event.*;
import java.awt.*;
import java.awt.geom.*;
import java.util.Arrays;

/**This class defines and manipulates the strips
   associated to a polygon**/


public class StripMap {
    public StripMap() {}




    /**Computes the position of a point relative to the strip.**/

    public static double relStrip(PolyWedge P,int n,Complex u) {
	Complex[] X=Strips.stripData(P,n);
	Complex z1=X[0];
	Complex z2=X[1];
	Complex w1=X[2];
	Complex w2=X[3];
	double a1=Complex.area(z1,z2,u);
	double a2=Complex.area(z1,z2,w1);
	double a3=a1/a2;
	return(a3);
    }


    /**always a non-negative integer*/

    public static int relStripIntegerAbs(PolyWedge P,int n,Complex u) {
        double a=relStrip(P,n,u);
        a=Math.abs(Math.floor(a));
        int b=(int)(a);
        return(b);
    }

    /**same as previous, but signed integer**/

    public static int relStripInteger(PolyWedge P,int n,Complex u) {
        double a=relStrip(P,n,u);
        a=Math.floor(a);
        int b=(int)(a);
        return(b);
    }




    /**This is the basic strip map.  P is the polygon.  n is the strip.  u is the starting point   **/

    public static Complex map(PolyWedge P,int n,Complex u) {
	Complex[] X=Strips.stripData(P,n);
	Complex v=Complex.minus(X[3],X[1]);
	double a=relStrip(P,n,u);
	a=Math.floor(a);
	v=new Complex(a*v.x,a*v.y);
	Complex w=Complex.minus(u,v);
	return(w);
    }

    /**This is the N-fold composition of the strip map**/

    public static Complex stripMap(PolyWedge P,Complex u,int start) {
	Complex z=new Complex(u);
	int N=2*P.count;
	for(int i=start+1;i<=N+start;++i) {  
                      z=map(P,P.slopes[i%N],z); 
	}
	return(z);
    }



    /**This routine is used with the arithmetic graph computer**/

    public static int[] arithmeticGraph(PolyWedge P,Complex u) {
                  int N=2*P.count;
	int tor;
	int[] fin=new int[P.count];
	Complex z=new Complex(u);
	for(int i=1;i<=N;++i) {  
	    tor=relStripInteger(P,P.slopes[i%N],z);
                      int[] vec=Strips.stripVector(P,P.slopes[i%N]);
	    for(int j=0;j<P.count;++j) {
		fin[j]=fin[j]+tor*vec[j];
	    }
                      z=map(P,P.slopes[i%N],z); 
	}
	return(fin);
    }




    /**These routines are used in the pinwheel computer**/

    public static EnhancedComplex oneStepMap(PolyWedge P,EnhancedComplex E) {
	int n=P.slopes[E.n];
	Complex w=oneStepMap(P,n,E.z);
	EnhancedComplex F=new EnhancedComplex(w,E.n);
                  if(Complex.dist(E.z,w)<.000000001) F.n=(F.n+1)%P.count;
	return(F);
    }

    public static Complex oneStepMap(PolyWedge P,int n,Complex u) {
	Complex[] X=Strips.stripData(P,n);
	Complex v=Complex.minus(X[3],X[1]);
	double a=relStrip(P,n,u);
	a=Math.floor(a);
	if(a>1) a=1;
	if(a<0) a=-1;
	v=new Complex(a*v.x,a*v.y);
	Complex w=Complex.minus(u,v);
	return(w);
    }


    /**These are used for the torus computer.  Probably these routines
       will be scrapped at some point.**/

    public static int[] integerMap(PolyWedge P,Complex u,int start) {
	int[] tor=integerMapRaw(P,u,start);	
	int[] tor2=new int[P.count];
	for(int i=0;i<P.count;++i) {
	    tor2[i]=tor[i]+tor[i+P.count];
	}
	return(tor2);
    }

    public static int[] integerMapRaw(PolyWedge P,Complex u,int start) {	
                  int N=2*P.count;
                  int[] tor=new int[N];
	Complex z=new Complex(u);
	for(int i=start+1;i<=N+start;++i) {  
	    tor[i-start-1]=relStripInteger(P,P.slopes[i%N],z);
                      z=map(P,P.slopes[i%N],z); 
	}
	return(tor);
    }



    /**Used with the tile computer**/


    public static Complex moveToZero(PolyWedge P,Complex z0) {

	int test=0;
	Complex z1=new Complex(z0);
	while(test==0) {   
	    test=Strips.insideStripPositive(P,P.slopes[0],z1);
	    if(test==1) return(z1);
	    z1=BilliardsMap.nextPoint2(z1,P);
	}
	return(z1);
    }


}