import processing.core.PApplet;
import processing.core.PVector;
import java.util.ArrayList;

PVector target, cameraOffset;
float centerToCornerDistance, farAway;
float alignRadius, alignWeight, centralizeRadius, centralizeWeight;
float spdLimit = 10;
int fishCount = 50;
Fish player;
ArrayList<Fish> fish = new ArrayList<Fish>();
ArrayList<Fish> fishToRemove = new ArrayList<Fish>();
private boolean targetActive = false;
private float t;
private final float maxFishSize = 30;


public void settings() {
  fullScreen(P3D);
  orientation(PORTRAIT);
}

public void setup() {
  cameraOffset = new PVector(width * .5f, height * .5f);
  player = new Fish();
  player.pos = new PVector(0, 0);
  player.spd = new PVector();
  target = new PVector(player.pos.x, player.pos.y);
}

public void draw() {
  t = radians(frameCount);
  centerToCornerDistance = dist(0, 0, width * .5f, height * .5f);
  farAway = centerToCornerDistance * 2;
  background(0);
  pushMatrix();
  translate(cameraOffset.x, cameraOffset.y);
  updateTarget();
  movePlayerTowardsTarget();
  moveCameraTowardsPlayer();
  drawFish();
  while (fish.size() < fishCount) {
    fish.add(new Fish());
  }
  popMatrix();
  drawSliders();

  if (frameCount > 1300 && frameCount < 1600) {
    //            saveFrame("capture/####.jpg");
  }
}

private void drawSliders() {
  spdLimit =      /*slider("spd limit", 1, 100,*/ 10;
  alignRadius =   /*slider("align radius", 10, 400,*/ 200;
  alignWeight =   /*slider("align weight", 0, 1,*/ .5f;
  //        avoidRadius =   /*slider("avoid radius", 10, 200,*/ 20;
  centralizeRadius = /*slider("centralize radius", 10, 400,*/ 100;
  centralizeWeight = /*slider("centralize weight", 0, 1,*/ .5f;
}

private void drawFish() {
  noFill();
  for (Fish f : fish) {
    stroke(155, 155, 255, 150);
    strokeWeight(1);
    f.updateAndDraw();
    if (f.toRemove) {
      fishToRemove.add(f);
    }
  }
  stroke(255, 255);
  strokeWeight(1);
  player.updateAndDraw();
  fish.removeAll(fishToRemove);
  fishToRemove.clear();
}

private void updateTarget() {
  if (mousePressed) {
    target.x = mouseX - cameraOffset.x;
    target.y = mouseY - cameraOffset.y;
    targetActive = true;
  }
  if (dist(player.pos.x, player.pos.y, target.x, target.y) < 3) {
    targetActive = false;
  }
}

private float distanceFromPlayerToTarget() {
  return (target.x == player.pos.x && target.y == player.pos.y) ? 0 : dist(player.pos.x, player.pos.y, target.x, target.y);
}

private void movePlayerTowardsTarget() {
  if (!targetActive) {
    return;
  }
  player.spd.x = lerp(player.pos.x, target.x, .1f);
  player.spd.y = lerp(player.pos.y, target.y, .1f);
  player.spd.sub(player.pos);
  player.spd.limit(10);
  player.spd.mult(.9f);
  player.pos.add(player.spd);
}

private void moveCameraTowardsPlayer() {
  PVector playerCoordinateOnScreen = new PVector(modelX(player.pos.x, player.pos.y, player.pos.z), modelY(player.pos.x, player.pos.y, player.pos.z), 0);
  cameraOffset.x = lerp(cameraOffset.x, width * .5f - player.pos.x, .1f);
  cameraOffset.y = lerp(cameraOffset.y, height * .5f - player.pos.y, .1f);
}

boolean isPointInRect(float px, float py, float rx, float ry, float rw, float rh) {
  return px >= rx && px <= rx + rw && py >= ry && py <= ry + rh;
}

class Fish {
  PVector pos;
  PVector spd = new PVector();
  PVector acc = new PVector();
  float radius;
  boolean toRemove = false;
  PVector centralizeAvgPos = new PVector();
  PVector friendAlignAvgSpd = new PVector();
  PVector friendAvoidance = new PVector();
  PVector enemyAvoidance = new PVector();
  PVector foodAvgPos = new PVector();


  private float seekFoodWeight = 2;

  Fish beingEatenBy = null;


  Fish() {
    if (player == null) {
      pos = new PVector(width * .5f, height * .5f);
      radius = 15;
    } else {
      pos = randomPositionOffscreenInFrontOfPlayer();
      radius = random(maxFishSize);
    }
  }

