use serde::{Deserialize, Serialize};
use serde_wasm_bindgen::Error;
use tsify::Tsify;
use wasm_bindgen::JsValue;
use wasm_bindgen::prelude::wasm_bindgen;
use crate::board::{Board, CellType, Coordinates, Letter};
use crate::game::Game;

#[wasm_bindgen]
pub struct GameWasm(Game);


#[derive(Deserialize, Tsify, Copy, Clone)]
#[tsify(from_wasm_abi)]
pub struct PlayedTile {
    index: usize,
    character: Option<char>,
}

#[wasm_bindgen]
impl GameWasm {

    #[wasm_bindgen(constructor)]
    pub fn new(seed: u64, dictionary_text: &str) -> GameWasm {
        GameWasm(Game::new(seed, dictionary_text))
    }

    pub fn get_tray(&self) -> Result<JsValue, Error> {
        let tray = self.0.get_tray();

        serde_wasm_bindgen::to_value(tray)
    }

    pub fn get_board_cell_types(&self) -> Result<JsValue, Error> {
        let board = self.0.get_board();

        let cell_types: Vec<CellType> = board.cells.iter().map(|cell| -> CellType {
            cell.cell_type.clone()
        }).collect();

        serde_wasm_bindgen::to_value(&cell_types)
    }

    pub fn receive_play(&mut self, tray_tile_locations: JsValue, commit_move: bool) -> Result<JsValue, JsValue> {
        let tray_tile_locations: Vec<Option<PlayedTile>> = serde_wasm_bindgen::from_value(tray_tile_locations)?;

        let mut board_instance = self.0.get_board().clone();
        let tray = self.0.get_tray().clone();

        let mut played_letters: Vec<(Letter, Coordinates)> = Vec::new();
        for (i, played_tile) in tray_tile_locations.iter().enumerate() {
            if played_tile.is_some() {
                let played_tile = played_tile.unwrap();
                let mut letter: Letter = tray.letters.get(i).unwrap().unwrap();

                let coord = Coordinates::new_from_index(played_tile.index);
                if letter.is_blank {
                    match played_tile.character {
                        None => {
                            panic!("You can't play a blank character without providing a letter value")
                        }
                        Some(x) => {
                            // TODO - I should check that the character is a valid letter
                            letter.text = x;
                        }
                    }
                }
                played_letters.push((letter, coord));

            }
        }

        board_instance.receive_play(played_letters)?;

        let result = board_instance.calculate_scores(self.0.get_dictionary())?;

        Ok(serde_wasm_bindgen::to_value(&&result.1).unwrap())

    }
}