import java.util.LinkedList;
import java.awt.*;
import java.io.*;
import javax.imageio.*;
import java.awt.image.*;
import java.net.URL;

class Triangle{
  //off sets from location
  double x, y;
  int v1x,  v1y,  v2x,  v2y,  v3x,  v3y;
  int h, w;
  double v[];
  public Triangle(int v1x, int v1y, int v2x, int v2y, int v3x, int v3y){
    this.v1x = v1x;
    this.v1y = v1y;
    this.v2x = v2x;
    this.v2y = v2y;
    this.v3x = v3x;
    this.v3y = v3y;
    v= new double[] {1,1};
  } 
}

public class HW07b extends MISApplet{
  //variables for mouse
  int  mx = 0,  my = 0,mdx = 0, mdy = 0;
  boolean hasClicked = false;
  boolean isMouseDown = false;
  int clickCount;  
  
  final int WHITE = pack(255,255,255);
  final int BLACK = pack(  0,  0,  0);
  final int GRAY  = pack(128,128,128);
  final int RED   = pack(255,  0,  0);
  final int BLUE   = pack(0,0,128);
  final int GREEN   = pack(0,128 ,  0);
  final int YELLOW   = pack(255,  255,  0);
  
  double cur_time = 0;

  Triangle triangle;

  int[] back;

  public enum Tool{INVERTER, SPLICER}
  public enum Backdrop{ORIGINAL, PLAID1, PLAID2, STRIPES, VERONICA}
  Backdrop currentBackdrop = Backdrop.ORIGINAL; 

