use std::convert::{TryFrom, TryInto};

use js_sys::Int16Array;

#[derive(Debug)]
#[wasm_bindgen]
pub enum HangmanError {
    InvalidLetter
}

#[derive(Clone, Copy)]
pub struct InternalLetter(u8);
impl AsRef<u8> for InternalLetter {
    fn as_ref(&self) -> &u8 {
        &self.0
    }
}
impl From<InternalLetter> for u8 {
    fn from(l: InternalLetter) -> Self {
        l.0
    }
}
impl From<InternalLetter> for String {
    fn from(l: InternalLetter) -> Self {
        let u : u8 = l.into();
        let s: String = std::str::from_utf8(&[u]).expect("InternalLetters are always valid utf-8").to_string();
        s
    }
}
impl TryFrom<char> for InternalLetter {
    type Error = HangmanError;
    fn try_from(value: char) -> Result<Self, Self::Error> {
        let mut buf: [u8;4] = [0;4];
        if value.is_ascii_alphabetic() || value == '_' {
            let value = value.to_ascii_uppercase();
            value.encode_utf8(&mut buf);
            let byte : u8 = buf[0];
            assert_eq!(value, byte as char );
            Ok(InternalLetter(byte))
        } else {
            Err(HangmanError::InvalidLetter)
        }
    }
}
impl From<InternalLetter> for char {
    fn from(l: InternalLetter) -> Self {
        l.0 as char
    }
}

#[repr(u8)]
#[wasm_bindgen]

    InProgress

    InProgress,

pub enum GameLetter {
    CorrectGuess(char),
    Unguessed

#[wasm_bindgen(inspectable, readonly)]
#[derive(Clone, Copy)]
pub enum LetterGuessedState {
    CorrectGuess,
    Unguessed,

#[wasm_bindgen(readonly, inspectable)]
#[derive(Clone, Copy)]
pub enum GuessResult {
    Correct,
    Incorrect,
}

fn string_repr<T>(source: &Vec<T>, char_mapper: impl FnMut(&T) -> u8) -> String {
    let entries : Vec<u8> = source.iter().map(char_mapper).collect();
    let entries = entries.as_slice();
    std::str::from_utf8(entries).expect("All chars are valid UTF-8").to_string()
}

struct Game {
    guesses_left: u8,
    current_guesses: Vec<GameLetter>,
    state: GameState,
    word: &'static [char]

#[wasm_bindgen(inspectable)]
pub struct WordLetter {
    #[wasm_bindgen(readonly)]
    pub letter: InternalLetter,
    #[wasm_bindgen(readonly)]
    pub state: LetterGuessedState,

#[wasm_bindgen]
#[derive(Clone)]
pub struct JSGame {
    pub guesses_left: Option<u8>,
    pub current_guesses: JSGuessed,
    pub state: GameState,
    pub word: &'static str

#[wasm_bindgen(inspectable)]
pub struct GuessLetter {
    #[wasm_bindgen(readonly)]
    pub letter: InternalLetter,
    #[wasm_bindgen(readonly)]
    pub state: GuessResult,

#[wasm_bindgen(inspectable)]
pub struct Game {
    #[wasm_bindgen(skip)]
    pub guesses_left: u8,
    current_word: Vec<WordLetter>,
    guesses: Vec<GuessLetter>,
    #[wasm_bindgen(skip)]
    pub state: GameState,
}

#[derive(Clone)]
pub struct JSGuessed(Box<&'static str>);

impl Game {
    #[wasm_bindgen(getter)]
    pub fn guesses_left(&self) -> u8 {
        self.guesses_left
    }

    #[wasm_bindgen(getter)]
    pub fn state(&self) -> GameState {
        self.state
    }

    #[wasm_bindgen(getter)]
    pub fn current_word(&self) -> String {
        match self.state {
            GameState::InProgress => Self::to_in_progress(&self.current_word),
            _ => Self::to_game_end(&self.current_word),
        }
    }

impl<T> From<T> for JSGuessed where T: Iterator<Item = GameLetter> {
    fn from(letters: T) -> Self {
        let chars : Box<String> =  Box::new(letters.map(|l| match l {
            GameLetter::CorrectGuess(c) => c,
            GameLetter::Unguessed => '_',
        }).collect());

    fn to_in_progress(letters: &Vec<WordLetter>) -> String {
        let mapper = |l: &WordLetter| match l {
                WordLetter {letter, state: LetterGuessedState::CorrectGuess } => (u8::from(*letter)),
                WordLetter {state: LetterGuessedState::Unguessed, .. } => b"_"[0],
            };
        string_repr(letters, mapper)
    }

        Self(chars)

    fn to_game_end(letters: &Vec<WordLetter>) -> String {
        let mapper = |l: &WordLetter| l.letter.into();
        string_repr(letters, mapper)
    }
    #[wasm_bindgen(getter)]
    pub fn correct_guesses(&self) -> Box<[JsValue]> {
        let correct: Vec<JsValue> = self
            .guesses
            .iter()
            .filter_map(|g| {
                if let GuessLetter{ letter, state: GuessResult::Correct } = g {
                    let s : String = (*letter).into();
                    let j : JsValue = (*s).into();
                    Some(j)
                } else {
                    None
                }
            })
            .collect();
        correct.into_boxed_slice()

    #[wasm_bindgen(getter, skip_typescript)]
    pub fn incorrect_guesses(&self) -> Box<[JsValue]> {
        let incorrect: Vec<JsValue> = self
            .guesses
            .iter()
            .filter_map(|g| {
                if let GuessLetter{ letter, state: GuessResult::Incorrect } = g {
                    let s : String = (*letter).into();
                    let j : JsValue = (*s).into();
                    Some(j)
                } else {
                    None
                }
            })
            .collect();
        incorrect.into_boxed_slice()
    }

extern {

extern "C" {

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn internal_letter_works_for_letters_and_underscore() -> Result<(), HangmanError> {
        let lower : char = 'a';
        let upper : char = 'Z';
        let under : char = '_';
        let lower_r : InternalLetter = lower.try_into()?;
        assert_eq!("A".to_string(), String::from(lower_r));
        let upper_r : InternalLetter = upper.try_into()?;
        assert_eq!("Z".to_string(), String::from(upper_r));
        let under_r : InternalLetter = under.try_into()?;
        assert_eq!("_".to_string(), String::from(under_r));
        Ok(())
    }
    #[test]
    fn internal_letter_does_not_work_for_digits() {
        let digit = '9';
        assert!(InternalLetter::try_from(digit).is_err());
    }
}

js-sys = "*"

 "js-sys",