use std::{fs::{File, read_dir, remove_file, rename}, io::Write, collections::HashMap};
use futures_util::StreamExt;
use reqwest::Client;

use crate::{List, modrinth::Version, db::{userlist_add_disabled_versions, mods_get_title}, config::Cfg, error::{MLE, MLError, ErrorType}};

pub async fn download_versions(list: List, config: Cfg, versions: Vec<Version>) -> MLE<String> {

    let dl_path = String::from(&list.download_folder);

    println!("  └Download mods to {}", dl_path);

    for ver in versions {
        let project_name = mods_get_title(config.clone(), &ver.project_id)?;
        print!("\t└({})Download version {}", project_name, ver.id);
        //Force flush of stdout, else print! doesn't print instantly
        std::io::stdout().flush().unwrap();
        let primary_file = ver.files.into_iter().find(|file| file.primary).unwrap();
        let mut splitname: Vec<&str> = primary_file.filename.split('.').collect();
        let extension = match splitname.pop().ok_or("") {
            Ok(e) => e,
            Err(..) => return Err(MLError::new(ErrorType::Other, "NO_FILE_EXTENSION")),
        };
        let filename = format!("{}.mr.{}.{}.{}", splitname.join("."), ver.project_id, ver.id, extension);
        download_file(primary_file.url, list.clone().download_folder, filename).await?;
        //tokio::time::sleep(std::time::Duration::new(3, 0)).await;
        println!(" ✓");
    }

    Ok(dl_path)
}

async fn download_file(url: String, path: String, name: String) -> MLE<()> {
    let dl_path_file = format!("{}/{}", path, name);
    let res = Client::new()
        .get(String::from(&url))
        .send()
        .await?;

    // download chunks
    let mut file = File::create(&dl_path_file)?;
    let mut stream = res.bytes_stream();

    while let Some(item) = stream.next().await {
        let chunk = item?;
        file.write_all(&chunk)?;
    }

    Ok(())
}

pub fn disable_version(config: Cfg, current_list: List, versionid: String, mod_id: String) -> MLE<()> {
    //println!("Disabling version {} for mod {}", versionid, mod_id);
    let file = get_file_path(current_list.clone(), String::from(&versionid))?;
    let disabled = format!("{}.disabled", file);

    rename(file, disabled)?;

    userlist_add_disabled_versions(config, current_list.id, versionid, mod_id)?;

    Ok(())
}

pub fn delete_version(list: List, version: String) -> MLE<()> {
    let file = get_file_path(list, version)?;
    
    remove_file(file)?;

    Ok(())
}

pub fn get_file_path(list: List, versionid: String) -> MLE<String> {
    let mut names: HashMap<String, String> = HashMap::new();
    for file in read_dir(list.download_folder)? {
        let path = file?.path();
        if path.is_file() {
            let pathstr = match path.to_str().ok_or("") {
                Ok(s) => s,
                Err(..) => return Err(MLError::new(ErrorType::Other, "INVALID_PATH"))
            };
            let namesplit: Vec<&str> = pathstr.split('.').collect();
            let ver_id = namesplit[namesplit.len() - 2];
            names.insert(String::from(ver_id), String::from(pathstr));
        }
    };

    let filename = match names.get(&versionid).ok_or("") {
        Ok(n) => n,
        Err(..) => return Err(MLError::new(ErrorType::ArgumentError, "VERSION_NOT_FOUND_IN_FILES"))
    };
    
    Ok(filename.to_owned())
}

pub fn get_downloaded_versions(list: List) -> MLE<HashMap<String, String>> {
    let mut versions: HashMap<String, String> = HashMap::new();
    for file in read_dir(&list.download_folder)? {
        let path = file?.path();
        if path.is_file() && path.extension().ok_or("BAH").unwrap() == "jar" {
            let pathstr = path.to_str().ok_or("BAH").unwrap();
            let namesplit: Vec<&str> = pathstr.split('.').collect();
            versions.insert(String::from(namesplit[namesplit.len() - 3]), String::from(namesplit[namesplit.len() - 2]));
        }
    }
    Ok(versions)
}

pub fn clean_list_dir(list: &List) -> MLE<()> {
    let dl_path = &list.download_folder;
    println!("  └Clean directory for: {}", list.id);
    for entry in std::fs::read_dir(dl_path)? {
        let entry = entry?;
        std::fs::remove_file(entry.path())?;
    };
    Ok(())
}