//=====================================================================
// File: LorenzCanvas.java
//
// Applied Math 303, Term Project
// Blair Fraser, 2303725
//=====================================================================

import java.awt.*;

public class LorenzCanvas extends Canvas implements Runnable{
  //===================================================================
  // Variables
  //
  //===================================================================
  Lorenz equation;
  private int windowxPos, windowyPos;
  private int oldWindowxPos, oldWindowyPos;
  private int keskx=0, kesky=0, ekeskx=0, ekesky=0, grtegur=400;
  private Image pilt, sahver;
  private Graphics piltg, sahverg;
  private Color taustavarv=Color.white, joonevarv=Color.blue;
  int punktinr=0, punktidearv=1000;
  RPunkt[] punktid=new RPunkt[punktidearv];
  private RPunkt vp=new RPunkt(0, 0, -20);
  private RPunkt vs=new RPunkt(0, 0, 0);
  private boolean veelliigutada=false;
  private int ooteaeg=10, korgus=400, laius=500;
  Button liiklusnupp;
  //===================================================================
  // Methods
  //
  //===================================================================

  //===================================================================
  // Constructor
  //
  // Construct a lorenz canvas with all values set to zero.
  //===================================================================
  public LorenzCanvas() {
    super();
    resize(getPreferredSize());
    equation = new Lorenz();
  }

  //===================================================================
  // Accessors
  //
  //===================================================================

  public void seaVaatePunkt(double x, double y, double z){
    vp.sea(x, y, z);
    joonista();
  }
  public void seaVaateSuund(double x, double y, double z){
    vs.sea(x, y, z);
//    System.out.println(vs);
    joonista();
  }

  public void setInitialState(double t, double x, double y, double z) {
    equation.setInitialState(t, x, y, z);
  }    

  public void setTimeStep(double step) {
    equation.setTimeStep(step);
  }

  public void seaLiiklusNupp(Button b){
    liiklusnupp=b;
  }

  //===================================================================
  // SetDomain
  //
  // Set the section of phase space that the plot will show.
  //===================================================================

  public void seaTaustavarv(Color c){
    taustavarv=c;
    setBackground(c);
  }
  public void seaJoonevarv(Color c){
    joonevarv=c;
    setForeground(c);
  }



  //===================================================================
  // restart
  //
  // Restart the oscillator from the initial state.
  //===================================================================
  public void restart() {
    equation.reset();
    pilt = null;
    sahver=null;
    arvuta();
    joonista();
  }
  public void liiguta(){
    equation.reset();
    sahverg.setColor(taustavarv);
    sahverg.fillRect(0, 0, size().width, size().height);
    sahverg.setColor(joonevarv);
    (new Thread(this)).start();
  }
  public void seiska(){veelliigutada=false;
    if(liiklusnupp!=null) liiklusnupp.setLabel(" * Go * ");
  }

  //===================================================================
  //  minimumSize: returns a minimum size for the canvas.
  //===================================================================
  public Dimension minimumSize() {
    return new Dimension(400,350);
  }

  //===================================================================
  //  preferedSize: returns a good size for the canvas.
  //===================================================================
  public Dimension preferredSize() {
    return new Dimension(600,600);
  }


  //===================================================================
  // increment
  //
  // Increment the double well oscillator, map the new point onto the
  // window.
  //===================================================================

