class Ball {
  constructor(x, y, radius) {
    this.x = x;
    this.y = y;
    this.shadowY = y;
    this.velocity = createVector(radius * 0.21, random(-radius * 0.084, radius * 0.084));
    this.radius = radius;
  }

  update(ballArc) {
    this.x += this.velocity.x;
    this.shadowY += this.velocity.y;
    this.y = this.shadowY - ballArc;
  }

  render() {
    push();
    noStroke();
    fill(54, 54, 54, 100);
    ellipse(this.x, this.shadowY, this.radius);
    stroke(54);
    strokeWeight(1);
    fill(255, 255, 0);
    ellipse(this.x, this.y, this.radius);
    pop();
  }
}

class Paddle {
  constructor(x, y, slope, bottomBound, topBound, images, isPlayer, width) {
    this.x = x;
    this.y = y;
    this.bottomBound = bottomBound;
    this.topBound = topBound;
    this.slope = -slope;
    this.images = images;
    this.counter = 0;
    this.animationSpeed = 0.1;
    this.width = width;
    this.height = width * 2;
    this.moveDirection = "none";
    this.isPlayer = isPlayer;
    this.playerHasMoved = false;
  }

  move() {
    const speed = this.height * 0.05;
    if (this.moveDirection === 'up' && this.y > this.topBound) {
      this.y -= speed
      this.x += (speed/this.slope)
      this.counter += this.animationSpeed;
    } else if (this.moveDirection === 'down' && this.y < this.bottomBound) {
      this.y += speed
      this.x -= (speed/this.slope)
      this.counter += this.animationSpeed;
    }
  }

  autoMove(ballY) {
    const diff = this.y - ballY;
    if (diff < 0 && diff < -this.height * 0.5) { // move down
      this.switchMoveDirection('down');
    } else if (diff > 0 && diff > this.height * 0.5) { // move up
      this.switchMoveDirection('up');
    } else {
      this.switchMoveDirection('none');
    }
    this.move();
  }

  switchMoveDirection(type) {
    switch (type) {
      case 'up':
        this.moveDirection = 'up';
        this.playerHasMoved = true;
        break
      case 'down':
        this.moveDirection = 'down';
        this.playerHasMoved = true;
        break
      default:
        this.moveDirection = 'none'
    }
  }

  render() {
    const y1 = this.y - this.height;
    const x1 = this.x + (this.height/this.slope);

    const x2 = x1 + this.width;
    const y2 = y1;

    const x3 = this.x + this.width;
    const y3 = this.y;

    this.imageIdx = floor(this.counter) % this.images.length;

    if (this.images.length > 0) {
      noStroke();
      fill(54, 54, 54, 25);
      ellipse(this.x, this.y + this.height, this.height, this.width * 1.5);
      imageMode(CENTER);
      image(this.images[this.imageIdx], this.x, this.y, this.width * 2, this.height * 2);
      if (this.isPlayer && !this.playerHasMoved) {
        textSize(14);
        fill(54);
        text("use the arrow keys to move!", this.x - padding, this.y - (this.height * 1.5));
      }
    } else {
      noStroke();
      fill(54);
      quad(this.x, this.y, x1, y1, x2, y2, x3, y3);
    }
  }
}

let width, height;
let courtTopLeftX, courtTopLeftY, courtBottomLeftX, courtBottomLeftY,
    courtBottomRightX, courtBottomRightY, courtTopRightX, courtTopRightY;
let netTopLeftX, netTopLeftY, netBottomLeftX, netBottomLeftY,
    netBottomRightX, netBottomRightY, netTopRightX, netTopRightY;
let netWidth, shadowSize, padding, quadOffset;
let paddleOne, paddleTwo;
let ball;
let leftPlayerScore, rightPlayerScore;
let tennisManRedOne, tennisManRedTwo, tennisManBlueOne, tennisManBlueTwo;
let courtHeight, courtWidth, maxBallArc, oneFourthPoint, threeFourthsPoint;

function preload() {
  tennisManRedOne = loadImage('https://res.cloudinary.com/dkw0kkkgd/image/upload/v1550623424/tennisManRedOne_zaszr5.png');
  tennisManRedTwo = loadImage('https://res.cloudinary.com/dkw0kkkgd/image/upload/v1550623420/tennisManRedTwo_mz3skr.png');
  tennisManBlueOne = loadImage('https://res.cloudinary.com/dkw0kkkgd/image/upload/v1550623406/tennisManBlueOne_jo7ppq.png');
  tennisManBlueTwo = loadImage('https://res.cloudinary.com/dkw0kkkgd/image/upload/v1550623416/tennisManBlueTwo_ac6ppw.png');
}

