// Stavros Messinis, Jimmy Messinis //<>// //<>//
// The Cube Athens



import org.openkinect.freenect.*;
import org.openkinect.processing.*;

import java.util.Timer;

import java.util.TimerTask;

import processing.video.*;
Movie myMovie;
//Movie myTheme;

// Kinect Library object


Kinect kinect;
// Timer class
Timer timer;
Timer timer2;


//import processing.sound.*;
//SoundFile sndTheme;
//SoundFile sndDrop;

int timeToPlay = 120000; // 2 * 60 * 1000
float running;

boolean showData =true, showKinectDetect=true;
boolean playedVid=false;
boolean instructionsPlayed=false;
boolean instructionsPlayed1=false;
boolean puzzleSelected = false;
boolean pickingUp = false;
boolean snapped = false;
boolean winner=false;
boolean playingPuzzleSelect=false;

// We'll use a lookup table so that we don't have to repeat the math over and over
float[] depthLookUp = new float[2048];
int timeBetweenScreens=2000;
public int xpos=450;
public int ypos=1000;
float newX,newY;
int x=0;
int y=0;
public String  path;
int pcsdisplayed = 0;

int sceneSelection;
int selectTime=6000,firstSelectTime;
int imgPickedUp = 0;
int c=0;
boolean introPlayed = false;
boolean introPlayed1 = false;
float timeElapsed,  timeElapsed2=0, startTime, startTime2=0;
float pixelArea, pixelAreaLast;
float lasttimecheck;
int sceneNo,sceneComplete;
int scene;
boolean chosen =false;
int[] startTimeArr;
float midX,midY;
int selectedPiece = 6;
boolean dragging = false;

PImage[] images = new PImage[6];
PImage[][] pcs = new PImage[6][6];
PImage imgScene1;
PImage imgScene2;
PImage imgScene3;
PImage imgScene4;
PImage imgScene5;
PImage imgScene6;
PImage imgLose;
PImage imgGifts;
PImage imgPlacement;
PImage imgOutro;

PImage imgBG;
PImage imgBG2;

PImage img1complete;
PImage imgIntro;
PImage imgInstructions;
PImage imgPuzzleSelect;
PImage imgWinner;

PImage img;
PImage imgOpenedHand;
PImage imgClosedHand;

int selectedPiece2;
boolean didSnap = false;
PImage[] snappedImages = new PImage[6];

int imgLength = 286;
int imgHeight = 286;
float x0 = 65, y0 = 443,
    x1 = x0 + (2*imgLength/3) + 17  , y1 = y0,
    x2 = x1 + (2*imgLength/3) , y2 = y0,
    x3 = x0 , y3 = y0 + imgHeight / 2,
    x4 = x1 , y4 = y3,
    x5 = x2 , y5 = y4;





  float firstSelectTime2=0;
boolean reading=false;
void setup() {
  fullScreen();

  loadImages();
  loadPieces();

  kinect = new Kinect(this);
  kinect.initDepth();
  kinect.enableMirror(true);

  img = createImage(kinect.width, kinect.height,RGB);


  timer = new Timer(timeToPlay);
  startTime = millis();
  timer2 = new Timer(2000);
  //sndTheme = new SoundFile(this, ".//images//Theme.mp3");
  //sndTheme.loop();
      //sndPop = new SoundFile(this, ".//images//select.wav");
  //sndDrop = new SoundFile(this, ".//images//drop.wav");


  //println(kinect.width,kinect.height);

}

void draw() {
  //println(mouseX, mouseY);
  running = millis();

  if (!introPlayed){
    playIntro();
    //image(myTheme, 0, midY, 1,1);
    //myTheme.play();

  } else if (introPlayed) {
    playInstructions();
  } else if (instructionsPlayed ){
    reading=true;
    playPuzzleSelect();
  } else if (puzzleSelected ==true && reading== true){

    //workinghere
    playPuzzle();

  }

  if (winner){


    //reading=false;
       println("Playing winners");
        handAnimate(1,newX,newY);
    image(imgWinner,0,0);
    image(myMovie, 0, midY, 768,468);
    myMovie.play();

    if (!playedVid){
          firstSelectTime=millis();
        }
        playedVid=true;


        println("timeVid");

        timeElapsed2=millis()-firstSelectTime;
        println(timeElapsed2,firstSelectTime);

        if (timeElapsed2 >12000  && winner){
        //puzzleSelected=true;
          //println("chosen ",sceneSelection);

          println("timeElapsed");
          instructionsPlayed = false;
          introPlayed = false;
          //playedVid=false;
//          introPlayed=false;
          instructionsPlayed=false;
          puzzleSelected = false;
          winner=false;
          reading=true;
          playIntro();


        }



    winner=false;

    //reading=true;


    //if (playedVid==true){
    //float timestartVid=millis();
    //println("restarting");
    //running=7990;

  //}
  }
}



