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




public class PictureCanvas extends ScaleCanvas implements MouseListener, MouseMotionListener, KeyListener {
    Manager M;
    PolyWedge P,P2; //P2 is the conjugate of P
    Point JX;  
    Segment[] SEG=new Segment[50];
    int[] OPEN=new int[500];
    GeneralPath[] TILE=new GeneralPath[50];
    Color[] TILE_COLOR=new Color[50];
    int point_count;
    int segment_count;  
    int tile_count;
    int VTX;
    Complex SOURCE,SOURCE2,SOURCE3;
    PolyWedge ORBIT;
    int[] STRIPS=new int[10];
    Complex POSITION;
    Animation AN;

     public PictureCanvas() {
	 addMouseListener(this);
	 addMouseMotionListener(this);
	 addKeyListener(this);
	 P=new PolyWedge();	 
	 setScales(350,350,150);
	 tile_count=0;
	 for(int i=0;i<10;++i) SEG[i]=new Segment();
	 SOURCE=new Complex(0,0);
	 SOURCE3=new Complex(0,0);
	 initShape();
	 AN=new Animation();
	 POSITION=new Complex(0,0);
     }

    public void initShape() {
	P=new PolyWedge();
	P2=new PolyWedge();
	P=PolyWedge.random(5,.8);
                  P.slopes=Strips.sortSlopes(P);
	P.X=Strips.stripData(P,P.slopes[0]);
	P2=PolyWedge.conjugate(P);
                  P2.slopes=Strips.sortSlopes(P2);
	P2.X=Strips.stripData(P2,P2.slopes[0]);
    }




   public void paint(Graphics g2) {
      Graphics2D g=(Graphics2D) g2;
      g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
      drawBackground(g);    
      if((tile_count>0)&&(M.C2.TILEFIT.on==1)) tileFit();
      if(M.C2.POLYFIT.on==1) polyFit();
      if(M.C2.MODE.mode==0) regularDraw(g);
      if(M.C2.MODE.mode==1) stripMapDraw(g);
      if(M.C2.MODE.mode==2) outerMapDraw(g);   
   }

  public void regularDraw(Graphics2D g) {    
      if(M.C.PC.SHOW.L[2].on==1) drawWedge1(g,M.C.PC.WEDGE1.val);
      if(M.C.PC.SHOW.L[3].on==1) drawWedge2(g,M.C.PC.WEDGE2.val);   
     if(M.C.PC.SHOW.L[0].on==1) drawRegions1(g);
     if(M.C.PC.SHOW.L[1].on==1) drawRegions2(g);
     drawStrips(g);
      drawTiles(g);     
      drawInitialShape(g,0);    
      drawSpokes1(g); 
      drawSpokes2(g);
      drawPoint(g,SOURCE,Color.white);
      drawInitialShape(g,1);    
      animationDraw(g);
  }


    public void animationDraw(Graphics2D g) {
	GeneralPath gp=AuxDraw.disk(POSITION,.025,20);
	gp=transform(gp);
	g.setColor(M.C.COLOR.L[6].C);
	g.fill(gp);
	g.setColor(Color.white);
	g.draw(gp);

    }


      public void outerMapDraw(Graphics2D g) {       
          if(M.C.PC.SHOW.L[2].on==1) drawWedge1(g,M.C.PC.WEDGE1.val);
          if(M.C.PC.SHOW.L[0].on==1) drawRegions1(g);

          drawTiles(g);     
          drawInitialShape(g,0);    
          drawInitialShape(g,1);    
          doOuterMap(g);
      }

      public void stripMapDraw(Graphics2D g) {
          int n=M.C.PC.STRIP.val;
          drawStrips(g,n);   
          drawTiles(g);     
          drawInitialShape(g,0);    
          drawSpokes1(g);
          drawSpokes2(g,n);
          drawInitialShape(g,1);    
          doStripMap(g,n);
      }