function setup() {
  setupCanvas();
  leftPlayerScore = 0; rightPlayerScore = 0; // setup scoreboard
  setupCourtCoordinates();
  setupNetCoordinates();
  setupPaddles();
  ball = new Ball(width * 0.5, height * 0.5, width * 0.021); // setup ball
}

function setupCanvas() {
  height = min(window.innerHeight, window.innerWidth / 2);
  // keep court dimensions nice
  width = min(window.innerWidth, height * 2);
  createCanvas(width, height);
}

function draw() {
  paddleOne.move(); // move player according to keyboard inputs
  paddleTwo.autoMove(ball.y); // computer player moves on its own relative to the ball's position
  updateBall();
  isColliding(); // check if ball is colliding with players
  didHitWall(); // check if ball is colliding with walls
  didScore(); // check if a player has scored
  background(255); // draw background
  drawCourt();
  drawCourtLines();
  paddleOne.render(); // draw player
  paddleTwo.render(); // draw computer player
  drawNet();
  ball.render(); // draw ball
  drawScore();
}

function setupCourtCoordinates() {
  padding = height * 0.125;
  quadOffset = width * 0.125;

  // top left coordinates of court
  courtTopLeftX = padding + quadOffset;
  courtTopLeftY = padding;

  // bottom left coordinates of court
  courtBottomLeftX = padding;
  courtBottomLeftY = height - padding;

  // bottom right coordinates of court
  courtBottomRightX = width - padding - quadOffset;
  courtBottomRightY = height - padding;

  // top right coordinates of court
  courtTopRightX = width - padding;
  courtTopRightY = padding;
}

function setupNetCoordinates() {
  // net settings
  netWidth = height * 0.125;
  shadowSize = width * 0.021;

  // top left of net
  netTopLeftX = (width * 0.5) + quadOffset * 0.5;
  netTopLeftY = padding - netWidth;

  // bottom left of net
  netBottomLeftX = width * 0.5 - quadOffset * 0.5;
  netBottomLeftY = height - padding - netWidth;

  // bottom right of net
  netBottomRightX = width * 0.5 - quadOffset * 0.5;
  netBottomRightY = height - padding;

  // top right of net
  netTopRightX = width * 0.5 + quadOffset * 0.5;
  netTopRightY = padding;
}

function setupPaddles() {
  const bottomBound = courtBottomLeftY;
  const topBound = courtTopRightY;
  const yBounds = [bottomBound, topBound];

  const position = [courtBottomLeftX + 30, courtBottomLeftY - 60];
  const slope = (courtBottomLeftY - courtTopLeftY)/(courtBottomLeftX - courtTopLeftX);
  const blueImages = [tennisManBlueOne, tennisManBlueTwo];
  paddleOne = new Paddle(...position, slope, ...yBounds, blueImages, isPlayer = true, width * 0.03);

  const twoPosition = [courtTopRightX - 70, courtTopRightY + 60];
  const twoSlope = (courtTopRightY - courtBottomRightY)/(courtTopRightX - courtBottomRightX);
  const redImages = [tennisManRedOne, tennisManRedTwo];
  paddleTwo = new Paddle(...twoPosition, twoSlope, ...yBounds, redImages, isPlayer = false, width * 0.03);
}

function keyReleased() {
  if (keyCode === UP_ARROW || keyCode === DOWN_ARROW) {
    paddleOne.switchMoveDirection('none');
  } else if (keyCode === 87 || keyCode === 83) {
    paddleOne.switchMoveDirection('none');
  }
}

function keyPressed() {
  if (keyCode === UP_ARROW) {
    paddleOne.switchMoveDirection('up');
  } else if (keyCode === DOWN_ARROW) {
    paddleOne.switchMoveDirection('down');
  }
}

function isColliding() {
  const bottomOfBall = ball.y + ball.radius,
        topOfBall = ball.y - ball.radius,
        topOfPaddleOne = paddleOne.y - paddleOne.height,
        bottomOfPaddleOne = paddleOne.y + paddleOne.height,
        topOfPaddleTwo = paddleTwo.y - paddleTwo.height,
        bottomOfPaddleTwo = paddleTwo.y + paddleTwo.height;

  if (ball.x >= paddleOne.x - paddleOne.width && ball.x <= paddleOne.x + paddleOne.width) {
    if (topOfBall <= bottomOfPaddleOne && bottomOfBall >= topOfPaddleOne) {
      playerCollisionEvent();
    }
  } else if (ball.x >= paddleTwo.x - paddleTwo.width && ball.x <= paddleTwo.x + paddleTwo.width) {
    if (topOfBall <= bottomOfPaddleTwo && bottomOfBall >= topOfPaddleTwo) {
      computerCollisionEvent();
    }
  }
}

