use logos::Logos;
use super::session::ReportMode;

#[derive(Logos, Debug, PartialEq)]
enum Token {
    #[end]
    End,
    #[error]
    Error,

    #[token = "Quit"]
    Quit,
    #[token = "show"]
    Show,
    #[token = "channel"]
    Channel,
    #[token = "report"]
    Report,
    #[token = "mode"]
    Mode,
    #[token = "off"]
    Off,
    #[token = "once"]
    Once,
    #[token = "continuous"]
    Continuous,
    #[token = "enable"]
    Enable,
    #[token = "disable"]
    Disable,

    #[regex = "[0-9]+"]
    Number,
}

#[derive(Debug)]
pub enum Error {
    Parser,
    UnexpectedEnd,
    UnexpectedToken(Token),
    NoSuchChannel,
}

#[derive(Debug)]
pub enum ShowCommand {
    ReportMode,
}


#[derive(Debug)]
pub enum ChannelCommand {
    Enable,
    Disable,
}

#[derive(Debug)]
pub enum Command {
    Quit,
    Show(ShowCommand),
    Report(ReportMode),
    Channel(u8, ChannelCommand),
}

const CHANNEL_IDS: &'static [&'static str] = &[
    "0", "1", "2", "3",
];

impl Command {
    pub fn parse(input: &str) -> Result<Self, Error> {
        let mut lexer = Token::lexer(input);

        macro_rules! choice {
            [$($token: tt => $block: stmt,)*] => {
                match lexer.token {
                    $(
                        Token::$token => {
                            lexer.advance();
                            $block
                        }
                    )*
                    Token::End => Err(Error::UnexpectedEnd),
                    _ => Err(Error::UnexpectedToken(lexer.token))
                }
            }
        }

        choice![
            Quit => Ok(Command::Quit),
            Report => choice![
                Mode => choice![
                    End => Ok(Command::Show(ShowCommand::ReportMode)),
                    Off => Ok(Command::Report(ReportMode::Off)),
                    Once => Ok(Command::Report(ReportMode::Once)),
                    Continuous => Ok(Command::Report(ReportMode::Continuous)),
                ],
                End => Ok(Command::Report(ReportMode::Once)),
            ],
            Channel => choice![
                Number => {
                    let channel = CHANNEL_IDS.iter()
                        .position(|id| *id == lexer.slice());
                    match channel {
                        Some(channel) => {
                            choice![
                                Enable => Ok(Command::Channel(
                                    channel as u8,
                                    ChannelCommand::Enable
                                )),
                                Disable => Ok(Command::Channel(
                                    channel as u8,
                                    ChannelCommand::Disable
                                )),
                            ]
                        }
                        None => Err(Error::NoSuchChannel)
                    }
                },
            ],
        ]
    }
}