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

class Splice{
  int pix[][];
  double x;
  double y;
  double m;
  int w;
  int h;
  //velocity
  double v[];
  public Splice(int x, int y, int w, int h, double vx, double vy){
    this.x = x;
    this.y = y;
    this.w = w;
    this.h = h;
    this.w = w;
    this.h = h;
    v = new double[] {vx ,vy};
    m = w*h;
  }

}

public class HW07a extends MISApplet{
  //variables for mouse
  int  mx = 0,  my = 0,mdx = 0, mdy = 0;
  boolean isMouseDown = false;
  
  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;

  LinkedList<Splice> splices = new LinkedList<Splice>();

  int[] back;
  int[] hidden;

  //tool variables
  int invertW = 60;
  int invertH = 40;
  boolean isSplicing = false;
  int initial_x = 0;
  int initial_y = 0;
  
  Tool currentTool = Tool.SPLICER;
  Tool oldTool     = Tool.SPLICER;
  public enum Tool{INVERTER, SPLICER}
  public enum Backdrop{ORIGINAL, PLAID1, PLAID2, STRIPES, VERONICA}
  Backdrop currentBackdrop = Backdrop.PLAID2;   

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

    splices = new LinkedList<Splice>(); 

    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)); 
          }
        hidden = back;
        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; 
          }
        hidden = back;
        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; 
          }
        hidden = back;
        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; 
          }
        hidden = back;
        break;
      case VERONICA:
        backdropFromFile("Veronica01.jpg", "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
    updateSplices(cur_step);
    for(Splice s: splices)
      writeSplice(s);

    
    switch(currentTool){
      case INVERTER:
        invert(time);
        break;
      case SPLICER:
        splice(time);
        break;
      default:
        break;
    }
  }
  
  /** write a splice to the pix[] */
  private void writeSplice(Splice s){
    //get upper left hand corner coords
    int ul_x = (int)s.x - s.w/2;
    int ul_y = (int)s.y - s.h/2;
    for(int x = 0; x<s.w;x++)
      for(int y =0; y<s.h;y++){
        //index in pix[]
        int i = xy2i((x+ul_x+W)%W,(y+ul_y+H)%H);
        int temp = s.pix[x][y];
        pix[i] = temp;
      }
  }

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

  }

  
  /** update physics of splices */
  private void updateSplices(double t){
    //update velocities
   for(Splice s: splices){
     s.x = (s.x+t*s.v[0]); 
     s.y = (s.y+t*s.v[1]); 
   }
    
    //update velocities base on collisions
    for(Splice s1: splices)
      for(Splice s2: splices){
        if(s1!=s2){
          collision(s1.m,s1.w,s1.h, s1.x, s1.y, s1.v,s2.m,s2.w,s2.h, s2.x, s2.y, s2.v); 
        }
      }
    
    //update velocities
   for(Splice s: splices){
     if(s.x<s.w/2){
       s.x = s.w/2;
       s.v[0] = -s.v[0];
     }
     if(s.x>W-s.w/2){
       s.x = W-s.w/2;
       s.v[0] = -s.v[0];
     }
     if(s.y<s.h/2){
       s.y = s.h/2;
       s.v[1] = -s.v[1];
     }
     if(s.y>H-s.h/2){
       s.y = H-s.h/2;
       s.v[1] = -s.v[1];
     }
   }
    
  }
  
  final int DASH_WIDTH = 4;
  final int DASH_LEN = 20;
  final int HALF_DASH_LEN = DASH_LEN/2;
  /** (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 splice(double time){

    int dashOffset = ((int) ((time%1)*DASH_LEN) );
    
    //clip the mouse
    int mx = Math.max(Math.min(this.mx,W-DASH_WIDTH),0);
    int my = Math.max(Math.min(this.my,H-DASH_WIDTH),0);
    
    //start new splice?
    if(!isSplicing && isMouseDown){
      isSplicing = true;
      initial_x = mx;
      initial_y = my;
    }

    if(isSplicing && isMouseDown){
      //draw little box based on time
      int top  = initial_y<my ? initial_y : my;
      int bottom= initial_y>my ? initial_y : my;
      int left = initial_x<mx ? initial_x : mx;
      int right = initial_x>mx ? initial_x : mx;
      for(int j = 0; j< DASH_WIDTH; j++){
        int i;
        for(int x = left; x < right; x++){
          i = xy2i(x,top+j);
          pix[i] = (x-dashOffset) %DASH_LEN>HALF_DASH_LEN ? WHITE : BLACK; 
          i = xy2i(x,bottom+j);
          pix[i] = (x-dashOffset) %DASH_LEN>HALF_DASH_LEN ? BLACK : WHITE; 
        }
        for(int y = top; y < bottom; y++){
          i = xy2i(left+j,y);
          pix[i] = ((y-dashOffset) % DASH_LEN)>HALF_DASH_LEN ? WHITE : BLACK; 
          i = xy2i(right+j,y);
          pix[i] = ((y-dashOffset) %DASH_LEN)>HALF_DASH_LEN ? BLACK : WHITE; 
        }
      }
    }

    if(!isMouseDown&&isSplicing){
      isSplicing = false;
      //to avoid non-rectangles
      if(initial_x==mx) initial_x--;
      if(initial_y==my) initial_y--;
      //make a new splice and add it to the list
      int w = Math.abs(initial_x-mx);
      int h = Math.abs(initial_y-my);
      double vx = H/(initial_y-my);
      double vy = W/(initial_x-mx);
      Splice s = new Splice((mx+initial_x)/2, (my+initial_y)/2,w,h,vx,vy);
      s.pix = new int[w][h];
      //capture pixels from background
      int ul_x = Math.min(initial_x,mx);
      int ul_y = Math.min(initial_y,my);
      for(int x=0;x<w;x++)
        for(int y=0;y<h;y++){
          s.pix[x][y] = back[xy2i(ul_x+x,ul_y+y)];
        }

      splices.add(s);
    }
    
  }

  
  /** Invert the background in invertRadius dist from mouse_pos */
  private void invert(double time){
    //mouse interaction part
    
    /** AVOID ANYTHING BUT INTEGER MATH */
    for(int y = my - invertH ; y < my + invertH ; y++)
      for(int x = mx - invertW ; x < mx + invertW ; x++) {
        //get index in pix[] at (x,y)
        int i = xy2i(x, y);
        if (i >= 0 && i < pix.length) {
          /** 256 as unity lerp parameter based on distance from center */
          int c = Math.max(0, 255 * Math.max(Math.abs(x-mx),Math.abs(y-my))/Math.max(invertW,invertH)- 128);
          //get original (backdrop values)
          int r  = unpack(hidden[i],0);
          int g  = unpack(hidden[i],1);
          int b  = unpack(hidden[i],2);
          //get inverted values
          int ir  = 255-r;
          int ig  = 255-g;
          int ib  = 255-b;
          // with in radius then just write inverse
          if (c == 0) 
              pix[i] = pack(ir, ig, ib);
          //otherwise blend in (this always makes grey...
          else {
            int red = ilerp(c,ir,r); 
            int grn = ilerp(c,ig,g);
            int blu = ilerp(c,ib,b); 
            pix[i] = pack(red, grn, blu);
          }
        }
      }
    
  }
   public boolean mouseDown(Event e, int x, int y) {
      isMouseDown = true;
      return true;
   }

   public boolean mouseUp(Event e, int x, int y) {
      isMouseDown = false;
      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;
      case 'x':
      case 'X':
        currentTool = oldTool;
        oldTool = null;
        break;
      default:
        break;
    }
    return true;
  }
  
  public boolean keyDown(Event e, int key) {
    switch(key){
      case 'x':
      case 'X':
        if(null==oldTool) oldTool = currentTool;
        currentTool = Tool.INVERTER;
        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, String hidename){
    try {
      BufferedImage img = ImageIO.read(new File(backname));//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());
    }
    try {
      BufferedImage img = ImageIO.read(new File(hidename));//gets the image
      hidden  = 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
          hidden[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); }

}