  public void initialize() {
    //set mouse to middle of the applet
    mx = W/2;
    my = H/2;
    
    clickCount = 0;
    

    switch(currentBackdrop){
      case ORIGINAL:
        back = new int[W*H];
        //construct backdrop
        /** INTEGER MATH ONLY */
        for (int y = 0 ; y < H ; y++)
          for (int x = 0 ; x < W ; x++) {
            int i = xy2i(x,y); 
            back[i] = pack(ilerp(x%(W/2),0,255),ilerp(y%(H/2),0,255), ilerp((x+y)%(W/4+H/4),0,255)); 
          }
        break;
      case PLAID1:
        back = new int[W*H];
        for (int y = 0 ; y < H ; y++)
          for (int x = 0 ; x < W ; x++) {
            int i = xy2i(x,y); 
            int c = BLUE;
            if(x%128<16||(x+32)%128<16||(x+64)%128<16)
              c = avg(c,WHITE); 
            if((y)%128<16||(y+32)%128<16||(y+64)%128<16)
              c = avg(c,WHITE); 
            if((x-4)%128<8||(x+32-4)%128<8||(x+64-4)%128<8)
              c = avg(c,BLACK ); 
            if((y-4)%128<8||(y+32-4)%128<8||(y+64-4)%128<8)
              c = avg(c,BLACK ); 
            back[i] = c; 
          }
        break;
      case PLAID2:
        back = new int[W*H];
        for (int y = 0 ; y < H ; y++)
          for (int x = 0 ; x < W ; x++) {
            int i = xy2i(x,y); 
            int c = GREEN;
            final int stripe_width = 3;
            final int diagonal_width = 3;
            final int twice_diagonal_width = 6;
            final int num_stripes_per_square = 28;
            if(x%(num_stripes_per_square*diagonal_width*2)<(num_stripes_per_square*diagonal_width)&&
              y%(num_stripes_per_square*diagonal_width*2)<(num_stripes_per_square*diagonal_width))
            c = BLACK;
            if( (x%twice_diagonal_width-y%twice_diagonal_width<diagonal_width &&x%twice_diagonal_width-y%twice_diagonal_width>=0)||
              (x%twice_diagonal_width-y%twice_diagonal_width<-diagonal_width)){
              if(x%(num_stripes_per_square*diagonal_width*2)<(num_stripes_per_square*diagonal_width)||
                y%(num_stripes_per_square*diagonal_width*2)<(num_stripes_per_square*diagonal_width))
              c = BLACK;
            }
            if((x-(num_stripes_per_square*diagonal_width/2)+stripe_width/2+(num_stripes_per_square*diagonal_width*2))%(num_stripes_per_square*diagonal_width*2)<stripe_width){
              if(!(x%(num_stripes_per_square*diagonal_width*2)<(num_stripes_per_square*diagonal_width)&&
                y%(num_stripes_per_square*diagonal_width*2)<(num_stripes_per_square*diagonal_width)))
                c= YELLOW;
              else if(!((x%twice_diagonal_width-y%twice_diagonal_width<diagonal_width &&x%twice_diagonal_width-y%twice_diagonal_width>=0)||
                (x%twice_diagonal_width-y%twice_diagonal_width<-diagonal_width)))
                c=YELLOW;
            }
            if((y-(num_stripes_per_square*diagonal_width/2)+stripe_width/2+(num_stripes_per_square*diagonal_width*2))%(num_stripes_per_square*diagonal_width*2)<stripe_width){
              if(!(x%(num_stripes_per_square*diagonal_width*2)<(num_stripes_per_square*diagonal_width)&&
                y%(num_stripes_per_square*diagonal_width*2)<(num_stripes_per_square*diagonal_width)))
                c= YELLOW;
              else if(!((x%twice_diagonal_width-y%twice_diagonal_width<diagonal_width &&x%twice_diagonal_width-y%twice_diagonal_width>=0)||
                (x%twice_diagonal_width-y%twice_diagonal_width<-diagonal_width)))
                c=YELLOW;
            }
            if((x+(num_stripes_per_square*diagonal_width/2)+stripe_width/2+(num_stripes_per_square*diagonal_width*2))%(num_stripes_per_square*diagonal_width*2)<stripe_width){
              if((x%(num_stripes_per_square*diagonal_width*2)<(num_stripes_per_square*diagonal_width)||
                y%(num_stripes_per_square*diagonal_width*2)<(num_stripes_per_square*diagonal_width)))
                c= BLACK; 
              else if(((x%twice_diagonal_width-y%twice_diagonal_width<diagonal_width &&x%twice_diagonal_width-y%twice_diagonal_width>=0)||
                (x%twice_diagonal_width-y%twice_diagonal_width<-diagonal_width)))
                c=BLACK; 
            }
            if((y+(num_stripes_per_square*diagonal_width/2)+stripe_width/2+(num_stripes_per_square*diagonal_width*2))%(num_stripes_per_square*diagonal_width*2)<stripe_width){
              if((x%(num_stripes_per_square*diagonal_width*2)<(num_stripes_per_square*diagonal_width)||
                y%(num_stripes_per_square*diagonal_width*2)<(num_stripes_per_square*diagonal_width)))
                c= BLACK ;
              else if(((x%twice_diagonal_width-y%twice_diagonal_width<diagonal_width &&x%twice_diagonal_width-y%twice_diagonal_width>=0)||
                (x%twice_diagonal_width-y%twice_diagonal_width<-diagonal_width)))
                c=BLACK ;
            }
            back[i] = c; 
          }
        break;
      case STRIPES:
        back = new int[W*H];
        for (int y = 0 ; y < H ; y++)
          for (int x = 0 ; x < W ; x++) {
            int i = xy2i(x,y); 
            int c = RED;
            final int diagonal_width = 8;
            final int twice_diagonal_width = 16;
            if( (x%twice_diagonal_width-y%twice_diagonal_width<diagonal_width &&x%twice_diagonal_width-y%twice_diagonal_width>=0)||
              (x%twice_diagonal_width-y%twice_diagonal_width<-diagonal_width))
              c = BLACK;
            back[i] = c; 
          }
        break;
      case VERONICA:
        backdropFromFile("Veronica02.jpg" );
        break;
      default:
        break;
    }
  
  }

  /** Overriden method that must define frame in doube pix[] array */
  public void computeImage(double time) {
    //paint the backdrop
    for(int i=0;i<back.length;i++) pix[i] = back[i];

    double past_time = cur_time;
    cur_time = time; 
    double cur_step = Math.min(1,cur_time - past_time);
    
    //paint the splices
    //update physics
    if(null!=triangle)
      writeTriangle(triangle);

    constructTriangle(time);
    
  }
  
