use rand::seq::SliceRandom;
use rhai::{
    serde::{from_dynamic, to_dynamic},
    Dynamic, Engine, Func, Map, RegisterResultFn, AST,
};
use serde::{Deserialize, Serialize};

use std::collections::HashMap;

use super::config::{Config, Pile};

fn shuffle_pile(pile: Map) -> Result<Dynamic, Box<rhai::EvalAltResult>> {
    let mut pile = Pile::from_rhai_map(pile)?;
    let mut rng = rand::thread_rng();
    pile.cards.shuffle(&mut rng);
    to_dynamic(pile)
}


#[derive(Debug, Serialize, Deserialize, Clone)]
struct Setup {
    piles: HashMap<String, Pile>,
    player_piles: Vec<HashMap<String, Pile>>,
    players: u32,
}

pub struct RunningGame {
    piles: HashMap<String, Pile>,
    player_piles: Vec<HashMap<String, Pile>>,
}

impl RunningGame {
    pub fn new(ast: AST, conf: &Config, players: u32) -> Self {
        let mut engine = Engine::new();
        engine.register_result_fn("shuffle", shuffle_pile);
        let setup = Func::<(Dynamic,), Dynamic>::create_from_ast(engine, ast, "setup");

        let piles = conf.piles.clone();
        let player_piles = vec![conf.player_piles.clone(); players as usize];
        let Setup {
            piles,
            player_piles,
            players: _,
        } = from_dynamic(
            &setup(
                to_dynamic(Setup {
                    piles,
                    player_piles,
                    players,
                })
                .unwrap(),
            )
            .unwrap(),
        )
        .unwrap();
        Self {
            piles,
            player_piles,
        }
        // Self {setup: Box::new(Func::<(Vec<Pile>, Vec<Vec<Pile>>), ()>::create_from_ast(engine, ast, "setup"))}
    }

    // pub fn setup(&self) {
    // 	(self.setup)().unwrap()
    // }
}