  public void arvuta(){
  equation.setInitialState(200, 1, 1, 0);
  for(punktinr=0; punktinr<punktidearv; punktinr++){
    punktid[punktinr]=new RPunkt(equation.getx(),
                         equation.gety(), equation.getz());
    equation.increment();
   }
/*   punktid[0]=new RPunkt(-10, -10, 0);
   punktid[1]=new RPunkt(-10,  10, 0);
   punktid[2]=new RPunkt( 10,  10, 0);
   punktid[3]=new RPunkt( 10, -10, 0);  */

 /*  double nurk=0, raadius=10.0;
   for(punktinr=0; punktinr<punktidearv; punktinr++){
    punktid[punktinr]=new RPunkt(raadius*Math.sin(nurk),
                                  raadius*Math.cos(nurk), punktinr/10.0);
   nurk+=Math.PI/50;

   } */  
   joonista();
  }
/*
 public void joonista(){
  if(pilt!=null){
   piltg.setColor(Color.white);
   piltg.fillRect(0, 0, size().width, size().height);
   piltg.setColor(Color.black);
   for(punktinr=0; punktinr<punktidearv; punktinr++){
    try{
    windowxPos=ekraanix(punktid[punktinr]);
    windowyPos=ekraaniy(punktid[punktinr]);
    piltg.drawLine(oldWindowxPos, oldWindowyPos, windowxPos, windowyPos);
    oldWindowxPos=windowxPos; oldWindowyPos=windowyPos;
    } catch (Exception e){}
   }
  }
  repaint();
 }
*/
 public  void joonista(){
  if((pilt!=null)&(piltg!=null)&(punktid[0]!=null)){
   piltg.setColor(taustavarv);
   piltg.fillRect(0, 0, size().width, size().height);
   piltg.setColor(joonevarv);
//   System.out.println(vs);
   for(punktinr=1; punktinr<punktidearv; punktinr++){
    joon(punktid[punktinr-1], punktid[punktinr], vp, vs, piltg);
   }
  }
  repaint();
 }

  //===================================================================
  // update
  //
  // Update method for double buffering animation.
  //===================================================================
  public void update(Graphics g) {
    if((pilt == null)||(korgus!=size().height)||(laius!=size().width)) {
      korgus=size().height; laius=size().width;
      pilt = createImage(laius, korgus);
      sahver = createImage(laius, korgus);
      ekeskx=laius/2;
      ekesky=korgus/2;
      piltg = pilt.getGraphics();
      sahverg=sahver.getGraphics();
      piltg.setColor(getBackground());
      piltg.fill3DRect(0, 0, laius, korgus, false);
      joonista();
    } else {
      if(piltg == null) {
        piltg = pilt.getGraphics();
      }}
      paint(g);
//      g.drawImage(pilt, 0, 0, this);
  } 

  //===================================================================
  // paint
  //
  // Paint method for the canvas.
  //===================================================================
  public void paint(Graphics g) {

    if(pilt!=null)g.drawImage(pilt, 0, 0, this);

  }


public void joon(RPunkt p1, RPunkt p2,  Graphics g){
           int varv=leiaVarv(p1);
//           System.out.println(p1+" "+varv);
           g.setColor(new Color(varv, varv, varv));

 try{
        if((p1.z>0)&(p2.z>0))
           g.drawLine(ekraanix(p1), ekraaniy(p1),
                      ekraanix(p2), ekraaniy(p2));
  else  if((p1.z>0)^(p2.z>0)){
           RPunkt ap1, ap2;
           if(p2.z>0){
             ap1=p2.koopia(); ap2=p1.koopia();
           }
           else{ap1=p1.koopia(); ap2=p2.koopia();}
           double osa=0.9*(ap1.z)/(ap1.z-ap2.z);
           ap2.x=ap1.x+osa*(ap2.x-ap1.x);
           ap2.y=ap1.y+osa*(ap2.y-ap1.y);
           ap2.z=ap1.z+osa*(ap2.z-ap1.z);
//           if(ap2.z<0){System.out.println("ap2 "+ap2);}
           g.drawLine(ekraanix(ap1), ekraaniy(ap1),
                      ekraanix(ap2), ekraaniy(ap2));

        }
  } catch(Exception e){System.out.println(e.getMessage()+p1+" "+p2);}
}

public void joon(RPunkt p1, RPunkt p2, RPunkt vp, RPunkt vs, Graphics g){
 RPunkt up1=p1.lahuta(vp).keera(-vs.x, -vs.y, -vs.z);
 RPunkt up2=p2.lahuta(vp).keera(-vs.x, -vs.y, -vs.z);
// System.out.println(p1+"\n"+p2+"\n"+up1+"\n"+up2+" "+vp);
 joon(up1, up2, g);
}

/*try{
 if((up1.z>0)&(up2.z>0))g.drawLine(ekraanix(up1), ekraaniy(up1),
                                   ekraanix(up2), ekraaniy(up2));
 }catch(Exception e){}
  else if((up1.z<0)^(up2.z<0)){
  if(up1.z<0){
   RPunkt abi=up1; up1=up2; up2=abi;
  }
  double osa=-up2.z/(up1.z-up2.z);
  up2=up2.liida(up1.lahuta(up2).korruta(osa));
//  System.out.println(up2);
  while(up2.z<=0){up2=up2.liida(up1.lahuta(up2).korruta(osa*0.1));}
  g.drawLine(ekraanix(up1), ekraaniy(up1),
                                   ekraanix(up2), ekraaniy(up2));
 }*/
  public int leiaVarv(RPunkt p){
    double kaugus=p.pikkus();
    if(kaugus<1)kaugus=1;
    return (int)(200*(1-(1.0/kaugus)));
  }

