use crate::{
    board::{BoardSlot, BoardSlotState},
    game::{GameState, MillGame, PlayerColor, Stone, StoneState},
};

use anyhow::Result;
use engine::prelude::*;

pub struct SimpleAI {
    pub player_color: PlayerColor,
}

impl SimpleAI {
    pub fn new(player_color: PlayerColor) -> Self {
        Self { player_color }
    }

    pub fn step(
        &self,
        stones: &mut [Stone; 9],
        board: &mut [[[BoardSlot; 3]; 3]; 3],
        scene: &mut SceneHandle,
        state: GameState,
    ) -> Result<()> {
        MillGame::log(&format!("AI at state {:?}", state));

        match state {
            GameState::Placing => {
                if let Some(placable) = stones
                    .iter_mut()
                    .find(|stone| stone.state == StoneState::ReadyToBePlaced)
                {
                    let mut free_slots: Vec<&mut BoardSlot> = board
                        .iter_mut()
                        .flatten()
                        .flatten()
                        .filter(|slot| slot.state == BoardSlotState::Empty)
                        .collect();

                    let len = free_slots.len();

                    let slot = &mut free_slots[Random::range(0, len as u32) as usize];

                    scene.on_scene(|scene| {
                        MillGame::place_stone(placable, slot, self.player_color, scene)?;

                        Ok(())
                    })?;
                }
            }
            GameState::Removing => {
                let mut other_color: Vec<&mut BoardSlot> = board
                    .iter_mut()
                    .flatten()
                    .flatten()
                    .filter(|slot| match (slot.state, self.player_color) {
                        (BoardSlotState::Black(_), PlayerColor::White) => true,
                        (BoardSlotState::White(_), PlayerColor::Black) => true,
                        _ => false,
                    })
                    .collect();

                let len = other_color.len();

                let slot = &mut other_color[Random::range(0, len as u32) as usize];

                scene.on_scene(|scene| {
                    MillGame::remove_stone(slot, scene)?;

                    Ok(())
                })?;
            }
            GameState::Main => todo!(),
        }

        MillGame::log("finish AI");

        Ok(())
    }
}