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

/**This class generates the arithmetic graph.**/

public class ArithmeticGraph {
    Manager M;

    public ArithmeticGraph() {}

    public ArithmeticGraph(Manager MM) {
	this.M=MM;
    }

    /**Here is the final routine**/

    public GeneralPath orbit(int i,int j) {
	Complex Z0=new Complex(3.5,2);
	int choice=i;
	int power=M.C.INIT.val;
	int type=-1;
	int lim=(int)(Math.pow(3,10));
	return(orbit(Z0,choice,power,lim));
    }

    public GeneralPath orbit(Complex Z0,int choice,int power,int lim) {
	Complex Z1=new Complex(Z0);
	for(int i=0;i<power;++i) Z1=Renormalize.thetaInverse(Z1);
	int scaling=power-1;
	double ss=Math.sqrt(3);
	if(choice==3) ss=Math.sqrt(2)+1;
	ss=Math.pow(ss,-scaling);

	Complex Z2=new Complex(Z1);
	GeneralPath gp=new GeneralPath();
	gp.moveTo(0,0);
	Complex path=new Complex();
	int halt=1;
	int count=0;
	int parity=0;

	while((halt==1)&&(count<lim)) {
	   ++count;
	   path=nextPoint(choice,Z2,path,parity,ss);   
	   gp.lineTo((float)(path.x),(float)(path.y)); 
                      int temp=getParity(Z2);   
                      parity=(parity+temp)%2;
                      Z2=nextPoint1(Z2);
	    if(Complex.dist(Z2,Z1)<.0000001) halt=0;
	}
	return(gp);
    }


    /**This routine computes the actual orbit in the dynamical plane**/

    public Complex[] plainOrbit(Complex Z1,int lim) {
	Complex Z2=new Complex(Z1);
	int halt=1;
	int count=0;
	int parity=0;

	Complex[] W1=new Complex[lim];
	while((halt==1)&&(count<lim)) {
                     W1[count]=new Complex(Z2);
	   W1[count].TYPE=parity;
	   parity=(parity+getParity(Z2))%2;
                      Z2=nextPoint1(Z2);
	    if(Complex.dist(Z2,Z1)<.0000001) halt=0;
	    ++count;
	}
	Complex[] W2=new Complex[count];
	for(int i=0;i<count;++i) W2[i]=new Complex(W1[i]);
	return(W2);
    }







    public int getParity(Complex z) {
	int n=PolyData.getNumber(z);
	Complex w=PolyData.getGraph(0,n);
	if(w.x>0) return(0);
	return(1);
    }


    /**The dynamical map**/

          public Complex nextPoint1(Complex z) {
	int n=PolyData.getNumber(z);
	Complex w=PolyData.getGraph(1,n);
	w=Complex.plus(w,z);
	return(w);
       }

    /**chooses either G2 or G3**/

    public Complex nextPoint(int choice,Complex z,Complex p1,int parity,double ss) {
	if(choice==2) return(nextPoint2(z,p1,parity,ss));
	return(nextPoint3(z,p1,parity,ss));
    }


    /**The map for G2*/
    public static Complex nextPoint2(Complex z,Complex p1,int parity,double ss) {
	int n=PolyData.getNumber(z);
	Complex w=PolyData.getGraph(2,n);
	w=new Complex(ss*w.x,ss*w.y);
	Complex p2=Complex.plus(p1,w);
	if(parity==1)  p2=Complex.minus(p1,w);
	return(p2);
    }

    /**The map for G3*/
    public static Complex nextPoint3(Complex z,Complex p1,int parity,double ss) {
                  double x=Math.sqrt(2);
	Complex CENTER=new Complex(3.0/2+3*x/2,3.0/2);
	Complex zz=Complex.plus(CENTER,Complex.minus(CENTER,z));
	int n=PolyData.getNumber(z);
	if(parity==1) n=PolyData.getNumber(zz);
	Complex w=PolyData.getGraph(3,n);	
                  w=new Complex(ss*w.x,ss*w.y);	
	Complex p2=Complex.plus(p1,w);
	if(parity==1)  p2=Complex.minus(p1,w);
	return(p2);
    }

}