function playerCollisionEvent() {
  ball.velocity.x *= -1.03;
  ball.x = paddleOne.x + paddleOne.width + 5;
  let velocityMag;
  let xVel = ball.velocity.x;

  const maxTopSlope = (courtTopRightY - (paddleOne.y - paddleOne.height))/(courtTopRightX - (paddleOne.x + paddleOne.width)); // range from -0.38 to 0
  const maxBottomSlope = (courtBottomRightY - (paddleOne.y + paddleOne.height))/(courtBottomRightX - (paddleOne.x + paddleOne.width)); // range from 0 to 0.54

  if (ball.y < paddleOne.y) {
    velocityMag = -random(4);
    ball.velocity.y = map(velocityMag, -4, 0, xVel * maxTopSlope, 0);
  } else {
    velocityMag = random(4);
    ball.velocity.y = map(velocityMag, 0, 4, 0, xVel * maxBottomSlope);
  }
}

function computerCollisionEvent() {
  ball.velocity.x *= -1.03;
  ball.x = paddleTwo.x - paddleTwo.width - 4;
  let velocityMag;
  let xVel = ball.velocity.x;

  const maxTopSlope = (courtTopLeftY - (paddleTwo.y - paddleTwo.height))/(courtTopLeftX - (paddleTwo.x - paddleTwo.width)); // 0 to 0.56
  const maxBottomSlope = (courtBottomLeftY - (paddleTwo.y + paddleTwo.height))/(courtBottomLeftX - (paddleTwo.x - paddleTwo.width)); // 0 to -0.39

  if (ball.y < paddleTwo.y) {
    velocityMag = -random(4);
    ball.velocity.y = map(velocityMag, -4, 0, xVel * maxTopSlope, 0);
  } else {
    velocityMag = random(4);
    ball.velocity.y = map(velocityMag, 0, 4, 0, xVel * maxBottomSlope);
  }
}

function resetBall() {
  ball.x = width * 0.5;
  ball.y = height * 0.5;
  ball.shadowY = height * 0.5;
  ball.velocity.x = (ball.velocity.x < 0) ? ball.radius * 0.21 : -(ball.radius * 0.21);
  ball.velocity.y = random(-ball.radius * 0.084, ball.radius * 0.084);
}

function didHitWall() {
  const upperBound = courtTopLeftY;
  const lowerBound = courtBottomLeftY;

  if (ball.y <= upperBound) { ball.velocity.y *= -1 }
  if (ball.y >= lowerBound) { ball.velocity.y *= -1 }
}

function didScore() {
  const leftBound = courtBottomLeftX;
  const rightBound = courtTopRightX;

  if (ball.x <= leftBound) { rightPlayerScore++; resetBall(); }
  if (ball.x >= rightBound) { leftPlayerScore++; resetBall(); }
}

function updateBall() {
  let ballArc;
  maxBallArc = height * 0.0625;
  courtWidth = width - (2 * padding) - quadOffset;
  oneFourthPoint = courtBottomLeftX + quadOffset * 0.5 + courtWidth * 0.25;
  threeFourthsPoint = courtTopRightX - quadOffset * 0.5 - courtWidth * 0.25;

  const oneRacketX = paddleOne.x + paddleOne.width;
  const twoRacketX = paddleTwo.x - paddleTwo.width;

  if (ball.velocity.x > 0) { // ball is moving right
    if (ball.x <= width * 0.5) {
      ballArc = map(ball.x, oneRacketX, width * 0.5, maxBallArc * 0.5, maxBallArc);
    } else if (ball.x > width * 0.5 && ball.x <= threeFourthsPoint) {
      ballArc = map(ball.x, width * 0.5, threeFourthsPoint, maxBallArc, 0);
    } else {
      ballArc = map(ball.x, threeFourthsPoint, twoRacketX, 0, maxBallArc * 0.5);
    }
  } else { // ball is moving left
    if (ball.x >= width * 0.5) {
      ballArc = map(ball.x, twoRacketX, width * 0.5, maxBallArc * 0.5, maxBallArc);
    } else if (ball.x < width * 0.5 && ball.x >= oneFourthPoint) {
      ballArc = map(ball.x, width * 0.5, oneFourthPoint, maxBallArc, 0);
    } else {
      ballArc = map(ball.x, oneFourthPoint, oneRacketX, 0, maxBallArc * 0.5);
    }
  }
  ball.update(ballArc);
}

function drawCourt() {
  noStroke();
  fill(54);
  const shift = 10;
  quad(courtTopLeftX + shift, courtTopLeftY + shift, courtBottomLeftX + shift, courtBottomLeftY + shift, courtBottomRightX + shift, courtBottomRightY + shift, courtTopRightX + shift, courtTopRightY + shift);

  fill(161, 238, 168);
  quad(courtTopLeftX, courtTopLeftY, courtBottomLeftX, courtBottomLeftY, courtBottomRightX, courtBottomRightY, courtTopRightX, courtTopRightY);
}