  public void run(){
    veelliigutada=true;
    RPunkt vanapunkt=equation.getRPunkt();
    RPunkt uuspunkt;
    int vx, vy, sx, sy;
    int vanax, vanay, uusx, uusy;
    int varu=10, kord=0;
    while(veelliigutada){
     try{
      equation.increment();
      uuspunkt=equation.getRPunkt();
      vanax=ekraanix(vanapunkt, vp, vs);
      vanay=ekraaniy(vanapunkt, vp, vs);
      uusx=ekraanix(uuspunkt, vp, vs);
      uusy=ekraaniy(uuspunkt, vp, vs);
      if(uusx>vanax){
        vx=vanax-varu; sx=uusx+varu;
      } else{
        vx=uusx-varu; sx=vanax+varu;
      }
      if(uusy>vanay){
        vy=vanay-varu; sy=uusy+varu;
      } else{
        vy=uusy-varu; sy=vanay+varu;
      }
      synchronized(pilt){ 
         joon(vanapunkt, uuspunkt, vp, vs, sahverg);

         vanapunkt=uuspunkt;
//       System.out.println("uuspunkt = "+ uuspunkt);
//       piltg.clipRect(200, 200, 400, 400);
       piltg.drawImage(sahver, 0, 0, this);
        piltg.setColor(Color.red);
        piltg.fillOval(ekraanix(uuspunkt, vp, vs)-5,
                       ekraaniy(uuspunkt, vp, vs)-5, 10, 10);
       Graphics g=getGraphics();
       g.clipRect((int)vx, (int)vy, (int)sx, (int)sy);
//       System.out.println(vx+" "+vy+" "+sx+" "+sy);
    //     System.out.println(hasFocus());
       g.drawImage(pilt, 0, 0, this);
       if(kord++%10==0)repaint();
      }
        } catch(Exception e){}
       finally{piltg.setColor(joonevarv);}

//      repaint();
      try{Thread.sleep(ooteaeg);} catch(Exception e){}
    }
  }


  private int ekraanix(RPunkt p){
  return ekeskx+(int)(grtegur*(p.x)/(p.z));  
  }


  private int ekraaniy(RPunkt p) throws Exception{
   if(p.z>0) return ekesky-(int)(grtegur*(p.y)/(p.z));
   else{//System.out.println("alla nulli"+p);
    throw(new Exception("z alla nulli"));
   }
  }

/*  private int ekraanix(RPunkt p, RPunkt vp, RPunkt vs){
    ekraanix(p.lahuta(vp).keera(-vs.x, -vs.y, -vs.z));
  }

  private int ekraaniy(RPunkt p, RPunkt vp, RPunkt vs){
    ekraaniy(p.lahuta(vp).keera(-vs.x, -vs.y, -vs.z));
  } */

  private int ekraanix(RPunkt p, RPunkt vp, RPunkt vs){
   return ekraanix(p.lahuta(vp).keera(-vs.x, -vs.y, -vs.z));    
  }

  private int ekraaniy(RPunkt p, RPunkt vp, RPunkt vs) throws Exception{
   return ekraaniy(p.lahuta(vp).keera(-vs.x, -vs.y, -vs.z));    
  }



}