use bevy::prelude::*;
use strum::{EnumCount, FromRepr};

use crate::{
    EnumNextCycle,
    game::{
        hand::{Drawn, Hand},
        player::{MainPlayer, Player},
        round::{CurrentPlayer, TurnState, Wind},
        wall::Wall,
    },
    tile::{self, *},
};

pub mod hand;
pub mod player;
pub mod round;
pub mod wall;

#[derive(States, Default, Hash, Clone, Eq, Debug, PartialEq, Copy)]
pub enum GameState {
    #[default]
    None,
    Setup,
    Deal,
    Play,
}

pub struct Riichi;
impl Plugin for Riichi {
    fn build(&self, app: &mut App) {
        app
            // start stopper
            .init_state::<GameState>()
            .add_sub_state::<TurnState>()
            .init_resource::<round::MatchSettings>()
            .init_resource::<round::Compass>()
            .add_systems(Startup, tile::init_tiles)
            .add_systems(OnEnter(GameState::Setup), setup)
            .add_systems(OnEnter(GameState::Deal), hand::shuffle_deal)
            .add_systems(Update, hand::sort_hands.run_if(in_state(GameState::Play)))
            // .add_systems(Update, turn_manager.run_if(in_state(GameState::Play)))
            .add_systems(OnEnter(TurnState::Tsumo), tsumo)
            // semicolon stopper
            ;
    }
}

// struct TurnEvent {
//     pub next: Option<Entity>,
//     pub prev: Option<Entity>,
// }

// fn turn_manager() {}

fn tsumo(
    mut commands: Commands,
    curr_player: Res<CurrentPlayer>,
    // players: Populated<Entity, With<Player>>,
    wall_ent: Single<Entity, With<Wall>>,
    walltiles: Single<&Children, With<Wall>>,
    curr_turnstate: Res<State<TurnState>>,
    mut next_turnstate: ResMut<NextState<TurnState>>,
) {
    trace!("tsumo for: {:?}", curr_player.0);

    let drawn = walltiles.last().unwrap();
    commands.entity(*wall_ent).remove_child(*drawn);
    commands.entity(curr_player.0).insert(Drawn(*drawn));

    debug!("wall: {:?}", *walltiles);

    next_turnstate.set(curr_turnstate.next());
}

pub(crate) fn setup(
    mut commands: Commands,
    matchsettings: Res<round::MatchSettings>,
    // mut compass: ResMut<Compass>
    tiles: Query<Entity, With<Tile>>,
    mut next_gamestate: ResMut<NextState<GameState>>,
) {
    for i in 1..=matchsettings.player_count {
        let player = player::Player {
            name: format!("Player {}", i),
        };
        let points = player::Points(matchsettings.starting_points);

        let bundle = (
            player,
            points,
            Hand,
            Wind::from_repr((i - 1) as usize).unwrap(),
        );

        if i == 1 {
            let player = commands.spawn((bundle, MainPlayer)).id();
            commands.insert_resource(CurrentPlayer(player));
        } else {
            commands.spawn(bundle);
        }
    }

    commands.spawn(Wall);

    next_gamestate.set(GameState::Deal);
}