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


public class SnowflakeGenerator  {
    Wedge[] WEDGE=new Wedge[25000];
    int COUNT;

    public SnowflakeGenerator() {
    }



    /**THE TWO MAIN SUBDIVISION SCHEMES**/


    /**This does the plain subdivision scheme.**/

    public GeneralPath getSnowflake(int k) {
	iteratedRefineWedge(k);	
	GeneralPath gp=new GeneralPath();
	GeneralPath gp2=new GeneralPath();
	for(int i=0;i<COUNT;++i) {
	    gp2=WEDGE[i].toGeneralPath();
	    gp.append(gp2,false);
	}
	 return(gp);
    }

    public Wedge[] getSnowflakeList(int level) {
                   iteratedRefineWedge(level);
	Wedge[] Q=new Wedge[COUNT];
	for(int i=0;i<COUNT;++i) Q[i]=new Wedge(WEDGE[i]);
	return(Q);
    }

    /**This does the edge-targeted subdivision scheme.  Assuming that the
          two complex numbers Z0 and Z1 are both right angle vertices of the snowflake,
          this does the minimal substitution needed to expose these vertices.**/

    public void makeSnowflake(Complex[] Z) {
	 iteratedRefineWedge(Z);
	int[] I=new int[2];
	I[0]=getVertexIndex(Z[0]);
	I[1]=getVertexIndex(Z[1]);
	iteratedRefineWedge(Z,WEDGE[I[0]],WEDGE[I[1]]);
    }

    public GeneralPath getSnowflake(Complex[] Z) {
	makeSnowflake(Z);
	GeneralPath gp=new GeneralPath();
	GeneralPath gp2=new GeneralPath();
	for(int i=0;i<COUNT;++i) {
	    gp2=WEDGE[i].toGeneralPath();
	    gp.append(gp2,false);
	}
	 return(gp);
    }

    public Wedge[] getSnowflakeList(Complex[] Z) {
	makeSnowflake(Z);
	Wedge[] W=new Wedge[COUNT];
	for(int i=0;i<COUNT;++i) {
	    W[i]=new Wedge(WEDGE[i]);
	}
	return(W);
    }





    /**AUXILLIARY ROUTINES**/

    public void initializeWedges() {
	COUNT=8;
	for(int i=0;i<8;++i)
	WEDGE[i]=Wedge.initialWedge(i);
    }


    /**support for the basic refinement scheme**/

    public void iteratedRefineWedge(int val) {     
	initializeWedges();
	for(int i=0;i<val;++i) {
	    refine(i%2);
	}
    }

    public void refine(int type) {
	Wedge[] temp3=new Wedge[5*COUNT];
	int count=0;

	for(int i=0;i<COUNT;++i) {
	    if(WEDGE[i].type!=type) {
		temp3[count]=new Wedge(WEDGE[i]);
	              ++count;
	    }
	    if(WEDGE[i].type==type) {
	       Wedge[] temp2=WEDGE[i].subdivide();
	       for(int j=0;j<temp2.length;++j) {
		temp3[count]=new Wedge(temp2[j]);
		++count;
	       }
	    }
	}
	COUNT=count;
	for(int i=0;i<COUNT;++i) {
	    WEDGE[i]=new Wedge(temp3[(i+2)%COUNT]);
	}
    }


    /**support for the targeted subdivision scheme.**/


    public void iteratedRefineWedge(Complex[] Z) {   
                   initializeWedges();   
	 int count=0;  
	 while((count<8)&&(testVertex(Z[0],Z[1])==false)) {
                       refine(Z[0],Z[1]);
	     ++count;
	  }
    }

    public void iteratedRefineWedge(Complex[] Z,Wedge W1,Wedge W2) {
                   initializeWedges();   
	 int count=0;  
	 while((count<8)&&(testVertex(Z[0],Z[1])==false)) {
	     refine(Z,W1,W2);
	     ++count;
	  }
    }

    /**locates the vertex in a finite list of wedges.**/

    public boolean testVertex(Complex z) {
	for(int i=0;i<COUNT;++i) {
	    if(Complex.dist(WEDGE[i].z[2],z)<.00000001) return(true);
	}
	return(false);
    }

    public int getVertexIndex(Complex z) {
	for(int i=0;i<COUNT;++i) {
	    if(Complex.dist(WEDGE[i].z[2],z)<.00000001) return(i);
	}
	return(-1);
    }

    public boolean testVertex(Complex z1,Complex z2) {
	if(testVertex(z1)==false) return(false);
	if(testVertex(z2)==false) return(false);
	return(true);
    }


    /**This is a preliminary routine that does somewhat more than
       the minimal amount of refining needed to expose the vertices.*/

    public void refine(Complex z1,Complex z2) {
	    Wedge[] temp3=new Wedge[5*COUNT];
	    int count=0;
	for(int i=0;i<COUNT;++i) {
	    boolean test1=WEDGE[i].isNear(z1,z2);
	    boolean test2=true;
	    if(test1==false) test2=false;

	    if(test2==true) {
	       Wedge[] temp2=WEDGE[i].subdivide();
	       for(int j=0;j<temp2.length;++j) {
		temp3[count]=new Wedge(temp2[j]);
		++count;
	       }
	    }

	    if(test2==false) {
		temp3[count]=new Wedge(WEDGE[i]);
	              ++count;
	    }
	}
	COUNT=count;
	for(int i=0;i<COUNT;++i) {
	    WEDGE[i]=new Wedge(temp3[(i+2)%COUNT]);
	}
    }


    /**This routine only works once we have produced two wedges
          W1 and W2 that contain the vertices Z[0] and Z[1].  The
	  crude refinement scheme produces this for us.*/

    public void refine(Complex[] Z,Wedge W1,Wedge W2) {
	    Wedge[] temp3=new Wedge[5*COUNT];
	    int count=0;
	for(int i=0;i<COUNT;++i) {
	    boolean test1=WEDGE[i].isMinimalParent(Z[0],W1);
	    boolean test2=WEDGE[i].isMinimalParent(Z[1],W2);
	    boolean test3=false;
	    if(test1==true) test3=true;
	    if(test2==true) test3=true;

	    if(test3==true) {
	       Wedge[] temp2=WEDGE[i].subdivide();
	       for(int j=0;j<temp2.length;++j) {
		temp3[count]=new Wedge(temp2[j]);
		++count;
	       }
	    }

	    if(test3==false) {
		temp3[count]=new Wedge(WEDGE[i]);
	              ++count;
	    }
	}
	COUNT=count;
	for(int i=0;i<COUNT;++i) {
	    WEDGE[i]=new Wedge(temp3[(i+2)%COUNT]);
	}
    }




}