use std::sync::{
    atomic::{AtomicU32, Ordering::SeqCst},
    Arc, Mutex,
};

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 {
    Placing,
    Main,
}

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

impl PlayerColor {
    pub fn swap(&mut self) {
        *self = match *self {
            PlayerColor::White => PlayerColor::Black,
            PlayerColor::Black => PlayerColor::White,
        }
    }
}

pub struct MillGame {
    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,

    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 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 {
            board: Arc::new(Mutex::new(board)),
            white_stones: Mutex::new(white_stones.unwrap()),
            black_stones: Mutex::new(black_stones.unwrap()),

            state: Mutex::new(GameState::Placing),
            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),

            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() {
                    *me.state.lock().unwrap() = GameState::Placing;
                    *me.current_player.lock().unwrap() = PlayerColor::White;

                    me.next_game_step()?;
                }

                Ok(())
            }
        });

        Ok(me)
    }

    fn next_game_step(&self) -> Result<()> {
        match *self.current_player.lock().unwrap() {
            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)?;
            }
        }

        {
            let mut state = self.state.lock().unwrap();

            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)
                    {
                        *state = GameState::Main;
                    }
                }
                GameState::Main => {}
            }
        }

        if *self.current_player.lock().unwrap() == self.simple_ai.player_color {
            match self.simple_ai.player_color {
                PlayerColor::White => self.simple_ai.step(
                    &mut *self.white_stones.lock().unwrap(),
                    self.board.lock().unwrap().slots(),
                    &mut *self.scene.lock().unwrap(),
                )?,
                PlayerColor::Black => self.simple_ai.step(
                    &mut *self.black_stones.lock().unwrap(),
                    self.board.lock().unwrap().slots(),
                    &mut *self.scene.lock().unwrap(),
                )?,
            }

            self.current_player.lock().unwrap().swap();
            self.next_game_step()?;
        }

        Ok(())
    }

    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.0, 0.25, 12))
                .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,
        slot: &mut BoardSlot,
        player_color: PlayerColor,
        scene: &mut Scene,
    ) -> Result<()> {
        match player_color {
            PlayerColor::White => slot.state = BoardSlotState::White(stone.stone),
            PlayerColor::Black => slot.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));

        Ok(())
    }

    pub fn check_for_mill(&self) -> Result<bool> {
        let slots = self.board.lock().unwrap().slots();

        for x in 0..3 {
            for y in 0..3 {
                for z in 0..3 {
                    //
                }
            }
        }
    }
}

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

    fn update(&self) -> Result<()> {
        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 placed = false;

                    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),
                        )? {
                            if let Some(slot) = self
                                .board
                                .lock()
                                .unwrap()
                                .close_to_marker(world_space.truncate())
                            {
                                if let Some(placable) = self
                                    .black_stones
                                    .lock()
                                    .unwrap()
                                    .iter_mut()
                                    .find(|stone| stone.state == StoneState::ReadyToBePlaced)
                                {
                                    Self::place_stone(placable, slot, PlayerColor::Black, scene)?;

                                    placed = true;
                                }
                            }
                        }

                        Ok(())
                    })?;

                    if placed {
                        self.current_player.lock().unwrap().swap();
                        self.next_game_step()?;
                    }
                }
                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(())
    }
}