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

import java.awt.*;

public class LorenzCanvas extends Canvas {
  //===================================================================
  // Variables
  //
  //===================================================================
  private 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);
  //===================================================================
  // Methods
  //
  //===================================================================

  //===================================================================
  // Constructor
  //
  // Construct a lorenz canvas with all values set to zero.
  //===================================================================
  public LorenzCanvas() {
    super();
    resize(400,300);
    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);
  }

  //===================================================================
  // 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();
  }


  //===================================================================
  //  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) {
      pilt = createImage(size().width, size().height);
      ekeskx=size().width/2;
      ekesky=size().height/2;
      piltg = pilt.getGraphics();
      piltg.setColor(getBackground());
      piltg.fill3DRect(0, 0, size().width, size().height, 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){
 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));
 }*/




  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){
   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));    
  }



}