use std::{
    sync::{
        atomic::{AtomicBool, AtomicU32, Ordering::SeqCst},
        Arc, Mutex, MutexGuard,
    },
    time::Duration,
};

use anyhow::Result;
use assetpath::AssetPath;
use engine::prelude::{cgmath::vec3, *};

use crate::{
    board::{Board, BoardSlot, BoardSlotState},
    objects::Objects,
    simple_ai::SimpleAI,
};

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
pub enum StoneState {
    ReadyToBePlaced,
    Placed,
    Dead,
}

pub struct Stone {
    pub stone: Entity,
    pub state: StoneState,
}

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
pub enum GameState {
    Waiting,
    Placing,
    Removing,
    Main,
}

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
pub enum PlayerColor {
    White,
    Black,
}

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
pub enum MillState {
    White,
    Black,
    None,
}

pub enum LogSeverity {
    Basic,
    Debug,
}

const LOG_SEVERITY: LogSeverity = LogSeverity::Basic;

impl PlayerColor {
    pub fn swap(&mut self) {
        *self = match *self {
            PlayerColor::White => {
                MillGame::log("swapped to black player", LogSeverity::Debug);

                PlayerColor::Black
            }
            PlayerColor::Black => {
                MillGame::log("swapped to white player", LogSeverity::Debug);

                PlayerColor::White
            }
        }
    }

    pub fn other(&self) -> Self {
        match self {
            PlayerColor::White => PlayerColor::Black,
            PlayerColor::Black => PlayerColor::White,
        }
    }
}

pub struct MillGame {
    engine: Arc<Engine>,
    last_turn_timing: Mutex<Duration>,

    board: Arc<Mutex<Board>>,
    white_stones: Mutex<[Stone; 9]>,
    black_stones: Mutex<[Stone; 9]>,

    state: Mutex<GameState>,
    current_player: Mutex<PlayerColor>,

    scene: Mutex<SceneHandle>,
    camera_controls: Mutex<CameraControl>,

    mouse_x: AtomicU32,
    mouse_y: AtomicU32,

    turn_finished: AtomicBool,

    selected_field: Mutex<Option<(usize, usize, usize)>>,

    simple_ai: SimpleAI,

    white_player_label: Arc<Label>,
    black_player_label: Arc<Label>,
    start_button: Arc<Button>,
    grid: Arc<Grid>,

    gui: Arc<GuiBuilder>,
}

impl MillGame {
    pub const OFFSET_TO_BOARD: f32 = 0.02;
    pub const TURN_WAIT_TIME: Duration = Duration::from_millis(500);