void playIntro(){
  reading=false;
  if (!introPlayed1){
          firstSelectTime=millis();
        }
        introPlayed1=true;
        image(imgIntro,0,0);


         println("Intro");

        timeElapsed2=millis()-firstSelectTime;
        println(timeElapsed2,firstSelectTime);
         if (timeElapsed2 >5000){
           introPlayed=true;
         playInstructions();
         }

}

void playInstructions(){
  if (!playingPuzzleSelect){
  reading=false;
  if (!instructionsPlayed1) {
    firstSelectTime=millis();
  }
  instructionsPlayed1=true;
  image(imgInstructions,0,0);
  println("Playing Instructions");

   timeElapsed2=millis()-firstSelectTime;
        println(timeElapsed2,firstSelectTime);
         if (timeElapsed2 >5000){
           instructionsPlayed=true;
           playPuzzleSelect();
         }
   }
}





void sorryYouLost(){
  reading=false;
 image(imgLose, 0, 0);
 //delay(5000);
 introPlayed = false;

}

void playPuzzle(){
  if (!winner){

      reading=true;
      playScene(sceneSelection);
      drawSnappedImages();


      tint(255,100);
      image(img,midX,midY);
      tint(255,255);

      handAnimate(1,newX,newY);

      if (timer.isFinished()) {
        sorryYouLost();
      } else {

        timer.render();


        if (isPickingUp()) {
          //sndPop.play();
          dragging = true;
        }

        if (dragging){
          dragPiece(sceneSelection, selectedPiece);
          snap(sceneSelection,selectedPiece);
          //image(
        }

      }
    }
}

void drawSnappedImages(){


  for (int i=0;i < snappedImages.length; i++){
    float theX, theY;
    if (snappedImages[i] != null) {
      switch (i){
        case 0:
          theX = x0; theY = y0;
          //delay(1000);
          winner=true;

          introPlayed = false;
          // reading=false;

          break;
        case 1:
          theX = x1; theY = y1;
          break;
        case 2:
          theX = x2 -40; theY = y2;
          break;
        case 3:
          theX = x3; theY = y3;
          break;
        case 4:
          theX = x4; theY = y4 + 65;
          break;
        case 5:
          theX = x5 - 40; theY = y5;

          break;
       default:
         theX = 0; theY = 0;
      }

      image(snappedImages[i], theX, theY);
      //sndDrop.play();


    }

  }
}

void playScene(int num){
      if (!winner){
      reading=true;
      puzzleSelected=true;
      if (sceneComplete!=1){
        image(imgBG,0,0);

        switch(num) {
          case 1:
            tint(255, 90);
            image(imgScene1,midX,midY);
            tint(255, 255);
            for (int d=0; d < selectedPiece;d++){
              image(pcs[num-1][d],400,900);
              //println(d);
            }
            break;
          case 2:
            //println("case2");
            tint(255, 90);
            image(imgScene2,midX,midY);
            tint(255, 255);
            for (int d=0; d < selectedPiece;d++){
              image(pcs[num-1][d],400,900);

            }

          break;
          case 3:
            tint(255, 90);
            image(imgScene3,midX,midY);
            tint(255, 255);
            for (int d=0; d < selectedPiece;d++){
              image(pcs[num-1][d],400,900);
            }
            break;

          case 4:
            tint(255, 90);
            image(imgScene4,midX,midY);
            tint(255, 255);
            for (int d=0; d < selectedPiece;d++){
              image(pcs[num-1][d],400,900);
            }
            break;

          case 5:
            tint(255, 90);
            image(imgScene5,midX,midY);
            tint(255, 255);
            for (int d=0; d < selectedPiece;d++){
              image(pcs[num-1][d],400,900);
            }
            break;
          case 6:
            tint(255, 90);
            image(imgScene6,midX,midY);
            tint(255, 255);
            for (int d=0; d < selectedPiece;d++){
              image(pcs[num-1][d],400,900);
            }
            break;
        }

      }

    }
}

void handAnimate(int state, float newX, float newY){
  if (state==1){
    image(imgOpenedHand, newX,newY);
  }else{
    image(imgClosedHand,newX,newY);
  }
}