    public void doOuterMap(Graphics2D g) {
	if(P.contains(SOURCE3)==0) {
	Complex w1=BilliardsMap.nextPoint(SOURCE3,P);
	Complex w2=BilliardsMap.nextPoint2(SOURCE3,P);
	drawArrow(g,SOURCE3,w1,new Color(80,100,120),1);
	drawArrow(g,w1,w2,new Color(80,100,120),1);
	drawArrow(g,SOURCE3,w2,Color.white,3);
	}
    }



    public void doStripMap(Graphics2D g,int n) {
	Complex w=StripMap.oneStepMap(P,P.slopes[n],SOURCE3);
	drawArrow(g,SOURCE3,w,Color.white,2);
    }


    public void drawArrow(Graphics2D g,Complex z1,Complex z2,Color C,int thick) {
	GeneralPath gp=new GeneralPath();
	gp=AuxDraw.disk(z1,0.025,20);
	gp=transform(gp);
	g.setColor(M.C.COLOR.L[6].C);
	g.fill(gp);
	g.setColor(Color.white);
	g.draw(gp);

	gp=AuxDraw.disk(z2,0.025,20);
	gp=transform(gp);
	g.setColor(M.C.COLOR.L[6].C);
	g.fill(gp);
	g.setColor(Color.white);
	g.draw(gp);

	double d=.2;
	if(thick==1) d=0;
	if(Complex.dist(z1,z2)>.000001) {
	    g.setStroke(new BasicStroke(thick));
	    gp=AuxDraw.getArrow(z1,z2,d);
	    gp=transform(gp);
	    g.setColor(C);
	    g.draw(gp);
	}
                  g.setStroke(new BasicStroke(1));
    }


    public Color opacify(Color C1,Lever L) {
              double s=1.0*L.val/6;
               int trans=(int)(255*s);
               Color C=new Color(C1.getRed(),C1.getGreen(),C1.getBlue(),trans);
               return(C);
    }


    public void drawBackground(Graphics2D g) {
      g.setColor(M.C.COLOR.L[0].C);
      g.fillRect(0,0,getWidth(),getHeight());  
    }


    public void drawTiles(Graphics2D g) {
	for(int i=0;i<tile_count;++i) {
	    GeneralPath X=new GeneralPath(TILE[i]);
	    X.transform(A[1]);
	    X.transform(A[0]);
	    Color C=TILE_COLOR[i];
	    C=opacify(C,M.C.PC.TRANS1);
	        g.setColor(C);
                          g.fill(X); 
	        g.setColor(C.brighter());
                          g.draw(X); 
	}
                 g.setStroke(new BasicStroke(1));
    }

    public void tileFit() {
	GeneralPath gp=new GeneralPath();
	gp.append(P.toGeneralPath(),false);
	for(int i=0;i<tile_count;++i) {
	    GeneralPath X=new GeneralPath(TILE[i]);
	    gp.append(X,false);
	}
	A=preFit(gp,0,0,700,700);
    }
    public void polyFit() {
	GeneralPath gp=new GeneralPath();
	gp.append(P.toGeneralPath(),false);
	A=preFit(gp,0,0,700,700);
    }

    public void drawInitialShape(Graphics2D g,int choice) {
	int h=getHeight();
	int w=getWidth();
	GeneralPath gp=new GeneralPath();

	try {gp=P.toGeneralPath();} catch(Exception e){System.out.println("oop");}
	gp=transform(gp);
	if(choice==0) {
	    g.setColor(M.C.COLOR.L[1].C);
	   g.fill(gp);
	}	
                  if(choice==1) {
                    g.setColor(M.C.COLOR.L[2].C);
	  g.setStroke(new BasicStroke(2));
	  g.draw(gp);	 
                    g.setStroke(new BasicStroke(1));
	}
    }

    public void drawStrips(Graphics2D g) {
	GeneralPath gp=new GeneralPath();	
	Color[] COL=new Color[2];
	for(int i=0;i<P.count;++i) {
	    if(M.C.PC.SELECT[1][i].on==1) drawStrips(g,i);
	}
    }

    public void drawStrips(Graphics2D g,int i) {
	      int j=P.slopes[i];
	      GeneralPath gp=Strips.strip(P,j,1000);
	      gp=transform(gp);
	      Color C=M.C.PC.SELECT[2][i].C;
	      C=opacify(C,M.C.PC.TRANS2);
                        g.setColor(C);      
                        g.fill(gp);
	      g.setStroke(new BasicStroke(2));   
                        g.setColor(C);
	      g.draw(gp);
	      g.setStroke(new BasicStroke(1));
    }