function drawCourtLines() {
  stroke(255);

  courtHeight = height - (2 * padding);
  const topSingleLineX1 = padding + ((1 - 0.125) * quadOffset),
        topSingleLineY = padding + (0.125 * courtHeight),
        topSingleLineX2 = width - padding - (0.125 * quadOffset);

  // middle line
  line(oneFourthPoint, height* 0.5, threeFourthsPoint, height* 0.5);

  // center marker notch thingies
  const markerLength = width/64;
  const leftX = courtBottomLeftX + quadOffset * 0.5;
  const rightX = courtTopRightX - quadOffset * 0.5;
  line(leftX, height * 0.5, leftX + markerLength, height * 0.5);
  line(rightX - markerLength, height * 0.5, rightX, height * 0.5);

  line(topSingleLineX1, topSingleLineY, topSingleLineX2, topSingleLineY);

  const bottomSingleLineX1 = padding + (0.125 * quadOffset),
        bottomSingleLineY = padding + ((1 - 0.125) * courtHeight),
        bottomSingleLineX2 = width - padding - ((1 - 0.125) * quadOffset);

  line(bottomSingleLineX1, bottomSingleLineY, bottomSingleLineX2, bottomSingleLineY);

  // vertical lines in the middle of the court
  line(bottomSingleLineX1 + courtWidth * 0.25, bottomSingleLineY, topSingleLineX1 + courtWidth * 0.25, topSingleLineY);

  line(bottomSingleLineX2 - courtWidth * 0.25, bottomSingleLineY, topSingleLineX2 - courtWidth * 0.25, topSingleLineY);
}

function drawNet() {
  strokeWeight(1);
  // shadow
  noStroke();
  fill(54, 54, 54, 54);
  quad(netTopRightX, netTopRightY, netBottomRightX, netBottomRightY, netBottomRightX + shadowSize, netBottomRightY, netTopRightX + shadowSize, netTopRightY);

  stroke(54);
  // line across
  line(netBottomLeftX, netBottomRightY - netWidth * 0.75, netTopRightX, netTopRightY - netWidth * 0.75);
  line(netBottomLeftX, netBottomRightY - netWidth * 0.5, netTopRightX, netTopRightY - netWidth * 0.5);
  line(netBottomLeftX, netBottomRightY - netWidth * 0.25, netTopRightX, netTopRightY - netWidth * 0.25);

  line(netBottomRightX, netBottomRightY, netTopRightX, netTopRightY);

  // vertical net lines
  line(netBottomLeftX + quadOffset/10, (9*courtHeight)/10 + netWidth, netBottomLeftX + quadOffset/10, (9*courtHeight)/10);
  line(netBottomLeftX + (2*quadOffset)/10, (8*courtHeight)/10 + netWidth, netBottomLeftX + (2*quadOffset)/10, (8*courtHeight)/10);
  line(netBottomLeftX + (3*quadOffset)/10, (7*courtHeight)/10 + netWidth, netBottomLeftX + (3*quadOffset)/10, (7*courtHeight)/10);
  line(netBottomLeftX + (4*quadOffset)/10, (6*courtHeight)/10 + netWidth, netBottomLeftX + (4*quadOffset)/10, (6*courtHeight)/10);
  line(netBottomLeftX + (6*quadOffset)/10, (4*courtHeight)/10 + netWidth, netBottomLeftX + (6*quadOffset)/10, (4*courtHeight)/10);
  line(netBottomLeftX + (7*quadOffset)/10, (3*courtHeight)/10 + netWidth, netBottomLeftX + (7*quadOffset)/10, (3*courtHeight)/10);
  line(netBottomLeftX + (8*quadOffset)/10, (2*courtHeight)/10 + netWidth, netBottomLeftX + (8*quadOffset)/10, (2*courtHeight)/10);
  line(netBottomLeftX + (9*quadOffset)/10, courtHeight/10 + netWidth, netBottomLeftX + (9*quadOffset)/10, courtHeight/10);

  stroke(245);

  strokeWeight(4);
  line(netTopLeftX, netTopLeftY, netBottomLeftX, netBottomLeftY);
  // line through the middle of the net
  line(width * 0.5, height * 0.5, width * 0.5, height * 0.5 - netWidth)
  stroke(54);
  // left post
  line(netBottomRightX, netBottomRightY, netBottomLeftX, netBottomLeftY);

  // right post
  strokeWeight(3);
  line(netTopRightX, netTopRightY, netTopLeftX, netTopLeftY);
}

function drawScore() {
  textSize(height * 0.1);
  noStroke();
  fill(54);
  textAlign(RIGHT);
  text(leftPlayerScore, padding + quadOffset + (courtWidth * 0.25), padding - 10); // player score
  textAlign(LEFT);
  text(rightPlayerScore, width - padding - (courtWidth * 0.25), padding - 10); // computer score
}