void playWinner(){
  //reading=false;
   println("Playing winner");
    image(imgWinner,0,0);
  firstSelectTime2=millis();
  println("tm:",firstSelectTime2);
         playedVid=true;
        restartApp();
        println("playing Vid");
        timeElapsed2=millis()-firstSelectTime2;
        println(timeElapsed2,firstSelectTime2);
        //stop();

}



void playPuzzleSelect(){
  playingPuzzleSelect=true;
  if (!winner && reading==true){
  image(imgPuzzleSelect,0,0);
  kinectRead();
  selectScene();
}
}


//SELECT SCENE
void selectScene(){
  if (!puzzleSelected ){
    stroke(255);
    noFill();

    if (newX>=47 && newX<=373) { // 1st puzzle
      if (newY>=400 && newY<=580){
        if (sceneSelection!=1){
          firstSelectTime=millis();
        }

        sceneSelection=1;

        //println("selecing TL");

        timeElapsed2=millis()-firstSelectTime;
        //println(timeElapsed2,firstSelectTime);

        if (timeElapsed2 >2000){
        //puzzleSelected=true;
          //println("chosen ",sceneSelection);
          fill(255,55);
          rect(40,395,340,195);
        }
      }
    }

    if (newX>=362 && newX<=719) { // 2nd puzzle
      if (newY>=400 && newY<=580){
        if (sceneSelection!=2){
          firstSelectTime=millis();
        }

        sceneSelection=2;

        //println("selecing TR");

        timeElapsed2=millis()-firstSelectTime;
        //println(timeElapsed2,firstSelectTime);

        if (timeElapsed2 >2000){
          //puzzleSelected=true;
          //println("chosen ",sceneSelection);
          fill(255,55);
          rect(385,395,340,195);
        }
      }
    }

    if (newX>=47 && newX<=373) { // 3rd puzzle
      if (newY>=600 && newY<=780){
        if (sceneSelection!=3){
          firstSelectTime=millis();
        }

        sceneSelection=3;

        //println("selecing ML");

        timeElapsed2=millis()-firstSelectTime;
        //println(timeElapsed2,firstSelectTime);

        if (timeElapsed2 >2000){
          //println("chosen ",sceneSelection);
          fill(255,55);
          rect(40,595,340,195);
        }
      }
    }

    if (newX>=362 && newX<=719) {
    if (newY>=600 && newY<=780){
    if (sceneSelection!=4){
    firstSelectTime=millis();}
    sceneSelection=4;
    //println("selecing MR");
    timeElapsed2=millis()-firstSelectTime;
    //println(timeElapsed2,firstSelectTime);
    if (timeElapsed2 >2000){
    //puzzleSelected=true;
    //println("chosen ",sceneSelection);
    fill(255,55);
    rect(385,595,340,195);
    }
    }
    }

    if (newX>=47 && newX<=373) {
    if (newY>=800 && newY<=980){
    if (sceneSelection!=5){

    firstSelectTime=millis();}
    sceneSelection=5;
    //println("selecing BL");
    timeElapsed2=millis()-firstSelectTime;
    //println(timeElapsed2,firstSelectTime);
    if (timeElapsed2 >2000){
    //puzzleSelected=true;
    //println("chosen ",sceneSelection);
    fill(255,55);
    rect(40,795,340,195);
    }
    }
    }

    if (newX>=362 && newX<=719) {
    if (newY>=800 && newY<=980){
    if (sceneSelection!=6){
    firstSelectTime=millis();}
    sceneSelection=6;
    //println("selecing BR");
    timeElapsed2=millis()-firstSelectTime;
    //println(timeElapsed2,firstSelectTime);
    if (timeElapsed2 >2000){
    //puzzleSelected=true;
    //println("chosen ",sceneSelection);
    fill(255,55);
    rect(385,795,340,195);
    }
    }
    }

    switch (sceneSelection) {
    case 1:
    rect(40,395,340,195);
    if (millis()-firstSelectTime>2000) {
    //image(
    playScene(1);
    timer.start();
    //println(millis()-firstSelectTime);
    }
    break;

    case 2:

    rect(385,395,340,195);
    if (millis()-firstSelectTime>2000) {
    playScene(2);
    timer.start();
    //println(millis()-firstSelectTime);
    }

    break;

    case 3:
    timeElapsed2=0;
    rect(40,595,340,195);
    if (millis()-firstSelectTime>2000) {
    playScene(3);
    timer.start();
    //println(millis()-firstSelectTime);
    }
    break;
    case 4:
    timeElapsed2=0;
    rect(385,595,340,195);
    if (millis()-firstSelectTime>2000) {
    playScene(4);
    timer.start();
    //println(millis()-firstSelectTime);
    }
    break;
    case 5:
    timeElapsed2=0;
    rect(40,795,340,195);
    if (millis()-firstSelectTime>2000) {
    playScene(5);
    timer.start();
    //println(millis()-firstSelectTime);
    }
    break;
    case 6:
    timeElapsed2=0;
    rect(385,795,340,195);
    if (millis()-firstSelectTime>2000) {
    playScene(6);
    timer.start();
    //println(millis()-firstSelectTime);
    }
    break;
    default:
    rect(0,0,0,0);
    firstSelectTime=0;
    sceneSelection=0;
    timeElapsed2=0;
    }


  }

}

