import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import java.awt.geom.*;
import java.math.*;


/**This class does the math for the outer billiards map*/

public class BilliardsMap {

    public BilliardsMap() {}

    /**This routine tests whether the point z is contained in the kth sector determined by a polygon**/

    public static int testSector(PolyWedge P,Complex z,int k) {
	int k1=(k+0)%P.count;
	int k2=(k+1)%P.count;
	int k3=(k+2)%P.count;
	Complex z1=P.z[k1];
	Complex z2=P.z[k2];
	Complex z3=P.z[k3];
	z3=new Complex(2*z2.x-z3.x,2*z2.y-z3.y);
	int test1=Complex.notNegativelyOriented(z,z1,z2);
	int test2=Complex.notNegativelyOriented(z,z2,z3);
	if((test1==0)&&(test2==0)) return(1);
	if((test1==0)&&(test2==1)) return(-1);
	if((test1==1)&&(test2==0)) return(-2);
	return(0);
    }

    /**This routine determines which sector a point lies in**/

    public static  int testSector(PolyWedge P,Complex z) {
	int test=-1;
	for(int i=0;i<P.count;++i) {
	    if(testSector(P,z,i)==1) test=i;
	}
	return(test);
    }


    /**This routine determines which vertex will be used for the outer billiards map.**/

    public static  int getGoodVertex(PolyWedge P,Complex z) {
	int test=-1;
	for(int i=0;i<P.count;++i) {
	    if(testSector(P,z,i)==1) test=i;
	}
	if(test==-1) return(-1);
	test=(test+1)%P.count;
	return(test);
    }

    /**This is the basic outer billiards map*/

    public static Complex nextPoint(Complex z,PolyWedge Q) {
	int k=BilliardsMap.testSector(Q,z);
	k=(k+1)%Q.count;
	Complex q=Q.z[k];
	Complex w=new Complex(2*q.x-z.x,2*q.y-z.y);
                  return(w);
    }

    /**The inverse map**/

    public static Complex previousPoint(Complex z2,PolyWedge Q2) {
	Complex z=z2.conjugate();
	PolyWedge Q=PolyWedge.conjugate(Q2);
	int k=BilliardsMap.testSector(Q,z);
	k=(k+1)%Q.count;
	Complex q=Q.z[k];
	Complex w=new Complex(2*q.x-z.x,2*q.y-z.y);
        return(w.conjugate());
    }

    /**The square of the outer billiards map**/
    public static Complex nextPoint2(Complex z,PolyWedge Q) {
	Complex w=new Complex(z);
	w=nextPoint(w,Q);
	w=nextPoint(w,Q);
	return(w);
    }
    
     /**The inverse of the square map**/
    public static Complex previousPoint2(Complex z,PolyWedge Q) {
	Complex w=new Complex(z);
	w=previousPoint(w,Q);
	w=previousPoint(w,Q);
	return(w);
    }


    /**Keeps track of the vertices involved**/

    public static EnhancedComplex nextPoint(EnhancedComplex E,PolyWedge Q) {
	Complex z=new Complex(E.z);
	int k=BilliardsMap.testSector(Q,E.z);
	k=(k+1)%Q.count;
	Complex q=Q.z[k];
	Complex w=new Complex(2*q.x-z.x,2*q.y-z.y);
	EnhancedComplex F=new EnhancedComplex(w,k);
	return(F);
    }

    public static EnhancedComplex nextPoint2(EnhancedComplex E0,PolyWedge Q) {
	EnhancedComplex E1=nextPoint(E0,Q);
	EnhancedComplex E2=nextPoint(E1,Q);
	return(E2);
    }






}