//! This module consists of endpoints to handle callbacks

crate::export_handlers!(
    decrypt,
    delete,
    delete_message,
    get,
    get_menu,
    alter,
    change_locale
);

use crate::{
    entity::locale::LocaleType,
    errors::{InvalidCommand, handle_error},
    locales::LocaleTypeExt,
};
use base64::{Engine as _, engine::general_purpose::STANDARD_NO_PAD as B64_ENGINE};
use teloxide::types::{CallbackQuery, MaybeInaccessibleMessage};

type NameHash = Vec<u8>;

#[derive(Clone, Copy, PartialEq, Eq)]
pub enum AlterableField {
    Name,
    Login,
    Pass,
}

#[derive(Clone)]
pub enum CallbackCommand {
    DeleteMessage,
    Get(NameHash),
    GetMenu,
    Decrypt(NameHash),
    Alter(NameHash, AlterableField),
    DeleteAccount { name: NameHash, is_command: bool },
    ChangeLocale(LocaleType),
}

impl CallbackCommand {
    pub fn from_query(q: CallbackQuery) -> Option<Self> {
        if !matches!(q.message, Some(MaybeInaccessibleMessage::Regular(_))) {
            return None;
        }
        q.data?.parse().map_err(handle_error).ok()
    }
}

impl std::str::FromStr for CallbackCommand {
    type Err = crate::errors::InvalidCommand;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "delete_message" => return Ok(Self::DeleteMessage),
            "get_menu" => return Ok(Self::GetMenu),
            _ => (),
        };

        let mut substrings = s.split(' ');
        let (Some(command), Some(param), None) =
            (substrings.next(), substrings.next(), substrings.next())
        else {
            return Err(InvalidCommand::InvalidParams);
        };

        if command == "change_locale" {
            let locale =
                LocaleType::from_language_code(param).ok_or(InvalidCommand::UnknownLocale)?;
            return Ok(Self::ChangeLocale(locale));
        }

        let name_hash = B64_ENGINE.decode(param)?;
        if name_hash.len() != 32 {
            return Err(InvalidCommand::InvalidOutputLength);
        }

        match command {
            "get" => Ok(Self::Get(name_hash)),
            "decrypt" => Ok(Self::Decrypt(name_hash)),
            "an" => Ok(Self::Alter(name_hash, AlterableField::Name)),
            "al" => Ok(Self::Alter(name_hash, AlterableField::Login)),
            "ap" => Ok(Self::Alter(name_hash, AlterableField::Pass)),
            "delete0" => Ok(Self::DeleteAccount {
                name: name_hash,
                is_command: false,
            }),
            "delete1" => Ok(Self::DeleteAccount {
                name: name_hash,
                is_command: true,
            }),
            _ => Err(InvalidCommand::InvalidParams),
        }
    }
}