import ddf.minim.*;


import arb.soundcipher.*;
import arb.soundcipher.constants.*;

import hypermedia.net.*;
import fisica.*;
import fullscreen.*; 

int PORT_RX=12345;
String HOST_IP = "127.0.0.1";//IP Address of the PC in which this App is running
UDP udp;//Create UDP object for recieving
int bucketHeight = 200;

int timer = 60;    // limit time in sec;
int startTime = 0;

Minim minim = new Minim(this);
AudioSample small, middle, big;

FullScreen fs; 
FWorld world;
SoundCipher sc = new SoundCipher(this);

// Buffer for each points
int[] px = new int[5];    // 1000 ~ 5900
int[] py = new int[5];    // 4500 ~ 1100
int[] pz = new int[5];
int[] pF = new int[5];    // 0 ~ 1000

FBox craneMount;
FBox crane;
FPoly leftClaw, rightClaw;
FRevoluteJoint leftClawJoint, rightClawJoint;
int clawPower = 1000;
int clawReleasePower = 60;

ForcePoint clawForce, leftForce, rightForce;

Inertia craneX;
Inertia craneY;

FBlob[] balls = new FBlob[20];
int[] sizes = new int[20];

boolean left=false;
boolean right = false;
boolean claw = false;


void setup() {
  size(640, 480);
  smooth();
//  fs = new FullScreen(this);
//  fs.enter();


  // small: http://www.freesound.org/people/fins/sounds/146723/
  // 
  small = minim.loadSample("middle.wav");
  middle = small;
  big = minim.loadSample("big.wav");

  clawForce = new ForcePoint(100, 500);
  leftForce = new ForcePoint(10, 50);
  rightForce = new ForcePoint(10, 50);

  Fisica.init(this);

  world = new FWorld();
  world.setGravity(0, 500);


  FPoly bucket = new FPoly();
  bucket.vertex(0, height);
  bucket.vertex(0, 0);
  bucket.vertex(20, 0);
  bucket.vertex(20, height-20);
  bucket.vertex(width/3-50, height-20);
  bucket.vertex(width/3, height-bucketHeight+50);
  bucket.vertex(width/3+20, height-bucketHeight+50);
  bucket.vertex(width/3+20, height-20);
  bucket.vertex(width-20, height-20);
  bucket.vertex(width-20, height-bucketHeight);
  bucket.vertex(width, height-bucketHeight);
  bucket.vertex(width, height);
  bucket.setStatic(true);
  bucket.setFill(127);
  bucket.setFriction(10);
  world.add(bucket);

  craneX = new Inertia(width/3/2, 0.2, 10); 
  craneY = new Inertia(160, 0.2, 10);

  craneMount = new FBox(50, 20);
  craneMount.setPosition(craneX.getValue(), craneY.getValue());
  craneMount.setStatic(true);
  craneMount.setFill(255);
  craneMount.setBullet(true);
  world.add(craneMount);

  crane = new FBox(150, 25);
  crane.setPosition(craneMount.getX(), craneMount.getY()+25);
  crane.setStatic(false);
  crane.setFill(255);
  crane.setBullet(true);
  world.add(crane);

  FDistanceJoint craneConnecter = new FDistanceJoint(craneMount, crane);
  craneConnecter.setDrawable(true);
  craneConnecter.setStroke(255);
  craneConnecter.setStrokeWeight(3);
  world.add(craneConnecter); 

  int clawLength = 60;
  leftClaw = new FPoly();
  leftClaw.vertex(crane.getX()-15, crane.getY()+15);
  leftClaw.vertex(crane.getX()-15-clawLength, crane.getY()+15);
  leftClaw.vertex(crane.getX()-15-clawLength, crane.getY()+15+30);
  leftClaw.vertex(crane.getX()-15-clawLength+5, crane.getY()+15+30);
  leftClaw.vertex(crane.getX()-15-clawLength+10, crane.getY()+15+10);
  leftClaw.vertex(crane.getX()-15, crane.getY()+15+10);
  leftClaw.setBullet(true);
  world.add(leftClaw);
  leftClawJoint = new FRevoluteJoint(leftClaw, crane, crane.getX()-20, crane.getY()+20);
  leftClawJoint.setStrokeWeight(0);

  leftClawJoint.setEnableLimit(true);
  leftClawJoint.setUpperAngle(1.57);
  leftClawJoint.setLowerAngle(0);
  leftClawJoint.setEnableMotor(true); 
  leftClawJoint.setMotorSpeed(-2);
  leftClawJoint.setMaxMotorTorque(clawReleasePower); 
  world.add(leftClawJoint);

  rightClaw = new FPoly();
  rightClaw.vertex(crane.getX()+15, crane.getY()+15);
  rightClaw.vertex(crane.getX()+15+clawLength, crane.getY()+15);
  rightClaw.vertex(crane.getX()+15+clawLength, crane.getY()+15+30);
  rightClaw.vertex(crane.getX()+15+clawLength-5, crane.getY()+15+30);
  rightClaw.vertex(crane.getX()+15+clawLength-10, crane.getY()+15+10);
  rightClaw.vertex(crane.getX()+15, crane.getY()+15+10);
  rightClaw.setBullet(true);
  world.add(rightClaw);
  rightClawJoint = new FRevoluteJoint(rightClaw, crane, crane.getX()+20, crane.getY()+20);
  rightClawJoint.setStrokeWeight(0);
  rightClawJoint.setEnableLimit(true);
  rightClawJoint.setUpperAngle(0);
  rightClawJoint.setLowerAngle(-1.57);
  rightClawJoint.setEnableMotor(true); 
  rightClawJoint.setMotorSpeed(2);
  rightClawJoint.setMaxMotorTorque(clawReleasePower);
  world.add(rightClawJoint);

  for (int i=0;i<20;i++)
    sizes[i] = 1;
  for (int i=10;i<20;i++)
    sizes[i] = 2;
  for (int i=16;i<20;i++)
    sizes[i] = 3;  

  shuffle(sizes);

  for (int i=0;i<10;i++) {
    balls[i] = dropBubbles(260+i*36, height-100, sizes[i]);
  }
  for (int i=10;i<20;i++) {
    balls[i] = dropBubbles(260+(i-10)*36, height-200, sizes[i]);
  }


  udp= new UDP(this, PORT_RX, HOST_IP);
  //udp.log(true);
  udp.listen(true);

  frameRate(60);
}