    public void drawRegions1(Graphics2D g) {
	boolean test=false;
	for(int i=0;i<P.count;++i) {
	    for(int j=0;j<P.count;++j) {
	      if(i!=j) {
	         try{
	              PolyWedge Q=Regions.X(P,i,j);
	              GeneralPath gp=Q.toGeneralPath();
	              test=gp.contains(SOURCE.x,SOURCE.y);
	              gp=transform(gp);    
                                g.setColor(M.C.COLOR.L[4].C);
	              g.draw(gp);
	          }
	         catch(Exception e) {}
	      }
	    }
	}
    }

    public void drawRegions2(Graphics2D g) {
	boolean test=false;
	for(int i=0;i<P.count;++i) {
	    for(int j=0;j<P.count;++j) {
	    if(i!=j) {
	      try{
	      PolyWedge Q=Regions.Y(P,i,j);
	      GeneralPath gp=Q.toGeneralPath();
	       test=gp.contains(SOURCE.x,SOURCE.y);
	       gp=transform(gp);    
                         g.setColor(M.C.COLOR.L[5].C);
	       g.draw(gp);
	      }
	      catch(Exception e) {}
	    }
	    }
	}
    }


    public void drawSpokes1(Graphics2D g) {
	GeneralPath gp=new GeneralPath();
	for(int i=0;i<P.count;++i) {
	  gp.reset();    
	    Complex[] Z=Strips.spoke(P,P.slopes[i]);
	    gp.moveTo((float)(Z[0].x),(float)(Z[0].y));
	    gp.lineTo((float)(Z[1].x),(float)(Z[1].y));
	    gp=transform(gp);    
                      g.setColor(M.C.COLOR.L[3].C);
	    g.draw(gp);
	}
    }



    public void drawSpokes2(Graphics2D g) {
	for(int i=0;i<P.count;++i) {    
	    if(M.C.PC.SELECT[3][i].on==1) drawSpokes2(g,i);
	}
    }

    public void drawSpokes2(Graphics2D g,int i) {
 	g.setStroke(new BasicStroke(3));
	GeneralPath gp=new GeneralPath();
                      Complex[] Z=Strips.spoke(P,P.slopes[i]);
	    gp.moveTo((float)(Z[0].x),(float)(Z[0].y));
	    gp.lineTo((float)(Z[1].x),(float)(Z[1].y));
	    gp=transform(gp);
                      g.setColor(M.C.PC.SELECT[4][i].C);
	    g.draw(gp);
	g.setStroke(new BasicStroke(1));

    }


    public void drawWedge1(Graphics2D g,int i) {
	GeneralPath gp=new GeneralPath();
	      gp=Sectors.getSector(P,i);
	      gp=transform(gp);
	      g.setColor(new Color(100,0,0,200));
	      g.fill(gp);
    }
    public void drawWedge2(Graphics2D g,int i) {
	GeneralPath gp=new GeneralPath();
	      gp=Sectors.getAntiSector(P,i);
	      gp=transform(gp);
	      g.setColor(new Color(0,0,100,200));
	      g.fill(gp);
    }


    public void doRun() { 
       reset();
       int[] X=PinwheelControl.pinwheelProbe(P,SOURCE);
       PolyWedge Y=probeRecord(SOURCE,X[1],X[0]);
       drawProbeTile(Y,SOURCE,X[1],X[0]);
    }