  /** write a triangle to the pix[] */
  private void writeTriangle(Triangle t){
    //split into two trapezoids
    int topX, topY, midX, midY, botX, botY;
    if(t.v1y>=t.v2y && t.v1y>=t.v3y){
      topX = t.v1x;
      topY = t.v1y;
      if(t.v2y>=t.v3y){
        midX = t.v2x;
        midY = t.v2y;
        botX = t.v3x;
        botY = t.v3y;
      }else{
        midX = t.v3x;
        midY = t.v3y;
        botX = t.v2x;
        botY = t.v2y;
      }
    }else if(t.v2y>=t.v1y && t.v2y>=t.v3y){
      topX = t.v2x;
      topY = t.v2y;
      if(t.v1y>=t.v3y){
        midX = t.v1x;
        midY = t.v1y;
        botX = t.v3x;
        botY = t.v3y;
      }else{
        midX = t.v3x;                                                                                                                                                     
        midY = t.v3y;                                                                                                                                                               
        botX = t.v1x;                                                                                                                                                               
        botY = t.v1y;                                                                                                                                                               
      }                                                                                                                                                                             
    }else{
      topX = t.v3x;
      topY = t.v3y;
      if(t.v2y>=t.v1y){
        midX = t.v2x;
        midY = t.v2y;
        botX = t.v1x;
        botY = t.v1y;
      }else{
        midX = t.v1x;                                                                                                                                                     
        midY = t.v1y;                                                                                                                                                               
        botX = t.v2x;                                                                                                                                                               
        botY = t.v2y;                                                                                                                                                               
      }                                                                                                                                                                             
    }
    double f  = (midY - topY);
    f= f/ (botY - topY);
    int projX = (int)lerp(f,topX,botX);
    int midL = Math.min(projX, midX);
    int midR = Math.max(projX, midX);
    writeTrapezoid(botX,botY,botX,botY,midL,midY,  midR,midY);
    writeTrapezoid(midL,midY, midR ,midY, topX, topY,topX,topY);
  }

  private void writeTrapezoid(int tlX, int tlY, int trX, int trY, int blX, int blY, int brX, int brY){
     //System.out.println(" "+ tlX+", "+ tlY+", "+ trX+", "+ trY+", "+ blX+", "+ blY+", "+ brX+", "+ brY); 
    for (int j = tlY ; j < blY ; j++) {   // LOOP THRU SCAN LINES
      //System.out.println("J="+j);
      double t = (j - tlY);
      //System.out.println("t: "+t);
      t = t/ (blY - tlY);       // COMPUTE FRACTION t
      //System.out.println("t: "+t);
      int Li = (int) lerp(t, tlX, blX);            // COMPUTE LEFT EDGE FOR SCAN LINE
      int Ri = (int) lerp(t, trX, brX);            // COMPUTE RIGHT EDGE FOR SCAN LINE
      //System.out.print("I from "+Li+" to " +Ri);
      for (int i = Li ; i < Ri ; i++){    // FILL PIXELS IN SCAN LINE
        int z = xy2i(i,j);
        //System.out.print(i+", ");
        pix[z] = pack(255-unpack(pix[z],0), 255-unpack(pix[z],1),  255-unpack(pix[z],2)); 
      }
      //System.out.println();
    }
  }
  
  public static double lerp(double f , double y0, double y1){
    return y0 + (y1-y0)*f;
  }

  private int avg(int c1, int c2){
    return pack(
      (unpack(c1,0)+unpack(c2,0))/2,
      (unpack(c1,1)+unpack(c2,1))/2,
      (unpack(c1,2)+unpack(c2,2))/2);  

  }

  
  
  final int DOT_WIDTH = 8;
  int x1,y1,x2,y2,x3,y3; 
  /** (1) if mouse down for first time start new splice
      (2) if mouse still down continue to define splice
      (3) if mouse up for first time after mouse has been down let splice go
  */
  private void constructTriangle(double time){
    if(hasClicked){
      
      //clip the mouse
      int mx = Math.max(Math.min(this.mx,W-DOT_WIDTH),0);
      int my = Math.max(Math.min(this.my,H-DOT_WIDTH),0);

      switch(clickCount){
        case 1: 
          x1 = mx;
          y1 = my;
         break;
        case 2:
          x2 = mx;
          y2 = my;
          break;
        case 3:
          x3 = mx;
          y3 = my;
          //make a new triangle and addi t to list of triangles
          triangle = new Triangle(x1,y1,x2,y2,x3,y3);
          //reset click counter
          clickCount = 0;
          break;
        default:
      }
      
      hasClicked = false;
    }
    int i;
    for(int x=0-DOT_WIDTH/2; x<DOT_WIDTH/2; x++)
      for(int y=0-DOT_WIDTH/2; y<DOT_WIDTH/2; y++){
        switch(clickCount){
          case 3:
              i = xy2i((x3+x+W)%W,(y3+y+H)%H);
              pix[i] = pack(255-unpack(pix[i],0), 255-unpack(pix[i],0),  255-unpack(pix[i],0)); 
          case 2:
              i = xy2i((x2+x+W)%W,(y2+y+H)%H);
              pix[i] = pack(255-unpack(pix[i],0), 255-unpack(pix[i],0),  255-unpack(pix[i],0)); 
          case 1:
              i = xy2i((x1+x+W)%W,(y1+y+H)%H);
              pix[i] = pack(255-unpack(pix[i],0), 255-unpack(pix[i],0),  255-unpack(pix[i],0)); 
          default:
        }
    }
  }

  
   public boolean mouseDown(Event e, int x, int y) {
      return true;
   }