int leftSpeed = 0;
int rightSpeed = 0;


int prevScore = 0;
void step() {
  craneX.step();
  craneY.step();

  if (craneX.getValue() >= 290 && craneX.getValue() <= 560) {
    craneMount.setFill(0, 255, 0);
  }
  else {
    craneMount.setFill(255);
  }

  craneY.setValue(constrain(craneY.getValue(), 160, 350));
  if (craneY.getValue() > 220) {
    craneX.setValue(constrain(craneX.getValue(), 320, 530));
  }
  else {
    craneX.setValue(constrain(craneX.getValue(), 100, 540));
  }

  craneMount.adjustPosition(craneX.getValue()-craneMount.getX(), craneY.getValue()-craneMount.getY());

  world.step();
}

void draw() {
  background(0);

  int remainTime;

  if (startTime != 0) {
    remainTime = constrain(timer*1000 - (millis()-startTime), 0, timer*1000);
  }
  else {
    remainTime = timer*1000;
  }
  step();
  world.draw();

  if (remainTime == 0) {
    craneX.setForce(0);
    craneY.setForce(-0.5);
    leftClawJoint.setEnableMotor(true); 
    leftClawJoint.setMotorSpeed(-2);
    leftClawJoint.setMaxMotorTorque(clawReleasePower); 
    rightClawJoint.setEnableMotor(true); 
    rightClawJoint.setMotorSpeed(2);
    rightClawJoint.setMaxMotorTorque(clawReleasePower);
    textAlign(CENTER);
    textSize(50);
    fill(0, 255, 0);
    text("STOP!", width/2, 150);
  }


  int newScore = calculateScore(0, height-bucketHeight+30, width/3, bucketHeight);
  if (newScore != prevScore) {
    if (newScore-prevScore < 3)
      small.trigger();  
    else if (newScore-prevScore < 5)
      middle.trigger();
    else {
      middle.trigger();
      big.trigger();
    }

    prevScore = newScore;
  }
  fill(255);
  textAlign(LEFT);
  textSize(20);
  text("Score: "+calculateScore(0, height-bucketHeight, width/3, bucketHeight), 30, 30);
  text("Time: "+(float)(remainTime/10)/100, 30, 60);

  if (clawForce.isOn() || leftForce.isOn() || rightForce.isOn())
    if (startTime == 0)
      startTime = millis();

  if (remainTime == 0) {
    return;
  }

  if (clawForce.isOn()) {
    float power = constrain(clawForce.getValue()*2, 1500, 2000);
    //power = 2000;

    leftClawJoint.setEnableMotor(true); 
    leftClawJoint.setMotorSpeed(3);
    leftClawJoint.setMaxMotorTorque(power); 
    rightClawJoint.setEnableMotor(true); 
    rightClawJoint.setMotorSpeed(-3);
    rightClawJoint.setMaxMotorTorque(power);
  }
  else {
    leftClawJoint.setEnableMotor(true); 
    leftClawJoint.setMotorSpeed(-2);
    leftClawJoint.setMaxMotorTorque(clawReleasePower); 
    rightClawJoint.setEnableMotor(true); 
    rightClawJoint.setMotorSpeed(2);
    rightClawJoint.setMaxMotorTorque(clawReleasePower);
  }

  if (leftForce.isOn() && rightForce.isOn()) {
    if (craneX.getValue() >= 290 && craneX.getValue() <= 560) {
      craneY.setForce(0.5);
    }
    craneX.setForce(0);
  }
  else if (leftForce.isOn() && craneY.getValue() < 170) {
    craneY.setForce(-0.5);
    craneX.setForce(-1*constrain(leftForce.getValue(), 0, 150)/100);
  }
  else if (rightForce.isOn() && craneY.getValue() < 170) {
    craneY.setForce(-0.5);
    craneX.setForce(constrain(rightForce.getValue(), 0, 150)/100);
  }
  else {
    craneY.setForce(-0.5);
    craneX.setForce(0);
  }
  
  if(left)
    leftForce.feed(100);
  else
    leftForce.feed(0);

  if(right)
    rightForce.feed(100);
  else
    rightForce.feed(0);
    
  if(claw)  
    clawForce.feed(5000);
  else
    clawForce.feed(0);
}

