package.rs

use crate::cmd::{
    acl::{CmdAcl, CmdAdminRegister},
    Cmd,
};
use ini::Properties as IniSection;
use matrix_sdk::{room::Joined as JoinedRoom, ruma::UserId};
use std::{convert::TryFrom, fmt};

pub struct CmdPackage {
    name: String,
    acl: CmdAcl,
    admin_register: CmdAdminRegister,

    commands: Vec<Cmd>,
}

impl CmdPackage {
    #[allow(dead_code)]
    pub fn handle(&self, room: &JoinedRoom, user_id: &UserId, user_cmd: Vec<String>) -> String {
        match CmdAcl::action_permited(&self.admin_register, &self.acl, room, user_id) {
            Err(string) => "Action not permited: ".to_string() + &string,
            Ok(()) => match user_cmd.split_first() {
                None => "No command was passed".to_string(),
                Some((name, args)) => match self
                    .commands
                    .iter()
                    .find(|x| x.matches(name, &args.to_vec()))
                {
                    None => "Command not found".to_string(),
                    Some(command) => command.exec(args.to_vec()),
                },
            },
        }
    }

    #[allow(dead_code)]
    pub fn from_config(section: &IniSection, commands: Vec<Cmd>) -> CmdPackage {
        CmdPackage {
            name: section.get("name").unwrap().to_string(),
            acl: CmdAcl::from_string(section.get("acl").unwrap().to_string()),
            admin_register: CmdAdminRegister::from_vec(
                section
                    .get("admins")
                    .unwrap()
                    .split(",")
                    .map(|x| UserId::try_from(x).unwrap())
                    .collect::<Vec<UserId>>(),
            ),
            commands: commands,
        }
    }
}

impl fmt::Display for CmdPackage {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "CmdPackage({}, acls({}), admins({}), commands({}))",
            self.name,
            self.acl,
            self.admin_register,
            match self.commands.len() != 0 {
                true => self
                    .commands
                    .iter()
                    .map(|x| x.get_name().to_string())
                    .reduce(|x1, x2| format!("{}, {}", x1, x2))
                    .unwrap(),
                false => "".to_string(),
            }
        )
    }
}