use utilities::prelude::*;

pub const COMMAND_COUNT: usize = 8;

const COMMANDS_TAG: &str = "Commands";
const COMMANDS: [&str; COMMAND_COUNT] = [
    "command_1",
    "command_2",
    "command_3",
    "command_4",
    "command_5",
    "command_6",
    "command_7",
    "command_8",
];

pub struct Config {
    pub commands: [Option<String>; COMMAND_COUNT],
}

impl Config {
    pub fn open(path: &str) -> VerboseResult<Config> {
        let mut config = Config::default();

        let config_loader = match ConfigHandler::read_config(path) {
            Ok(config_loader) => config_loader,
            Err(_) => return Ok(config),
        };

        if let Some(commands) = config_loader.get(COMMANDS_TAG) {
            for i in 0..COMMAND_COUNT {
                if let Some(command) = commands.get(COMMANDS[i]) {
                    config.commands[i] = Some(command.to_value()?);
                }
            }
        }

        Ok(config)
    }

    pub fn save(&self, path: &str) -> VerboseResult<()> {
        let fields = (0..COMMAND_COUNT)
            .collect::<Vec<usize>>()
            .iter()
            .map(|i| {
                (
                    COMMANDS[*i],
                    match &self.commands[*i] {
                        Some(command) => Value::from_value(command),
                        None => Value::empty(),
                    },
                )
            })
            .collect();

        let data = &[(COMMANDS_TAG, fields)];

        ConfigHandler::write_config(path, data)
    }
}

impl Default for Config {
    fn default() -> Config {
        Config {
            commands: Default::default(),
        }
    }
}