use std::io::{Error, ErrorKind};

use crate::{db::{insert_list, remove_list, change_list, get_lists, get_current_list_id, get_list}, Modloader, config::Cfg, input::Input};

#[derive(Clone)]
pub struct List {
    pub id: String,
    pub mc_version: String,
    pub modloader: Modloader,
}

pub fn list(config: Cfg, args: Option<Vec<String>>) -> Result<(), Box<dyn std::error::Error>> {

    if args.is_none() {
        let lists = get_lists(config.clone())?;
        let current_list = get_current_list_id(config)?;
        println!("Your lists:\n{}\n-----\nCurrently selected list: \"{}\"", lists.join(",\n"), current_list);
        return Ok(());
    }

    let arguments = Input::from(args.unwrap().join(" "))?;

    if arguments.args.is_none() { return Err(Box::new(Error::new(ErrorKind::InvalidInput, "TOO_FEW_ARGUMENTS"))); };

    match arguments.command.as_str() {
        "add" => {
            add(config, arguments.args.unwrap())
        },
        "change" => {
            change(config, arguments.args.unwrap())
        },
        "remove" => {
            remove(config, arguments.args.unwrap())
        },
        _ => Err(Box::new(Error::new(ErrorKind::InvalidInput, "UNKNOWN_SUBCOMMAND")))
    }
}

pub fn get_current_list(config: Cfg) -> Result<List, Box<dyn std::error::Error>> {
    let id = get_current_list_id(config.clone())?;
    get_list(config, id)
}

fn add(config: Cfg, args: Vec<String>) -> Result<(), Box<dyn std::error::Error>> {
    match args.len() {
        1 | 2 => Err(Box::new(Error::new(ErrorKind::InvalidInput, "TOO_FEW_ARGUMENTS"))),
        3 => {
            let id = String::from(&args[0]);
            let mc_version = String::from(&args[1]);
            let mod_loader = match args[2].as_str() {
                "forge" => Modloader::Forge,
                "fabric" => Modloader::Fabric,
                _ => return Err(Box::new(Error::new(ErrorKind::InvalidInput, "UNKNOWN_MODLOADER")))
            };
            match insert_list(config, id, mc_version, mod_loader) {
                Err(err) => { Err(Box::new(err)) },
                Ok(()) => Ok(()),
            }
        },
        5.. => Err(Box::new(Error::new(ErrorKind::InvalidInput, "TOO_MANY_ARGUMENTS"))),
        _ => panic!("list arguments should never be zero or lower"),
    }
}

fn change(config: Cfg, args: Vec<String>) -> Result<(), Box<dyn std::error::Error>> {
    let lists = get_lists(config.clone())?;
    match args.len() {
        1 => {
            let list = String::from(&args[0]);
            if !lists.contains(&list) { return Err(Box::new(Error::new(ErrorKind::NotFound, "LIST_DOESNT_EXIST"))); };
            match change_list(config, list) {
                Err(err) => { Err(Box::new(err)) },
                Ok(()) => Ok(()),
            }
        },
        2.. => Err(Box::new(Error::new(ErrorKind::InvalidInput, "TOO_MANY_ARGUMENTS"))),
        _ => panic!("list arguments should never be zero or lower"),
    }
}

fn remove(config: Cfg, args: Vec<String>) -> Result<(), Box<dyn std::error::Error>> {
    match args.len() {
        1 => {
            match remove_list(config, String::from(&args[0])) {
                Err(err) => { Err(Box::new(err)) },
                Ok(()) => Ok(()),
            }
        },
        2.. => Err(Box::new(Error::new(ErrorKind::InvalidInput, "TOO_MANY_ARGUMENTS"))),
        _ => panic!("list arguments should never be zero or lower"),
    }
}