// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use core::f64::consts::PI;
use fidl_fuchsia_game_tennis as fidl_tennis;
use fidl_fuchsia_game_tennis::{GameState, PaddleProxy};
use fuchsia_syslog::fx_log_info;
use parking_lot::Mutex;
use std::f64;
use std::sync::Arc;

const TIME_SCALE_FACTOR: f64 = 0.02; // Time scale factor: scales all movements/speeds by this amount.
const BOARD_HEIGHT: f64 = 10.0;
const BOARD_WIDTH: f64 = 20.0;
const PADDLE_SPEED: f64 = 0.4 * TIME_SCALE_FACTOR; // distance paddle travels per step
const PADDLE_SIZE: f64 = 1.0; // vertical height of paddle
const PADDLE_MAX_ANGLE: f64 = std::f64::consts::PI / 4.0; // Maximum paddle angle
const BALL_SPEEDUP_MULTIPLIER: f64 = 1.05; // speed multiplier applied on every paddle bounce
#[allow(unused)]
const MAX_BOUNCE_ANGLE: f64 = 1.3; // in radians, bounce angle when hitting very top edge of paddle

pub struct Game {
    state: GameState,
    player_1: Option<Player>,
    player_2: Option<Player>,
    ball_dx: f64,
    ball_dy: f64,
}

#[derive(Clone)]
struct Player {
    pub name: String,
    pub state: Arc<Mutex<PlayerState>>,
    pub proxy: PaddleProxy,
}

#[derive(Clone)]
pub enum PlayerState {
    Up,
    Down,
    Stop,
    Disconnected,
}

fn calc_paddle_movement(pos: &mut f64, state: &PlayerState) -> bool {
    let player_delta = match state {
        PlayerState::Up => PADDLE_SPEED * -1.0,
        PlayerState::Down => PADDLE_SPEED,
        PlayerState::Stop => 0.0,
        PlayerState::Disconnected => return false,
    };
    let mut new_paddle_location = *pos + player_delta;
    new_paddle_location = new_paddle_location.max(PADDLE_SIZE / 2.0);
    new_paddle_location = new_paddle_location.min(BOARD_HEIGHT - PADDLE_SIZE / 2.0);
    *pos = new_paddle_location;
    true
}

fn calc_paddle_bounce(dx: &mut f64, dy: &mut f64, ball_y: f64, paddle_y: f64) {
    let speed = ((*dx) * (*dx) + (*dy) * (*dy)).sqrt() * BALL_SPEEDUP_MULTIPLIER;
    let paddle_angle = PADDLE_MAX_ANGLE * (ball_y - paddle_y) / (PADDLE_SIZE / 2.0);

    let new_ball_dx = -dx.signum() * speed * paddle_angle.cos();
    let new_ball_dy = speed * paddle_angle.sin();
    if (*dx) * new_ball_dx >= 0.0 {
        panic!("Ball bouncing in the same direction!");
    }
    *dx = new_ball_dx;
    *dy = new_ball_dy;
}

impl Game {
    /// return clone of internal state
    pub fn state(&self) -> GameState {
        fidl_tennis::GameState {
            ball_x: self.state.ball_x,
            ball_y: self.state.ball_y,
            player_1_y: self.state.player_1_y,
            player_2_y: self.state.player_2_y,
            player_1_score: self.state.player_1_score,
            player_2_score: self.state.player_2_score,
            player_1_name: self.state.player_1_name.clone(),
            player_2_name: self.state.player_2_name.clone(),
            time: self.state.time,
            game_num: self.state.game_num,
        }
    }
    pub fn new() -> Game {
        Game {
            player_1: None,
            player_2: None,
            ball_dx: 0.0,
            ball_dy: 0.0,
            state: GameState {
                ball_x: 0.0,
                ball_y: 0.0,
                game_num: 0,
                player_1_y: 0.0,
                player_2_y: 0.0,
                player_1_score: 0,
                player_2_score: 0,
                player_1_name: "".to_string(),
                player_2_name: "".to_string(),
                time: 0,
            },
        }
    }

    pub fn time_scale_factor(&self) -> f64 {
        TIME_SCALE_FACTOR
    }

    pub fn players_ready(&self) -> bool {
        return self.player_1.is_some() && self.player_2.is_some();
    }

    pub fn register_new_paddle(
        &mut self,
        player_name: String,
        paddle_proxy: PaddleProxy,
    ) -> Arc<Mutex<PlayerState>> {
        let paddle = Player {
            name: player_name.clone(),
            state: Arc::new(Mutex::new(PlayerState::Stop)),
            proxy: paddle_proxy,
        };
        let res = paddle.state.clone();
        if self.player_1.is_none() {
            self.player_1 = Some(paddle);
            self.state.player_1_name = player_name;
        } else if self.player_2.is_none() {
            self.player_2 = Some(paddle);
            self.state.player_2_name = player_name;
        } else {
            panic!("too many clients connected");
        }
        return res;
    }

