use crate::{modrinth::{versions, extract_current_version, Version, projects, get_raw_versions, project}, config::Cfg, db::{mods_insert, userlist_remove, mods_get_id, userlist_insert, userlist_get_all_ids, userlist_get_current_version, lists_get_all_ids, mods_remove}, input::{Input, ModOptions}, files::{delete_version, download_versions}, List, error::{MLE, ErrorType, MLError}};

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum IDSelector {
    ModificationID(String),
    VersionID(String)
}

pub async fn modification(config: Cfg, input: Input) -> MLE<()> {
    match input.clone().mod_options.ok_or("").unwrap() {
        ModOptions::Add => {
            add(config, input).await
        },
        ModOptions::Remove => {
            remove(config, input)
        },
    }
}

async fn add(config: Cfg, input: Input) -> MLE<()> {

    mods_add(config, vec![input.mod_id.unwrap()], input.list.unwrap(), input.direct_download, input.set_version).await?;

    Ok(())
}

#[derive(Debug, Clone)]
pub struct ProjectInfo {
    pub mod_id: String,
    pub slug: String,
    pub title: String,
    pub current_version: Option<Version>,
    pub applicable_versions: Vec<String>,
    pub download_link: String,
}

pub async fn mods_add(config: Cfg, ids: Vec<IDSelector>, list: List, direct_download: bool, set_version: bool) -> MLE<()> {
    println!("Add mods to {}", list.id);
    println!("  └Add mods:");
    
    let mut mod_ids: Vec<String> = Vec::new();
    let mut ver_ids: Vec<String> = Vec::new();

    //"Sort" project ids from version ids to be able to handle them differently but in a batch
    for id in ids {
        match id {
            IDSelector::ModificationID(pid) => mod_ids.push(pid),
            IDSelector::VersionID(vid) => ver_ids.push(vid),
        }
    }

    let mut projectinfo: Vec<ProjectInfo> = Vec::new();
    if !mod_ids.is_empty() { projectinfo.append(&mut get_mod_infos(config.clone(), mod_ids, list.clone()).await?) };
    if !ver_ids.is_empty() { projectinfo.append(&mut get_ver_info(config.clone(), ver_ids).await?) };

    if projectinfo.is_empty() { return Err(MLError::new(ErrorType::ArgumentError, "NO_IDS?")) };
    
    let mut downloadstack: Vec<Version> = Vec::new();

    //Adding each mod to the lists and downloadstack
    if projectinfo.len() == 1 {
        println!("  └Insert mod in list {} and save infos", list.id);
    } else {
        println!("  └Insert mods in list {} and save infos", list.id);
    }
    
    for project in projectinfo {
        let current_version_id = if project.current_version.is_none() { String::from("NONE") } else { project.current_version.clone().unwrap().id };
        match userlist_insert(config.clone(), &list.id, &project.mod_id, &current_version_id, project.clone().applicable_versions, &project.download_link, set_version) {
            Err(e) => {
                let expected_err = format!("SQL: UNIQUE constraint failed: {}.mod_id", list.id);
                if e.to_string() == expected_err { Err(MLError::new(ErrorType::ModError, "MOD_ALREADY_ON_SELECTED_LIST")) } else { Err(e) }
            },
            Ok(..) => { Ok(..) },
        }?;
        
        match mods_insert(config.clone(), &project.mod_id, &project.slug, &project.title) {
            Err(e) => {
                if e.to_string() == "SQL: UNIQUE constraint failed: mods.id" { Ok(..) } else { Err(e) }
            },
            Ok(..) => Ok(..),
        }?;

        if project.current_version.is_some() { downloadstack.push(project.current_version.unwrap()) };
    }

    //Download all the added mods
    if direct_download { 
        download_versions(list.clone(), config.clone(), downloadstack).await?;
    };

    Ok(())
}

