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

use std::{
    collections::HashMap,
    convert::TryFrom,
    ops::{Deref, DerefMut},
};

    InvalidLetter

    InvalidLetter,
    AlreadyGuessed,
    GameOver,
}
impl From<HangmanError> for JsValue {
    fn from(he: HangmanError) -> Self {
        JsValue::from(match he {
            HangmanError::InvalidLetter => "Invalid Letter!",
            HangmanError::AlreadyGuessed => "Already Guessed!",
            HangmanError::GameOver => "Game is over!",
        })
    }

#[derive(Clone, Copy)]

#[derive(Clone, Copy, Hash, PartialEq, Eq)]

        let u : u8 = l.into();
        let s: String = std::str::from_utf8(&[u]).expect("InternalLetters are always valid utf-8").to_string();

        let u: u8 = l.into();
        let s: String = std::str::from_utf8(&[u])
            .expect("InternalLetters are always valid utf-8")
            .to_string();

        let mut buf: [u8;4] = [0;4];

        let mut buf: [u8; 4] = [0; 4];

            let byte : u8 = buf[0];
            assert_eq!(value, byte as char );

            let byte: u8 = buf[0];
            assert_eq!(value, byte as char);

#[derive(Clone, Copy)]

#[derive(Clone, Copy, PartialEq, Eq)]

#[derive(Clone, Copy)]

#[derive(Clone, Copy, PartialEq, Eq)]

#[derive(Clone, Copy)]

#[derive(Clone, Copy, PartialEq, Eq)]

    let entries : Vec<u8> = source.iter().map(char_mapper).collect();

    let entries: Vec<u8> = source.iter().map(char_mapper).collect();

    std::str::from_utf8(entries).expect("All chars are valid UTF-8").to_string()

    std::str::from_utf8(entries)
        .expect("All chars are valid UTF-8")
        .to_string()

#[derive(PartialEq, Eq)]

impl WordLetter {
    pub fn guessed(&self) -> bool {
        self.state == LetterGuessedState::CorrectGuess
    }
}

}
struct WordList {}
impl WordList {
    pub fn select_random_word() -> Word {
        Word(
            "EGGPLANT"
                .chars()
                .map(|c| {
                    let letter =
                        InternalLetter::try_from(c).expect("WordList always uses valid chars");
                    WordLetter {
                        letter,
                        state: LetterGuessedState::Unguessed,
                    }
                })
                .collect(),
        )
    }
}
#[wasm_bindgen]
pub struct Word(Vec<WordLetter>);
impl Deref for Word {
    type Target = Vec<WordLetter>;
    fn deref(&self) -> &Self::Target {
        &self.0
    }

impl DerefMut for Word {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
impl Word {
    pub fn guess(&mut self, guess: &InternalLetter) -> GuessResult {
        let mut guess_result: GuessResult = GuessResult::Incorrect;
        self.iter_mut().for_each(|f| {
            if f.letter == *guess {
                f.state = LetterGuessedState::CorrectGuess;
                guess_result = GuessResult::Correct;
            }
        });
        guess_result
    }
    pub fn completely_guessed(&self) -> bool {
        self.0.iter().all(WordLetter::guessed)
    }
}

    current_word: Vec<WordLetter>,
    guesses: Vec<GuessLetter>,
    #[wasm_bindgen(skip)]
    pub state: GameState,

    current_word: Word,
    guesses: HashMap<InternalLetter, GuessResult>,

    #[wasm_bindgen(constructor)]
    pub fn new() -> Self {
        Self {
            guesses_left: 6,
            guesses: HashMap::with_capacity(15),
            current_word: WordList::select_random_word(),
        }
    }

    #[inline]

        self.state

        if self.guesses_left == 0 {
            GameState::Lost
        } else if self.current_word.completely_guessed() {
            GameState::Won
        } else {
            GameState::InProgress
        }

        match self.state {

        match self.state() {

        }
    }
    #[wasm_bindgen]
    pub fn guess_letter(&mut self, letter: char) -> Result<GameState, HangmanError> {
        let guess = InternalLetter::try_from(letter).or(Err(HangmanError::InvalidLetter))?;
        if self.guesses.get(&guess).is_some() {
            return Err(HangmanError::AlreadyGuessed);
        } else if self.state() != GameState::InProgress {
            return Err(HangmanError::GameOver);
        };
        let result = self.current_word.guess(&guess);
        match result {
            GuessResult::Incorrect => {
                self.guesses_left -= 1;
            }
            GuessResult::Correct => {}

        Ok(self.state())

                WordLetter {letter, state: LetterGuessedState::CorrectGuess } => (u8::from(*letter)),
                WordLetter {state: LetterGuessedState::Unguessed, .. } => b"_"[0],
            };

            WordLetter {
                letter,
                state: LetterGuessedState::CorrectGuess,
            } => (u8::from(*letter)),
            WordLetter {
                state: LetterGuessedState::Unguessed,
                ..
            } => b"_"[0],
        };

            .filter_map(|g| {
                if let GuessLetter{ letter, state: GuessResult::Correct } = g {
                    let s : String = (*letter).into();
                    let j : JsValue = (*s).into();

            .filter_map(|(letter, guess)| {
                if let GuessResult::Correct = guess {
                    let s: String = (*letter).into();
                    let j: JsValue = (*s).into();

            .filter_map(|g| {
                if let GuessLetter{ letter, state: GuessResult::Incorrect } = g {
                    let s : String = (*letter).into();
                    let j : JsValue = (*s).into();

            .filter_map(|(letter, guess)| {
                if let GuessResult::Incorrect = guess {
                    let s: String = (*letter).into();
                    let j: JsValue = (*s).into();

    use std::convert::TryInto;

        let lower : char = 'a';
        let upper : char = 'Z';
        let under : char = '_';

        let lower: char = 'a';
        let upper: char = 'Z';
        let under: char = '_';

        let lower_r : InternalLetter = lower.try_into()?;

        let lower_r: InternalLetter = lower.try_into()?;

        let upper_r : InternalLetter = upper.try_into()?;

        let upper_r: InternalLetter = upper.try_into()?;

        let under_r : InternalLetter = under.try_into()?;

        let under_r: InternalLetter = under.try_into()?;

}

}

pkg