//READ KINECT DATA
void kinectRead(){
  if (reading==true){

  //background(255);
  img.loadPixels();

  // Get the raw depth as array of integers
  int[] depth = kinect.getRawDepth();
  float sumX=0;
  float sumY=0;
  float totalPixels =0;


  float minThresh=300;
  float maxThresh=800;

  for (int x = 0; x < kinect.width; x++) {
    for (int y = 0; y < kinect.height; y++) {
      int offset = (x + y*kinect.width);
      int d=depth[offset];

      if (d >minThresh && d< maxThresh) {
        img.pixels[offset]  =color (200,0,0);
        sumX +=x;
        sumY +=y;
        totalPixels ++;
      } else {
        img.pixels[offset]=color(0);
      }
    }
  }

  img.updatePixels();

  midX = (768/2)-(kinect.width/2);
  midY = (1366/2)-(kinect.height/2);

  if (showKinectDetect==true) {
    tint(255,123);
    image(img,midX,midY);
    tint(255,255);
  }
  if(pixelAreaLast>pixelArea){
    //println("NoChange");
  } else {
    pixelAreaLast=pixelArea;
  }

  delay(10);

  pixelArea = sumX*sumY/1000000;
  float avgX = sumX / totalPixels;
  float avgY = sumY / totalPixels;
  fill(255,0,255);

  if (pixelArea > 1000000) {
    //ellipse(avgX+midX,avgY+midY,64,64);
    //map newX and newY from avgX and avgY to cover all the screen
    //newX=mouseX;
    //newY=mouseY;
    newX=map(avgX,0,kinect.width,0,width);
    newY=map(avgY,0,kinect.height,0,height);
    //newX=map(mouseX,0,kinect.width,0,width);
    //newY=map(mouseY,0,kinect.height,0,height);
    handAnimate(1,newX,newY);
  } else {
    //newX=mouseX;
    //newY=mouseY;
    //newX=map(mouseX,0,kinect.width,0,width);
    //newY=map(mouseY,0,kinect.height,0,height);
    newX=map(avgX,0,kinect.width,0,width);
    newY=map(avgY,0,kinect.height,0,height);
    handAnimate(0,newX,newY);
    //ellipse(newX,newY,64,64);
    //image(img1complete,avgX+midX,avgY+midY);
  }




  //if (avgX >470 && avgY>450){
  //  println ("in the box");
  //  imgPickedUp=c;
  //}
  //Show Data on top left of screen if showData boolean is true
  if (showData == true) {
    fill(0);
    text(pixelArea,10,10);
    //text ("x:"+avgX+"y:"+avgY,midX+10,midY+20);
    text ("x:"+newX+"y:"+newY,10,20);

    text ("Mx:"+mouseX+"My:"+mouseY,10,40);
    newX=mouseX;
    newY=mouseY;
    text ("Px%Delta:"+(pixelArea/pixelAreaLast)*100,10,50);
    //delay(1000);
    //if pixelArea
  }

}
}

void drawDebug(){
  fill(0);
  text(pixelArea,10,10);
  //text ("x:"+avgX+"y:"+avgY,midX+10,midY+20);
  text ("x:"+newX+"y:"+newY,10,20);

  text ("Mx:"+mouseX+"My:"+mouseY,10,40);
  text ("Px%Delta:"+(pixelArea/pixelAreaLast)*100,10,50);
  //delay(1000);
  //if pixelArea
}

boolean isPickingUp(){
  if (newX>=400 && newX<=680) {
    if (newY>=900 && newY<=1185){
      if (!pickingUp){
        firstSelectTime=millis();
      }
      pickingUp = true;

      timeElapsed2=millis()-firstSelectTime;
      if (timeElapsed2 >2000){
      // Got it

        return true;

      }
    }
  }
  return false;
}