   public boolean mouseUp(Event e, int x, int y) {
      hasClicked = true;
      clickCount++;
      return true;
   }

   public boolean mouseMove(Event e, int x, int y) {
      mx = x;
      my = y;
      return true;
   }
   
   public boolean mouseDrag(Event e, int x, int y) {
      mx = x;
      my = y;
      mdx = x;
      mdy = y;
      return true;
   }

  public boolean keyUp(Event e, int key) {
    switch(key){
      case '1':
        currentBackdrop = Backdrop.ORIGINAL;
        initialize();
        break;
      case '2':
        currentBackdrop = Backdrop.STRIPES;
        initialize();
        break;
      case '3':
        currentBackdrop = Backdrop.PLAID1; 
        initialize();
        break;
      case '4':
        currentBackdrop = Backdrop.PLAID2;  
        initialize();
        break;
      case '0':
        currentBackdrop = Backdrop.VERONICA;
        initialize();
        break;
      case 'R':
      case 'r':
        initialize();
        break;
      default:
        break;
    }
    return true;
  }
  

/** Collision for 2d, code in this method is modified from:
  * http://www.plasmaphysics.org.uk/programs/coll2d_cpp.htm
  *
  * modifies velocities
  */
  private void collision(
    double m1, double w1, double h1, double x1, double y1, double v1[],
    double m2, double w2, double h2, double x2, double y2 ,double v2[]){

    double m21=m2/m1;
    double x21=x2-x1;
    double y21=y2-y1;
    double vx21= v2[0]-v1[0];
    double vy21= v2[1]-v1[1];


    //are balls travelling at eachother? and touching eachother?
    if( (vx21*x21 + vy21*y21) < 0 && (Math.abs(x21)<w1/2+w2/2) && (Math.abs(y21)<h1/2+h2/2) ){
          
          //to prevent zero division  
          double sign = 1;
          double fy21=1.0E-12*Math.abs(y21);                            
          if ( Math.abs(x21)<fy21 ) {  
            if (x21<0) { sign=-1; } else { sign=1;}  
            x21=fy21*sign; 
          } 
    
          double a=y21/x21;
          double dvx2= -2*(vx21 +a*vy21)/((1+a*a)*(1+m21)) ;
          v2[0]=v2[0]+dvx2;
          v2[1]=v2[1]+a*dvx2;
          v1[0]=v1[0]-m21*dvx2;
          v1[1]=v1[1]-a*m21*dvx2;
    }
  }
  
  private void backdropFromFile(String backname){
    try {
      URL textURL = new URL( getCodeBase() , backname ); 
      BufferedImage img = ImageIO.read(textURL);//gets the image
      back  = new int[W*H]; 
      Raster rasterData = img.getData();//gets the information from the image file
      int w = rasterData.getWidth();
      int h = rasterData.getHeight();
      for(int y = 0; y < Math.max(H,h); y++ )
        for(int x = 0; x < Math.max(W,w); x++){   
          int i = xy2i(x,y);
          //grab this pixel  
          int[] data = rasterData.getPixel(x,y,new int[4]);
          //store copy of this pixel in temp
          back[i] = pack(data[0], data[1], data[2]);
      }
    } catch (IOException e) {
      System.out.println(e.getMessage());
    }
  }



   // FIXED POINT VERSION OF LINEAR INTERPOLATION, WITH 256 AS UNITY

   int ilerp(int t, int a, int b) { return a + (t * (b - a) >> 8); }

}