  void updateAndDraw() {
    if (beingEatenBy != null) {
      beingEatenBy.radius *= 1.05f;
      beingEatenBy.radius = constrain(beingEatenBy.radius, 0, maxFishSize);
      this.toRemove = true;
      return;
    }

    acc.mult(0);
    centralizeAvgPos.mult(0);
    friendAlignAvgSpd.mult(0);
    friendAvoidance.mult(0);
    enemyAvoidance.mult(0);
    foodAvgPos.mult(0);
    int alignToFriendsFlockCount = 0;
    int centralizeFriendCount = 0;
    int foodCount = 0;

    float safeDistanceFromFriend = radius*2;
    float foodRecognitionRadius = radius*6;
    float safeDistanceFromEnemy = radius*8;

    for (Fish f : fish) {
      if (this.equals(f)) {
        continue;
      }
      float d = dist(f.pos.x, f.pos.y, pos.x, pos.y);
      if (isFriend(f) && d < alignRadius) {
        friendAlignAvgSpd.add(f.spd);
        alignToFriendsFlockCount++;
      }
      if (isFriend(f) && d < safeDistanceFromFriend) {
        friendAvoidance.add(PVector.sub(pos, f.pos).normalize());
      } else if (isEnemy(f) && d < safeDistanceFromEnemy) {
        enemyAvoidance.add(PVector.sub(pos, f.pos).normalize());
      }
      if (isFood(f) && d < foodRecognitionRadius) {
        foodAvgPos.add(f.pos);
        foodCount++;
        if (d < radius) {
          f.beingEatenBy = this;
        }
      }
      if (isFriend(f) && d < centralizeRadius) {
        centralizeAvgPos.add(f.pos);
        centralizeFriendCount++;
      }
    }
    if (centralizeFriendCount > 0) {
      centralizeAvgPos.div(centralizeFriendCount);
    }
    if (alignToFriendsFlockCount > 0) {
      friendAlignAvgSpd.div(alignToFriendsFlockCount);
    }

    acc.add(friendAvoidance);
    //            acc.add(enemyAvoidance);
    //            acc.add(PVector.sub(foodAvgPos, pos).normalize().mult(seekFoodWeight));
    acc.add(PVector.sub(centralizeAvgPos, pos).normalize().mult(centralizeWeight));
    acc.add(friendAlignAvgSpd.normalize().mult(alignWeight));

    spd.add(acc);
    spd.limit(spdLimit);
    spd.mult(.9f);
    pos.add(spd);

    pushMatrix();
    translate(pos.x, pos.y);
    rotate(spd.heading());
    float distanceToPlayer = dist(pos.x, pos.y, player.pos.x, player.pos.y);
    if (distanceToPlayer > farAway && isBehindPlayer(pos)) {
      this.toRemove = true;
    }

    beginShape(TRIANGLE_STRIP);
    int vertexCount = 12;
    for (float i = -vertexCount * .25f; i < vertexCount; i++) {
      boolean tail = i < 0;
      float iN = map(i, 0, vertexCount - 1, 0, 1);
      float x = map(iN, 0, 1, -radius * 2, radius);
      float y0 =  radius * .5f * sin(iN * 3.f) + radius*.1f*sin(iN*2-t*25)*(tail?2:1);
      float y1 = -radius * .5f * sin(iN * 3.f) + radius*.1f*sin(iN*2-t*25)*(tail?2:1);
      vertex(x, y0);
      vertex(x, y1);
    }
    endShape();
    popMatrix();
  }

  private boolean isFood(Fish f) {
    return false;
    //            return f.radius < radius*.5f;
  }

  private boolean isFriend(Fish f) {
    return true;
    //abs(f.radius-radius)<=5;
  }

  private boolean isEnemy(Fish f) {
    return false;
    //            return f.radius - 5 > radius;
  }

  private boolean isBehindPlayer(PVector pos) {
    float angleToPlayer = atan2(player.pos.y - pos.y, player.pos.x - pos.x);
    float normalizedAngleToPlayer = normalizeAngle(angleToPlayer, PI);
    float normalizedPlayerHeading = normalizeAngle(player.spd.heading(), PI);
    float angleToPlayerVsHeading = normalizeAngle(normalizedAngleToPlayer - normalizedPlayerHeading, 0);
    return abs(angleToPlayerVsHeading) < HALF_PI;
  }

  private PVector randomPositionOffscreenInFrontOfPlayer() {
    float angle = random(player.spd.heading() - HALF_PI, player.spd.heading() + HALF_PI);
    float distance = random(centerToCornerDistance, farAway);
    return new PVector(player.pos.x + distance * cos(angle), player.pos.y + distance * sin(angle));
  }

  public float normalizeAngle(float a, float center) {
    return a - TWO_PI * floor((a + PI - center) / TWO_PI);
  }

  boolean isPointInRect(float px, float py, float rx, float ry, float rw, float rh) {
    return px >= rx && px <= rx + rw && py >= ry && py <= ry + rh;
  }

  boolean isPointInRectCenterMode(float px, float py, float rx, float ry, float rw, float rh) {
    return px >= rx - rw * .5f && px <= rx + rw * .5f && py >= ry - rh * .5f && py <= ry + rh * .5f;
  }

  class Slider {
    String name;
    float value;
    float min;
    float max;
    float defaultValue;
    int lastInteractedWith = -1;
  }
}

}