use crate::meta_commands::{MetaCommand, MetaCommandExecuteResult};
use crate::statements::{Statement, StatementExecuteResult};
use crate::tokens::{ScanError, Token};

#[derive(Debug)]
pub enum Command {
    MetaCommand(MetaCommand),
    Statement(Statement),
}

#[derive(Debug)]
pub struct CommandExecuteResult {
    pub should_exit: bool,
    msg: String,
}

impl CommandExecuteResult {
    pub fn display(&self) -> String {
        self.msg.to_string()
    }
}

impl From<MetaCommandExecuteResult> for CommandExecuteResult {
    fn from(value: MetaCommandExecuteResult) -> Self {
        Self {
            should_exit: value.should_exit,
            msg: String::new(),
        }
    }
}

impl From<StatementExecuteResult> for CommandExecuteResult {
    fn from(value: StatementExecuteResult) -> Self {
        Self {
            should_exit: false,
            msg: value.msg,
        }
    }
}

impl Command {
    pub fn execute(&self) -> CommandExecuteResult {
        match self {
            Command::MetaCommand(cmd) => cmd.execute().into(),
            Command::Statement(stmt) => stmt.execute().into(),
        }
    }
}

#[derive(Debug)]
pub enum CommandParseError {
    Scan(ScanError),
    UnexpectedToken(Token, &'static [&'static str]),
}

impl From<MetaCommand> for Command {
    fn from(value: MetaCommand) -> Self {
        Command::MetaCommand(value)
    }
}

impl From<Statement> for Command {
    fn from(value: Statement) -> Self {
        Command::Statement(value)
    }
}

impl From<ScanError> for CommandParseError {
    fn from(value: ScanError) -> Self {
        CommandParseError::Scan(value)
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        command::Command, meta_commands::MetaCommand, parser::parse, statements::Statement,
    };
    use insta::{assert_debug_snapshot, assert_snapshot};

    #[test]
    fn test_execute_insert_statement() {
        let statement: Command = Statement::Insert.into();
        let result = statement.execute().display();
        assert_snapshot!(result);
    }

    #[test]
    fn test_execute_select_statement() {
        let statement: Command = Statement::Select.into();
        let result = statement.execute().display();
        assert_snapshot!(result);
    }

    #[test]
    fn test_execute_exit_metacommand() {
        assert_debug_snapshot!(Into::<Command>::into(MetaCommand::Exit).execute());
    }

    #[test]
    fn test_parse_wrong_statement() {
        assert_debug_snapshot!(parse("<stdin>".to_string(), "salact".to_string()));
    }

    #[test]
    fn test_parse_wrong_meta_command() {
        assert_debug_snapshot!(parse("<stdin>".to_string(), ".halp".to_string()));
    }
}