    pub fn new(engine: Arc<Engine>) -> Result<Arc<Self>> {
        let mut scene = SceneHandle::new(&engine)?;
        let board = Board::new(&engine, &mut scene)?;

        let mut white_stones = None;
        let mut black_stones = None;

        scene.on_scene(|scene| {
            let view = scene.view_mut();

            view.camera_mut().set_center(board.center());
            view.update_buffer()?;

            // add light
            let mut sun_light = engine.new_directional_light()?;
            sun_light.set_direction(vec3(10.0, -4.0, -20.0))?;
            sun_light.set_color(vec3(1.0, 1.0, 1.0))?;
            sun_light.set_position(vec3(0.0, 0.0, 100.0))?;
            sun_light.set_power(10000000000.0)?;

            scene.add_light(sun_light)?;

            white_stones = Some(
                Self::init_nine_stones(&engine, Color::White)?
                    .into_iter()
                    .enumerate()
                    .map(|(index, mut e)| {
                        let location = e.get_component_mut::<Location>()?;
                        location.set_position(board.white_start_slots()[index].extend(0.0));

                        Ok(Stone {
                            stone: scene.add_entity(e)?,
                            state: StoneState::ReadyToBePlaced,
                        })
                    })
                    .collect::<Result<Vec<Stone>>>()?
                    .try_into()
                    .unwrap_or_else(|_: Vec<Stone>| {
                        unreachable!("create array from vec from an array")
                    }),
            );

            black_stones = Some(
                Self::init_nine_stones(&engine, Color::try_from("#2c2c2c")?)?
                    .into_iter()
                    .enumerate()
                    .map(|(index, mut e)| {
                        let location = e.get_component_mut::<Location>()?;
                        location.set_position(board.black_start_slots()[index].extend(0.0));

                        Ok(Stone {
                            stone: scene.add_entity(e)?,
                            state: StoneState::ReadyToBePlaced,
                        })
                    })
                    .collect::<Result<Vec<Stone>>>()?
                    .try_into()
                    .unwrap_or_else(|_: Vec<Stone>| {
                        unreachable!("create array from vec from an array")
                    }),
            );

            Ok(())
        })?;

        let mut camera_control = CameraControl::new(&mut scene)?;
        camera_control.set_zoom_levels(
            (3..60).into_iter().rev().map(|z| z as f32).collect(),
            5,
            &mut scene,
        )?;

        scene.activate()?;

        let gui = GuiBuilder::new(
            engine.gui_handler(),
            &AssetPath::from((
                engine.settings().resource_base_path.as_str(),
                "mainmenu.xml",
            )),
        )?;

        let grid: Arc<Grid> = gui.element("grid")?;
        let white_player_label: Arc<Label> = gui.element("white_player_label")?;
        let black_player_label: Arc<Label> = gui.element("black_player_label")?;
        let start_button: Arc<Button> = gui.element("start")?;

        gui.enable()?;

        let me = Arc::new(Self {
            engine: engine.clone(),
            last_turn_timing: Mutex::default(),

            board: Arc::new(Mutex::new(board)),
            white_stones: Mutex::new(white_stones.unwrap()),
            black_stones: Mutex::new(black_stones.unwrap()),

            state: Mutex::new(GameState::Waiting),
            current_player: Mutex::new(PlayerColor::White),

            scene: Mutex::new(scene),
            camera_controls: Mutex::new(camera_control),

            mouse_x: AtomicU32::new(0),
            mouse_y: AtomicU32::new(0),

            turn_finished: AtomicBool::new(false),

            selected_field: Mutex::default(),

            simple_ai: SimpleAI::new(PlayerColor::White),

            grid: grid.clone(),
            white_player_label,
            black_player_label,
            start_button: start_button.clone(),

            gui,
        });

        start_button.set_callback({
            let weak_grid = Arc::downgrade(&grid);
            let weak_self = Arc::downgrade(&me);

            move || {
                if let Some(grid) = weak_grid.upgrade() {
                    grid.detach(1, 0)?;
                }

                if let Some(me) = weak_self.upgrade() {
                    Self::log("start game", LogSeverity::Debug);

                    *me.state.lock().unwrap() = GameState::Placing;
                    *me.current_player.lock().unwrap() = PlayerColor::Black;

                    me.finish_turn();
                    *me.last_turn_timing.lock().unwrap() = me.engine.time();
                }

                Ok(())
            }
        });

        Ok(me)
    }

    pub fn finish_turn(&self) {
        Self::log(
            &format!("{:?} finished turn", *self.current_player.lock().unwrap()),
            LogSeverity::Debug,
        );

        *self.last_turn_timing.lock().unwrap() = self.engine.time();
        self.turn_finished.store(true, SeqCst);
    }

