use futures_util::StreamExt;
use indicatif::{ProgressBar, ProgressStyle, MultiProgress};
use reqwest::Client;
use tokio::task::JoinSet;
use std::{
    collections::HashMap,
    fs::{copy, read_dir, remove_file, rename, File},
    io::Write, cmp::min,
};

use crate::{
    cache::{copy_cached_version, get_cached_versions},
    config::Cfg,
    db::{mods_get_info, userlist_add_disabled_versions},
    error::{ErrorType, MLError, MLE},
    modrinth::Version,
    List,
};

pub async fn download_versions(list: List, config: Cfg, versions: Vec<Version>) -> MLE<()> {
    let cached = get_cached_versions(&config.cache);

    // println!("{:#?}", cached);

    // println!("  └Download mods to {}", dl_path);
    
    let mp = MultiProgress::new();

    let mut js = JoinSet::new();
    let style = ProgressStyle::with_template("{spinner:.green}{msg}\t[{bar:.green/lime}] {bytes}/{total_bytes}")
        .unwrap()
        .progress_chars("#>-");

    for ver in versions {
        let p = mp.add(ProgressBar::new(1));
        p.set_style(style.clone());
        js.spawn(download_version(config.clone(), list.clone(), ver, cached.clone(), p));
    }

    mp.clear().unwrap();

    while js.join_next().await.is_some() {}

    Ok(())
}

async fn download_version(config: Cfg, list: List, version: Version, mut cached: HashMap<String, String>, progress: ProgressBar) -> MLE<()> {
    let project_info = mods_get_info(config.clone(), &version.project_id)?;

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

    progress.set_message(String::from(&version.id));

    //Check cache if already downloaded
    let c = cached.remove(&version.id);
    if c.is_some() {
        print!(
            "\t└({})Get version {} from cache",
            project_info.title, version.id
        );
        //Force flush of stdout, else print! doesn't print instantly
        std::io::stdout().flush()?;
        copy_cached_version(&c.unwrap(), &dl_path);
        println!(" ✓");
    } else {
        // print!("\t└({})Download version {}", project_info.title, version.id);
        //Force flush of stdout, else print! doesn't print instantly
        std::io::stdout().flush().unwrap();
        let files = version.files;
        let file = match files.clone().into_iter().find(|f| f.primary) {
            Some(f) => f,
            None => files[0].clone()
        };
        let mut splitname: Vec<&str> = 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("."),
            version.project_id,
            version.id,
            extension
        );

        download_file(
            &file.url,
            &list.download_folder,
            &filename,
            &progress
        )
        .await?;
        // println!(" ✓");
        //Copy file to cache
        // print!("\t  └Copy to cache");
        //Force flush of stdout, else print! doesn't print instantly
        std::io::stdout().flush().unwrap();
        let dl_path_file = format!("{}/{}", list.download_folder, filename);
        let cache_path = format!("{}/{}", &config.clone().cache, filename);
        // println!("{}:{}", dl_path_file, cache_path);
        copy(dl_path_file, cache_path)?;
        // println!(" ✓");
    }

    progress.finish_with_message(format!("✓{}", version.id));

    Ok(())
}

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

    let size = res.content_length().expect("Couldn't get content length");

    progress.set_length(size);
    // progress.set_style(ProgressStyle::with_template("{spinner:.green}{msg}\t[{wide_bar:.green/lime}] {bytes}/{total_bytes}").unwrap().progress_chars("#>-"));

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

    let mut downloaded: u64 = 0;

    while let Some(item) = stream.next().await {
        progress.inc(1);
        let chunk = item?;
        file.write_all(&chunk)?;
        
        // Progress bar
        let new = min(downloaded + (chunk.len() as u64), size);
        downloaded = new;
        progress.set_position(new);

        // std::thread::sleep(std::time::Duration::from_millis(100));
    }

    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(())
}