use rand::rngs::SmallRng;
use rand::SeedableRng;
use wasm_bindgen::prelude::wasm_bindgen;
use crate::board::Letter;
use crate::constants::{standard_tile_pool, TRAY_LENGTH};
use crate::player_interaction::ai::Difficulty;
use crate::player_interaction::Tray;

pub enum Player {
    Human(String),
    AI{
        name: String,
        difficulty: Difficulty,
    }
}

pub struct PlayerState {
    player: Player,
    score: u32,
    tray: Tray
}

pub struct Game {
    tiles: Vec<Letter>,
    player: PlayerState,
}

// Problem - I want to provide a UI to the player
// Ideally they would get some kind of 'tray' object with methods to use and run
// However I want the main game state to live in Rust, not in JS.
// Does this mean I provide Rc<RefCell<Tray>>?

// Other option - what if I just have one Game object that exposes all methods.
// At no point do they get a Tray reference that auto-updates, they need to handle that
// I just provide read-only JSON of everything, and they call the methods for updates
// This will later work out well when I build it out as an API for multiplayer.

impl Game {
    pub fn new(seed: u64) -> Self {
        let mut rng = SmallRng::seed_from_u64(seed);

        let mut letters = standard_tile_pool(Some(&mut rng));
        let mut tray = Tray::new(TRAY_LENGTH);
        tray.fill(&mut letters);


        let player = PlayerState {
            player: Player::Human("Joel".to_string()),
            score: 0,
            tray,
        };

        Game {
            tiles: letters,
            player,
        }
    }

    pub fn get_tray(&self) -> &Tray {
        &self.player.tray
    }

    pub fn get_tray_mut(&mut self) -> &mut Tray {
        &mut self.player.tray
    }
    
}