async fn get_mod_infos(config: Cfg, mod_ids: Vec<String>, list: List) -> MLE<Vec<ProjectInfo>> {
    let mut projectinfo: Vec<ProjectInfo> = Vec::new();

    //Get required information from mod_ids
    let m_projects = match mod_ids.len() {
        1 => vec![project(&config.apis.modrinth, &mod_ids[0]).await],
        2.. => projects(&config.apis.modrinth, mod_ids).await,
        _ => panic!("PANIC"),
    };
    for project in m_projects {
        println!("\t└{}", project.title);
        println!("\t  └Get versions");
        let available_versions = versions(&config.apis.modrinth, String::from(&project.id), list.clone()).await;

        let mut available_versions_vec: Vec<String> = Vec::new();
        let current_version: Option<Version>;
        let file: String;
        if !available_versions.is_empty() {
            let current_id = extract_current_version(available_versions.clone())?;
            println!("\t  └Current version: {}", current_id);

            current_version = Some(available_versions.clone().into_iter().find(|v| v.id == current_id).unwrap());

            file = current_version.clone().ok_or("").unwrap().files.into_iter().find(|f| f.primary).unwrap().url;
            for ver in available_versions {
                available_versions_vec.push(ver.id);
            };

            projectinfo.push(ProjectInfo { mod_id: project.id, slug: project.slug, title: project.title, current_version, applicable_versions: available_versions_vec, download_link: file })

        } else {
            println!("\t  └There's currently no mod version for your specified target");
            current_version = None;
            file = String::from("NONE");
            available_versions_vec.push(String::from("NONE"));
            projectinfo.push(ProjectInfo { mod_id: project.id, slug: project.slug, title: project.title, current_version, applicable_versions: available_versions_vec, download_link: file })
        }
    };

    Ok(projectinfo)
}

async fn get_ver_info(config: Cfg, ver_ids: Vec<String>) -> MLE<Vec<ProjectInfo>> {
    let mut projectinfo: Vec<ProjectInfo> = Vec::new();
    
    //Get required information from ver_ids
    let mut v_versions = get_raw_versions(&config.apis.modrinth, ver_ids).await;
    let mut v_mod_ids: Vec<String> = Vec::new();
    for ver in v_versions.clone() {
        v_mod_ids.push(ver.project_id);
    };
    let mut v_projects = projects(&config.apis.modrinth, v_mod_ids).await;
    v_versions.sort_by(|a, b| a.project_id.cmp(&b.project_id));
    v_projects.sort_by(|a, b| a.id.cmp(&b.id));

    for (i, project) in v_projects.into_iter().enumerate() {
        let version = &v_versions[i];
        println!("\t└{}({})", project.title, version.id);
        let file = version.clone().files.into_iter().find(|f| f.primary).unwrap().url;
        projectinfo.push(ProjectInfo { mod_id: project.id, slug: project.slug, title: project.title, current_version: Some(version.clone()), applicable_versions: vec![String::from(&version.id)], download_link: file })
    };
    Ok(projectinfo)
}

fn remove(config: Cfg, input: Input) -> MLE<()> {
    
    let id = match input.clone().mod_id.unwrap() {
        IDSelector::ModificationID(id) => id,
        IDSelector::VersionID(..) => return Err(MLError::new(ErrorType::ArgumentError, "NO_MOD_ID")),
    }; 
    
    let mod_id = mods_get_id(&config.data, &id)?;
    
    let version = userlist_get_current_version(config.clone(), input.clone().list.unwrap().id, String::from(&mod_id))?;

    userlist_remove(config.clone(), input.clone().list.unwrap().id, String::from(&mod_id))?;
    delete_version(input.list.unwrap(), version)?;
    
    let list_ids = lists_get_all_ids(config.clone())?;
    
    let mut mod_used = false;
    for id in list_ids {
        let mods = userlist_get_all_ids(config.clone(), id)?;
        if mods.contains(&mod_id) { mod_used = true; break; };
    };

    if !mod_used { mods_remove(config, mod_id)?; };

    Ok(())
}