void dragPiece(int puzzle, int piece){
  if (!winner){
    //println(puzzle);
    if (pcs[puzzle-1].length > 0){
            image(pcs[puzzle - 1][piece -1],newX - 140 + 77 ,newY - 140 + 56);
    }
  }
  handAnimate(0,newX,newY);
}

void snap(int puzzle, int piece){
  //println("Puzzle length:" + pcs[puzzle - 1].length);
      noFill();
      stroke(255);
      tint(255, 70);
      //rect(x0,y0, imgLength, imgHeight);
      //rect(x1,y1, imgLength, imgHeight);
      //rect(x2,y2, imgLength, imgHeight);
      //rect(x3,y3, imgLength, imgHeight);
      //rect(x4,y4, imgLength, imgHeight);
      //rect(x5,y5, imgLength, imgHeight);
      tint(255,255);



  stroke(255);
  //println(x5, imgLength * 2 + 65);

  switch (selectedPiece) {
    case 1:
      if (newX - 50>=x0 && newX -50 < x1) {
        if (newY -50 >=y0 && newY -50 < y3){
          snapHere();
        }
      }
      break;
    case 2:
      if (newX - 50>=x1 && newX -50 < x2) {
        if (newY -50 >=y0 && newY -50 < y3){
          snapHere();
        }
      }
      break;
    case 3:
      if (newX - 50>=x2 && newX -50 < 715) {
        if (newY -50 >=y2 && newY -50 < y3){
          snapHere();
        }
      }
      break;
    case 4:
      if (newX - 50>=x3 && newX -50 < x4) {
        if (newY -50 >=y3 && newY -50 < 875){
          snapHere();
        }
      }
      break;
    case 5:
      if (newX>=255 && newX< 515) {
        if (newY>=586 && newY< 875){
          snapHere();
        }
      }
      break;
    case 6:
      if (newX>=x5 && newX < 715) {
        if (newY >=600 && newY < 700){
          snapHere();
        }
      }
      break;

  }


    if (didSnap){
    if (pcs[puzzle-1].length > 0){
      snappedImages[selectedPiece -1] = pcs[puzzle - 1][selectedPiece -1];
      pcs[puzzle - 1] = (PImage[]) shorten(pcs[puzzle - 1]);
    } else {
      println("zonk");
    }
    didSnap = false;
    println("Puzzle length after shorten:" + pcs[puzzle - 1].length);
    selectedPiece --;

  }

}

void snapHere(){
  if (!snapped){
    firstSelectTime=millis();
  }

  snapped = true;
  timeElapsed2=millis()-firstSelectTime;

  if (timeElapsed2 > 1000){

    println("Snapped");
    didSnap = true;
  }
  //pickingUp = true;


  handAnimate(1,newX,newY);
  dragging = false;
}

void loadPieces(){
  for (int puzzle = 0; puzzle < 6; puzzle ++) {
    for (int piece = 0; piece < 6; piece ++) {
      pcs[puzzle][piece] = loadImage(".//images//ep" + puzzle + "-" + piece + ".png");
      //println("//images//ep" + puzzle + "-" + piece + ".png");
    }
  }
}


void movieEvent(Movie m) {
  m.read();
}


void loadImages(){
  String path=".//images//";

  myMovie = new Movie(this, path + "vid.mp4");
  //myTheme = new Movie(this, path + "theme.mp4");

  imgLose  =  loadImage(path + "lose.png");
  imgGifts  = loadImage(path + "gifts.png");
  imgPlacement=loadImage(path + "placement.png");
  imgOutro  = loadImage(path + "outro.png");
  imgScene1 = loadImage(path + "series_1.png");
  imgScene2 = loadImage(path + "series_2.png");
  imgScene3 = loadImage(path + "series_3.png");
  imgScene4 = loadImage(path + "series_4.png");
  imgScene5 = loadImage(path + "series_5.png");
  imgScene6 = loadImage(path + "series_6.png");


  imgOpenedHand = loadImage(path + "openhandlight.png");  // Load the image into the program
  imgClosedHand = loadImage(path + "closedhand.png");
  imgWinner = loadImage(path +"winner.png");
  imgIntro = loadImage(path + "001.png");
  imgInstructions=loadImage(path + "002.png");
  imgPuzzleSelect=loadImage(path + "003.png");

  imgBG=loadImage(path + "puzzlebackground.png");
  img1complete=loadImage(path+"1complete"+".png");
}

void restartApp(){


}