use loda_rust_core::parser::{InstructionId, ParseInstructionId};
use std::fmt;

#[derive(Hash, Eq, PartialEq, Debug, Clone, Copy)]
pub enum Word {
    ProgramStart,
    ProgramStop,
    Instruction(InstructionId)
}

impl Word {
    pub fn parse(raw: &str) -> Option<Word> {
        match raw {
            "START" => {
                return Some(Word::ProgramStart);
            },
            "STOP" => {
                return Some(Word::ProgramStop);
            },
            _ => {}
        }
        match InstructionId::parse(raw, 1) {
            Ok(instruction_id) => {
                return Some(Word::Instruction(instruction_id));
            },
            Err(_) => {
                return None;
            }
        }
    }
}

impl fmt::Display for Word {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::ProgramStart => write!(f, "START"),
            Self::ProgramStop => write!(f, "STOP"),
            Self::Instruction(instruction) => write!(f, "{}", instruction)
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn parse(input: &str) -> String {
        match Word::parse(input) {
            Some(word) => word.to_string(),
            None => "NONE".to_string()
        }
    }

    #[test]
    fn test_10000_parse_success() {
        assert_eq!(parse("START"), "START");
        assert_eq!(parse("STOP"), "STOP");
        assert_eq!(parse("mov"), "mov");
        assert_eq!(parse("add"), "add");
    }

    #[test]
    fn test_10001_parse_unrecognized() {
        assert_eq!(parse(""), "NONE");
        assert_eq!(parse("unrecognized"), "NONE");
        assert_eq!(parse("junk"), "NONE");
        assert_eq!(parse("start"), "NONE");
        assert_eq!(parse("stop"), "NONE");
        assert_eq!(parse("MOV"), "NONE");
        assert_eq!(parse("ADD"), "NONE");
    }
}