void keyPressed() {
  if (startTime == 0)
    startTime = millis();

  int remainTime = constrain(timer*1000 - (millis()-startTime), 0, timer*1000);

  if (keyCode == 'R') {
    startTime = 0;
    udp.close();
    small.close();
    middle.close();
    big.close();
    minim.stop();
    setup();
  }

  if (remainTime==0) {
    return;
  }
  if (keyCode == LEFT) {
    left = true;
  }
  else if (keyCode == RIGHT) {
    right = true;
  }
  else if (keyCode == DOWN) {
    left = true;
    right = true;
  }
  else if (keyCode == ' ') {
    claw = true;
  }
}

void keyReleased() {
  if (keyCode == LEFT) {
    left = false;
  }
  if(keyCode == RIGHT) {
    right = false;
  }
  else if (keyCode == DOWN) {
    left = false;
    right = false;
  }

  else if (keyCode == ' ') {
    claw = false;
  }
}

int calculateScore(int px, int py, int pw, int ph) {
  int score = 0;
  for (int i=0;i<20;i++) {
    FBody b = (FBody)balls[i].getVertexBodies().get(0);
    if (b.getX() >= px && b.getX() <= px+pw && b.getY() >= py && b.getY() <= py+ph) {
      if (sizes[i] == 1)
        score += 1;
      else if (sizes[i] == 2)
        score += 3;
      else if (sizes[i] == 3)
        score += 5;
    }
  }

  return score;
}

FBlob dropBubbles(int xPos, int yPos, int bSize) {
  FBlob b = new FBlob();

  //  int bSize = 1;
  //  if (random(1)<0.2) {
  //    bSize = 2;
  //    if (random(1)<0.5)
  //      bSize = 3;
  //  }
  int nVertices = 15;
  if (bSize==2)
    nVertices = 20;
  if (bSize==3)
    nVertices = 30;


  b.setAsCircle(xPos, yPos+random(-10, 10), bSize*10+8, nVertices);
  b.setStroke(255);
  b.setStrokeWeight(2);
  b.setDamping(0.5);
  b.setRestitution(0.8);
  b.setFriction(0.5);
  b.setBullet(true);
  switch(bSize)
  {
  case 1:
    b.setFill(0, 0, 255);
    break;
  case 2:
    b.setFill(0, 255, 0);
    break;
  case 3:
    b.setFill(255, 0, 0);
    break;
  }
  world.add(b);
  return b;
}

byte[] receiveBuffer = new byte[1000];
int bufferIndex;

void receive(byte[] data, String HOST_IP, int PORT_RX) {
  for (int i=0;i<data.length;i++) {
    // END byte
    if (data[i] == 0) {
      // calculate CRC;
      if (bufferIndex <= 4)
        return;  

      // Calculate the CRC
      byte[] CRC = new byte[4];
      byte[] receiveString = new byte[bufferIndex-4];

      for (int j=0;j<bufferIndex-4;j++) {
        int index = j%4;
        receiveString[j] = receiveBuffer[j];
        CRC[index] ^= receiveBuffer[j];
      }
      // if CRC matches, commit the message
      if (CRC[0] == receiveBuffer[bufferIndex-4] && CRC[1] == receiveBuffer[bufferIndex-3] && CRC[2] == receiveBuffer[bufferIndex-2] && CRC[3] == receiveBuffer[bufferIndex-1]) {
        processPacket(new String(receiveString));
      }

      bufferIndex = 0;
      return;
    }

    // if else, just accumlate it
    receiveBuffer[bufferIndex++] = data[i];
    if (bufferIndex==1000)    // if data explode happens in buffer, just clear it
      bufferIndex = 0;
  }
}

void processPacket(String packet) {
  int[] values = int(split(packet, "\t"));
  int i = values[0]; 
  px[i] = values[1];
  py[i] = values[2];
  pz[i] = values[3];
  pF[i] = values[4];

  int grabForce = 0;
  int left = 0;
  int right = 0;
  for (i=0;i<5;i++) {
    if (px[i]>1000 && px[i] < 3000) {
      grabForce += abs(pF[i]);
    }
    else if (px[i] > 3000 && px[i] < 4000) {
      right += abs(pF[i]);
    }
    else if (px[i] > 5000 && px[i] < 6000) {
      left += abs(pF[i]);
    }
  }
  
  clawForce.feed(grabForce);
  leftForce.feed(left);
  rightForce.feed(right);
}