    fn next_game_step(&self) -> Result<()> {
        {
            let mut state = self.state.lock().unwrap();

            Self::log(
                &format!(" ===== NEW TURN ({:?}) =====", state),
                LogSeverity::Basic,
            );

            match *state {
                GameState::Placing => {
                    if !self
                        .black_stones
                        .lock()
                        .unwrap()
                        .iter()
                        .any(|stones| stones.state == StoneState::ReadyToBePlaced)
                        && !self
                            .white_stones
                            .lock()
                            .unwrap()
                            .iter()
                            .any(|stones| stones.state == StoneState::ReadyToBePlaced)
                    {
                        Self::log("change state to Main", LogSeverity::Debug);
                        *state = GameState::Main;
                    }

                    self.current_player.lock().unwrap().swap();
                }
                GameState::Removing => {
                    if !self
                        .black_stones
                        .lock()
                        .unwrap()
                        .iter()
                        .any(|stones| stones.state == StoneState::ReadyToBePlaced)
                        && !self
                            .white_stones
                            .lock()
                            .unwrap()
                            .iter()
                            .any(|stones| stones.state == StoneState::ReadyToBePlaced)
                    {
                        Self::log("change state to Main", LogSeverity::Debug);
                        *state = GameState::Main;
                    } else {
                        Self::log("change state to Placing", LogSeverity::Debug);
                        *state = GameState::Placing;
                    }

                    self.current_player.lock().unwrap().swap();
                }
                GameState::Main => {
                    self.current_player.lock().unwrap().swap();
                }
                GameState::Waiting => unreachable!(),
            }
        }

        let player = *self.current_player.lock().unwrap();

        Self::log(&format!("current player {:?}", player), LogSeverity::Debug);

        match player {
            PlayerColor::White => {
                self.black_player_label
                    .set_background(Color::try_from("#9b9292")?)?;
                self.white_player_label.set_background(Color::Yellow)?;
            }
            PlayerColor::Black => {
                self.white_player_label
                    .set_background(Color::try_from("#9b9292")?)?;
                self.black_player_label.set_background(Color::Yellow)?;
            }
        }

        if player == self.simple_ai.player_color {
            Self::log("current player is AI", LogSeverity::Debug);

            if !self.simple_ai.step(
                &mut self.stones(self.simple_ai.player_color),
                self.board.lock().unwrap().slots(),
                &mut *self.scene.lock().unwrap(),
                &mut *self.state.lock().unwrap(),
            )? {
                self.finish_turn();
            }
        }

        Self::log("leave next_game_step", LogSeverity::Debug);

        Ok(())
    }