    pub fn step(&mut self) {
        if self.players_ready() && self.state.game_num == 0 {
            self.new_game();
        } else if !self.players_ready() {
            // game has not started yet
            return;
        }

        self.state.time += 1;

        if !calc_paddle_movement(
            &mut self.state.player_1_y,
            &self.player_1.as_mut().unwrap().state.lock(),
        ) {
            self.player_1 = None;
            self.new_game();
            self.state.game_num = 0;
            self.state.player_1_score = 0;
            self.state.player_2_score = 0;
            return;
        }
        if !calc_paddle_movement(
            &mut self.state.player_2_y,
            &self.player_2.as_mut().unwrap().state.lock(),
        ) {
            self.player_2 = None;
            self.new_game();
            self.state.game_num = 0;
            self.state.player_1_score = 0;
            self.state.player_2_score = 0;
            return;
        }

        let mut new_ball_x = self.state.ball_x + self.ball_dx;
        let mut new_ball_y = self.state.ball_y + self.ball_dy;

        // reflect off the top/bottom of the board
        if new_ball_y <= 0.0 || new_ball_y > BOARD_HEIGHT {
            self.ball_dy = -self.ball_dy;
            if new_ball_y <= 0.0 {
                new_ball_y = new_ball_y.abs()
            } else {
                // Y = H-(y-H)
                new_ball_y = 2.0 * BOARD_HEIGHT - new_ball_y;
            }
            fx_log_info!("bounce off top or bottom");
        }

        // reflect off the left/right of the board, if a paddle is in the way
        if new_ball_x <= 0.0 {
            //
            // X+dx*t=0 => t=-X/dx
            // Y+dy*t=NY => NY=Y-X*dy/dx
            //
            new_ball_y = self.state.ball_y - self.state.ball_x * self.ball_dy / self.ball_dx;
            // we're about to go off of the left side
            if new_ball_y > self.state.player_1_y + (PADDLE_SIZE / 2.0)
                || new_ball_y < self.state.player_1_y - (PADDLE_SIZE / 2.0)
            {
                // player 1 missed, so player 2 gets a point and we reset
                fx_log_info!(
                    "ball {} {}, new y {}, paddle {}",
                    self.state.ball_x,
                    self.state.ball_y,
                    new_ball_y,
                    self.state.player_1_y
                );
                self.state.player_2_score += 1;
                self.new_game();
                return;
            } else {
                calc_paddle_bounce(
                    &mut self.ball_dx,
                    &mut self.ball_dy,
                    new_ball_y,
                    self.state.player_1_y,
                );
                new_ball_x = new_ball_x.abs();
                if self.ball_dx < 0.0 {
                    panic!("Ball going in the wrong direction");
                }
                fx_log_info!("bounce off left");
            }
        }
        if new_ball_x > BOARD_WIDTH {
            //
            // X+dx*t=BOARD_WIDTH => t=(BOARD_WIDTH-X)/dx
            // Y+dy*t=NY => NY=Y+(BOARD_WIDTH-X)*dy/dx
            //
            new_ball_y =
                self.state.ball_y + (BOARD_WIDTH - self.state.ball_x) * self.ball_dy / self.ball_dx;
            // we're about to go off of the right side
            if new_ball_y > self.state.player_2_y + (PADDLE_SIZE / 2.0)
                || new_ball_y < self.state.player_2_y - (PADDLE_SIZE / 2.0)
            {
                // player 2 missed, so player 1 gets a point and we reset
                fx_log_info!(
                    "ball {} {}, new y {}, paddle {}",
                    self.state.ball_x,
                    self.state.ball_y,
                    new_ball_y,
                    self.state.player_2_y
                );
                self.state.player_1_score += 1;
                self.new_game();
                return;
            } else {
                calc_paddle_bounce(
                    &mut self.ball_dx,
                    &mut self.ball_dy,
                    new_ball_y,
                    self.state.player_2_y,
                );
                // X = W-(x-W)
                new_ball_x = 2.0 * BOARD_WIDTH - new_ball_x;
                if self.ball_dx > 0.0 {
                    panic!("Ball going in the wrong direction");
                }
                fx_log_info!("bounce off right");
            }
        }

        self.state.ball_x = new_ball_x;
        self.state.ball_y = new_ball_y;
    }

    fn new_game(&mut self) {
        self.player_1.as_mut().map(|player| {
            *player.state.lock() = PlayerState::Stop;
            let _ = player.proxy.new_game(false);
        });
        self.player_2.as_mut().map(|player| {
            *player.state.lock() = PlayerState::Stop;
            let _ = player.proxy.new_game(true);
        });

        self.ball_dx = 0.0;
        while self.ball_dx.abs() < 0.2 {
            let angle: f64 = rand::random::<f64>() * 2.0 * PI;
            self.ball_dx = angle.sin();
            self.ball_dy = angle.cos();
        }
        self.ball_dx *= TIME_SCALE_FACTOR;
        self.ball_dy *= TIME_SCALE_FACTOR;
        self.state.ball_x = BOARD_WIDTH / 2.0;
        self.state.ball_y = BOARD_HEIGHT / 2.0;
        self.state.game_num += 1;
        self.state.player_1_y = BOARD_HEIGHT / 2.0;
        self.state.player_2_y = BOARD_HEIGHT / 2.0;
        self.state.time = 0;
    }
}