    public PolyWedge probeRecord(Complex z,int n,int start) {
	for(int i=0;i<10;++i) STRIPS[i]=-1;
	int zoop=0;
	EnhancedComplex E=new EnhancedComplex(z,start);
	PolyWedge Y=new PolyWedge();
	Y.count=n+1;
	M.C.PC.WEDGE1.val=start;
                   Y.z[0]=new Complex(E.z);
	for(int i=0;i<n;++i) {	
	    EnhancedComplex E0=new EnhancedComplex(E);
	   E=StripMap.oneStepMap(P,E);  
	   if(Complex.dist(E0.z,E.z)>.00001) {
                              M.C.PC.SELECT[3][E0.n].on=1;
                              M.C.PC.SELECT[2][E0.n].C=PinwheelControl.getColor(zoop,P.count);
                              M.C.PC.SELECT[4][E0.n].C=PinwheelControl.getColor(zoop,P.count);
	            M.C.PC.WEDGE2.val=E0.n;
	            STRIPS[zoop]=E0.n;
	            ++zoop;
	   }

                     Y.z[i+1]=new Complex(E.z);
	}
	ORBIT=new PolyWedge(Y);
	return(Y);
    }



    public void drawProbeTile(PolyWedge Y,Complex z,int n,int start) {
	EnhancedComplex E=new EnhancedComplex(z,start);
	PolyWedge Q=TileComputer.getTileStatic(SOURCE,1,P);
	Complex zz=new Complex(0,0);
	for(int i=0;i<Y.count;++i) {
	    try{ zz=Complex.minus(Y.z[i],Y.z[i-1]);}
	    catch(Exception e) {}
	    if((i==0)||(zz.norm()>.000001)) {
	          Q=Q.translate(zz);
                            TILE[tile_count]=Q.toGeneralPath();  
	          TILE_COLOR[tile_count]=PinwheelControl.getColor(tile_count,P.count);
	          if(i==Y.count-1) TILE_COLOR[tile_count]=new Color(0,0,255,180);
	          ++tile_count;  
	    } 
	}

    }

    public void reset() {  
                 tile_count=0;
                 point_count=0;
	for(int i=0;i<20;++i) M.C.PC.SELECT[3][i].on=0;
	for(int i=0;i<20;++i) M.C.PC.SELECT[2][i].C=new Color(30,40,50);
	for(int i=0;i<20;++i) M.C.PC.SELECT[4][i].C=Color.black;

    }

    public void mouseClicked(MouseEvent e) {
	MouseData J=MouseData.process(e);
	Point X=J.X;
	int but=J.mode; 
	doMouseClick(X,but);
    }


    public void setVertex() {
	P.z[VTX]=new Complex(SOURCE2);   
                  P.slopes=Strips.sortSlopes(P);
	P.X=Strips.stripData(P,P.slopes[0]);
	PolyWedge P2=PolyWedge.conjugate(P);
                  P2.slopes=Strips.sortSlopes(P2);
	P2.X=Strips.stripData(P2,P2.slopes[0]);
    }

    public void findNearest() {
	int n=P.nearestVertex(SOURCE2);
	VTX=n;
    }

    public void doMouseClick(Point X,int mode) {
        if(mode==1) scaleUp(X,-1);
        if(mode==3) scaleUp(X,+1);

         if((M.C2.MODE.mode==0)&&(mode==2)) {
                   SOURCE=unTransform(X);     
                   SOURCE3=unTransform(X);
       }

         if((M.C2.MODE.mode>=1)&&(mode==2)) {
                   SOURCE3=unTransform(X);
       }


       if(M.C2.MODE.mode==0) {
 	 try {doRun();}
	 catch(Exception ee) {}
       }
              AN.halt=0;
              POSITION=new Complex(SOURCE);
              M.repaint();
    }


    public void mouseEntered(MouseEvent e) {
	requestFocus();
    }

     public void mouseMoved(MouseEvent e) {
	 try {MouseData J=MouseData.process(e);
	     JX=J.X;
	 }
	 catch(Exception ee) {}
     }

    public void keyTyped(KeyEvent e) {
	char ch = e.getKeyChar();
	int test=0;
	if(ch=='z') test=1;
	if(ch=='x') test=2;
	if(ch=='c') test=3;
	if(ch=='v') test=4;
	if(test>0) doMouseClick(JX,test);
	if(test==4) {
	    SOURCE2=unTransform(JX);
	    findNearest();
                      setVertex();    
                       try {doRun();}
  	     catch(Exception ee) {}
	}

    }

	public void keyPressed(KeyEvent e) {}
        public void keyReleased(KeyEvent e) {}



}