    fn stones(&self, player_color: PlayerColor) -> MutexGuard<'_, [Stone; 9]> {
        match player_color {
            PlayerColor::White => self.white_stones.lock().unwrap(),
            PlayerColor::Black => self.black_stones.lock().unwrap(),
        }
    }

    fn init_nine_stones(engine: &Arc<Engine>, color: Color) -> Result<[EntityObject; 9]> {
        Ok((0..9)
            .map(|_| Self::init_stone(engine, color))
            .collect::<Result<Vec<EntityObject>>>()?
            .try_into()
            .unwrap_or_else(|_: Vec<EntityObject>| {
                unreachable!("create array from vec from an array")
            }))
    }

    fn init_stone(engine: &Arc<Engine>, color: Color) -> Result<EntityObject> {
        let mut marker = engine.assets().empty_entity();

        let draw = Draw::new(vec![{
            let mut mesh = AssetMesh::new(
                engine.device(),
                engine.settings().graphics_info()?.render_type,
            )?;

            let vertex_buffer = Buffer::builder()
                .set_data(&Objects::create_cylinder(1.1, 0.25, 30))
                .set_usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
                .set_memory_usage(MemoryUsage::CpuOnly)
                .build(engine.device().clone())?;

            let a: [f32; 3] = color.into();

            mesh.add_primitive(
                vertex_buffer,
                None,
                None,
                PrimitiveMaterial {
                    color: [a[0], a[1], a[2], 1.0],
                    metallic_factor: 0.2,
                    emissive_factor: [0.2, 0.2, 0.2],
                    roughness_factor: 0.8,
                    alpha_mode: AlphaMode::Opaque,
                    alpha_cut_off: 0.5,
                },
                true,
            )?;

            mesh
        }]);
        marker.insert_component(draw);

        let location = Location::from_entity(&mut marker);
        marker.insert_component(location);

        Ok(marker)
    }

    pub fn place_stone(
        stone: &mut Stone,
        (x, y, z): (usize, usize, usize),
        board: &mut [[[BoardSlot; 3]; 3]; 3],
        player_color: PlayerColor,
        scene: &mut Scene,
        state: &mut GameState,
    ) -> Result<MillState> {
        Self::log("place_stone", LogSeverity::Debug);

        let slot = &board[x][y][z];

        match player_color {
            PlayerColor::White => {
                Self::log(
                    &format!(" ==> white stone placed at {:?}", (x, y, z)),
                    LogSeverity::Basic,
                );

                slot.set_state(BoardSlotState::White(stone.stone));
            }
            PlayerColor::Black => {
                Self::log(
                    &format!(" ==> black stone placed at {:?}", (x, y, z)),
                    LogSeverity::Basic,
                );

                slot.set_state(BoardSlotState::Black(stone.stone));
            }
        }

        stone.state = StoneState::Placed;

        let entity = scene.entity_mut(stone.stone)?;

        let location = entity.get_component_mut::<Location>()?;
        location.set_position(slot.position.extend(0.0));

        let millstate = Self::check_for_mill(&board[x][y][z], board);

        if millstate != MillState::None {
            *state = GameState::Removing;
        }

        Self::log(
            &format!("return place stone with {:?}", millstate),
            LogSeverity::Debug,
        );

        Ok(millstate)
    }

    pub fn move_stone(
        (x, y, z): (usize, usize, usize),
        (tx, ty, tz): (usize, usize, usize),
        scene: &mut Scene,
        board: &mut [[[BoardSlot; 3]; 3]; 3],
        state: &mut GameState,
    ) -> Result<MillState> {
        Self::log(
            &format!("move stone ({:?}) to ({:?})", (x, y, z), (tx, ty, tz)),
            LogSeverity::Debug,
        );

        let slot = &board[x][y][z];
        let neighbour = &board[tx][ty][tz];

        if neighbour.state() != BoardSlotState::Empty {
            Self::log("neighbour not empty", LogSeverity::Debug);
            return Ok(MillState::None);
        }

        neighbour.set_state(slot.state());
        slot.set_state(BoardSlotState::Empty);

        scene
            .entity_mut(match neighbour.state() {
                BoardSlotState::Black(e) => {
                    Self::log(
                        &format!(
                            " ==> black stone moved from {:?} to {:?}",
                            (x, y, z),
                            (tx, ty, tz)
                        ),
                        LogSeverity::Basic,
                    );

                    e
                }
                BoardSlotState::White(e) => {
                    Self::log(
                        &format!(
                            " ==> white stone moved from {:?} to {:?}",
                            (x, y, z),
                            (tx, ty, tz)
                        ),
                        LogSeverity::Basic,
                    );

                    e
                }

                _ => unreachable!(),
            })?
            .get_component_mut::<Location>()?
            .set_position(neighbour.position.extend(0.0));

        let millstate = Self::check_for_mill(&board[tx][ty][tz], board);

        if millstate != MillState::None {
            Self::log("mill found!", LogSeverity::Debug);
            *state = GameState::Removing;
        }

        Self::log(
            &format!("return move stone with {:?}", millstate),
            LogSeverity::Debug,
        );

        Ok(millstate)
    }

    pub fn remove_stone(stone: &mut Stone, slot: &mut BoardSlot, scene: &mut Scene) -> Result<()> {
        Self::log("remove_stone", LogSeverity::Debug);

        let entity = match slot.state() {
            BoardSlotState::Black(e) => {
                Self::log(
                    &format!(
                        " ==> white player removes black stone at {:?}",
                        (slot.x, slot.y, slot.z)
                    ),
                    LogSeverity::Basic,
                );

                e
            }
            BoardSlotState::White(e) => {
                Self::log(
                    &format!(
                        " ==> black player removes white stone at {:?}",
                        (slot.x, slot.y, slot.z)
                    ),
                    LogSeverity::Basic,
                );

                e
            }
            _ => unreachable!(),
        };

        scene.remove_entity(entity)?;

        assert_ne!(stone.state, StoneState::Dead);
        stone.state = StoneState::Dead;

        slot.set_state(BoardSlotState::Empty);

        Ok(())
    }

    fn check_mill(s1: &BoardSlot, s2: &BoardSlot, s3: &BoardSlot) -> MillState {
        if s1.valid() && s2.valid() && s3.valid() {
            if s1.white() && s2.white() && s3.white() {
                return MillState::White;
            } else if s1.black() && s2.black() && s3.black() {
                return MillState::Black;
            }
        }

        MillState::None
    }

    pub fn check_for_mill(slot: &BoardSlot, board: &[[[BoardSlot; 3]; 3]; 3]) -> MillState {
        Self::log("check for mill", LogSeverity::Debug);

        if !(slot.x == 0 && slot.y == 0)
            && !(slot.x == 2 && slot.y == 0)
            && !(slot.x == 0 && slot.y == 2)
            && !(slot.x == 2 && slot.y == 2)
        {
            let state = Self::check_mill(
                &board[slot.x][slot.y][0],
                &board[slot.x][slot.y][1],
                &board[slot.x][slot.y][2],
            );

            if state != MillState::None {
                Self::log(&format!("mill found {:?}", state), LogSeverity::Debug);

                return state;
            }
        }

        let state = Self::check_mill(
            &board[slot.x][0][slot.z],
            &board[slot.x][1][slot.z],
            &board[slot.x][2][slot.z],
        );

        if state != MillState::None {
            Self::log(&format!("mill found {:?}", state), LogSeverity::Debug);

            return state;
        }

        let state = Self::check_mill(
            &board[0][slot.y][slot.z],
            &board[1][slot.y][slot.z],
            &board[2][slot.y][slot.z],
        );

        if state != MillState::None {
            Self::log(&format!("mill found {:?}", state), LogSeverity::Debug);

            return state;
        }

        MillState::None
    }

    fn check_mouse_click<F>(&self, f: F) -> Result<()>
    where
        F: FnOnce(
            &Self,
            (usize, usize, usize),
            &mut [[[BoardSlot; 3]; 3]; 3],
            &mut Scene,
        ) -> Result<()>,
    {
        Self::log("check_mouse_click", LogSeverity::Debug);

        self.scene.lock().unwrap().on_scene(|scene| {
            if let Some(world_space) =
                scene.screen_space_to_world(self.mouse_x.load(SeqCst), self.mouse_y.load(SeqCst))?
            {
                let mut board = self.board.lock().unwrap();

                if let Some(slot) = board.close_to_marker(world_space.truncate()) {
                    Self::log("click is close to marker", LogSeverity::Debug);

                    f(self, (slot.x, slot.y, slot.z), board.slots(), scene)?;
                }
            }

            Ok(())
        })
    }

    fn is_neighbour((x, y, z): (usize, usize, usize), (tx, ty, tz): (usize, usize, usize)) -> bool {
        if (x == tx && y == ty)
            && ((x == 0 && y == 0)
                || (x == 2 && y == 0)
                || (x == 0 && y == 2)
                || (x == 2 && y == 2))
        {
            return false;
        }

        (x as i32 - tx as i32).abs() == 1
            || (y as i32 - ty as i32).abs() == 1
            || (z as i32 - tz as i32).abs() == 1
    }

    pub fn log(s: &str, log_severity: LogSeverity) {
        match (LOG_SEVERITY, log_severity) {
            (LogSeverity::Basic, LogSeverity::Basic) => println!("{}", s),
            (LogSeverity::Basic, LogSeverity::Debug) => (),
            (LogSeverity::Debug, LogSeverity::Basic) => println!("{}", s),
            (LogSeverity::Debug, LogSeverity::Debug) => println!("{}", s),
        }
    }
}

impl EngineObject for MillGame {
    fn name(&self) -> &str {
        "MillGame"
    }

    fn update(&self) -> Result<()> {
        if self.turn_finished.load(SeqCst) {
            if (*self.last_turn_timing.lock().unwrap() + Self::TURN_WAIT_TIME) < self.engine.time()
            {
                self.turn_finished.store(false, SeqCst);
                self.next_game_step()?;
            }
        }

        Ok(())
    }

    fn event(&self, event: EngineEvent) -> Result<()> {
        match event {
            EngineEvent::MouseMotion(x, y) => {
                self.mouse_x.store(x, SeqCst);
                self.mouse_y.store(y, SeqCst);

                self.camera_controls.lock().unwrap().mouse_move(
                    x,
                    y,
                    &mut *self.scene.lock().unwrap(),
                )?;
            }
            EngineEvent::MouseButtonDown(button) => {
                match button {
                    MouseButton::Left => {
                        let mut state = self.state.lock().unwrap();
                        Self::log(
                            &format!("User click at state {:?}", state),
                            LogSeverity::Debug,
                        );

                        match *state {
                            GameState::Placing => {
                                self.check_mouse_click(|me, (x, y, z), board, scene| {
                                    let current_player = *me.current_player.lock().unwrap();

                                    if let Some(placable) = me
                                        .stones(current_player)
                                        .iter_mut()
                                        .find(|stone| stone.state == StoneState::ReadyToBePlaced)
                                    {
                                        if board[x][y][z].is_empty() {
                                            if Self::place_stone(
                                                placable,
                                                (x, y, z),
                                                board,
                                                current_player,
                                                scene,
                                                &mut *state,
                                            )? == MillState::None
                                            {
                                                me.finish_turn();
                                            }
                                        } else {
                                            Self::log(
                                                &format!(
                                                    "slot ({:?}), not empty ({:?})",
                                                    (x, y, z),
                                                    board[x][y][z].state()
                                                ),
                                                LogSeverity::Debug,
                                            );
                                        }
                                    }

                                    Ok(())
                                })?;
                            }
                            GameState::Removing => {
                                self.check_mouse_click(|me, (x, y, z), board, scene| {
                                    let slot = &mut board[x][y][z];

                                    Self::log(
                                        &format!(
                                            "state {:?} - player {:?}",
                                            slot.state(),
                                            *me.current_player.lock().unwrap()
                                        ),
                                        LogSeverity::Debug,
                                    );

                                    if match (slot.state(), *me.current_player.lock().unwrap()) {
                                        (BoardSlotState::Black(_), PlayerColor::White) => true,
                                        (BoardSlotState::White(_), PlayerColor::Black) => true,
                                        _ => false,
                                    } {
                                        let mut stones =
                                            self.stones(me.current_player.lock().unwrap().other());

                                        let stone = stones
                                            .iter_mut()
                                            .find(|s| {
                                                s.stone
                                                    == match slot.state() {
                                                        BoardSlotState::Black(e) => e,
                                                        BoardSlotState::White(e) => e,
                                                        _ => unreachable!(),
                                                    }
                                            })
                                            .unwrap();

                                        Self::remove_stone(stone, slot, scene)?;

                                        me.finish_turn();
                                    }

                                    Ok(())
                                })?;
                            }
                            GameState::Main => {
                                self.check_mouse_click(|me, (tx, ty, tz), board, scene| {
                                    let mut selected_slot = me.selected_field.lock().unwrap();

                                    match *selected_slot {
                                        Some((x, y, z)) => {
                                            if Self::is_neighbour((x, y, z), (tx, ty, tz)) {
                                                if Self::move_stone((x,y,z), (tx,ty,tz), scene, board, &mut state)? == MillState::None {
                                                    *selected_slot = None;
                                                    self.finish_turn();
                                                }
                                            }
                                        }
                                        None => {
                                            let slot = &board[tx][ty][tz];

                                            match (
                                                slot.state(),
                                                *me.current_player.lock().unwrap(),
                                            ) {
                                                (BoardSlotState::Black(_), PlayerColor::Black)
                                                | (BoardSlotState::White(_), PlayerColor::White) => {
                                                    *selected_slot = Some((tx, ty, tz));
                                                }

                                                _ => (),
                                            }
                                        }
                                    }

                                    Ok(())
                                })?;
                            }
                            GameState::Waiting => (),
                        }
                    }
                    MouseButton::Middle => self.camera_controls.lock().unwrap().hold(),
                    MouseButton::Right => (),
                    MouseButton::Forward => (),
                    MouseButton::Backward => (),
                }
            }
            EngineEvent::MouseButtonUp(button) => match button {
                MouseButton::Left => (),
                MouseButton::Middle => self.camera_controls.lock().unwrap().release(),
                MouseButton::Right => (),
                MouseButton::Forward => (),
                MouseButton::Backward => (),
            },
            EngineEvent::MouseWheel(_x, y, direction) => self
                .camera_controls
                .lock()
                .unwrap()
                .scroll_wheel(y, direction, &mut *self.scene.lock().unwrap())?,

            EngineEvent::KeyDown(_) => (),
            EngineEvent::KeyUp(_) => (),
            EngineEvent::ButtonDown(_) => (),
            EngineEvent::ButtonUp(_) => (),
            EngineEvent::ControllerAxis(_) => (),
            EngineEvent::ControllerAdded(_) => (),
            EngineEvent::ControllerRemoved(_) => (),
            EngineEvent::FileDrop(_) => (),
        }

        Ok(())
    }
}