use std::collections::HashSet;
use std::error::Error;
use std::fmt::{Debug, Display, Formatter};
use std::path::{Path, PathBuf};
use std::sync::Arc;
use futures::{stream, StreamExt, TryStreamExt};
use log::{debug, info, warn};
use tokio::{fs, io, io::ErrorKind};
use tokio::fs::File;
use tokio::io::AsyncWriteExt;

mod arch;
mod manifest;

use arch::JRE_ARCH;
use manifest::JavaRuntimesManifest;
use manifest::JavaRuntimeManifest;
use crate::launcher::jre::manifest::JavaRuntimeFile;
use crate::util;
use crate::util::{EnsureFileError, FileVerifyError, IntegrityError};
use crate::version::DownloadInfo;
use super::constants;

pub struct JavaRuntimeRepository {
    online: bool,
    home: PathBuf,
    manifest: JavaRuntimesManifest
}

impl JavaRuntimeRepository {
    pub async fn new(home: impl AsRef<Path>, online: bool) -> Result<Self, JavaRuntimeError> {
        info!("Java runtime architecture is \"{}\".", JRE_ARCH);

        fs::create_dir_all(&home).await.map_err(|e| JavaRuntimeError::IO { what: "creating home directory", error: e })?;

        let manifest_path = home.as_ref().join("manifest.json");
        match util::ensure_file(manifest_path.as_path(), Some(constants::URL_JRE_MANIFEST), None, None, online, true).await {
            Ok(_) => (),
            Err(EnsureFileError::Offline) => {
                info!("Launcher is offline, cannot download runtime manifest.");
            },
            Err(e) => return Err(JavaRuntimeError::EnsureFile(e))
        };

        let manifest_file = fs::read_to_string(&manifest_path).await
            .map_err(|e| JavaRuntimeError::IO { what: "reading runtimes manifest", error: e })?;

        Ok(JavaRuntimeRepository {
            online,
            home: home.as_ref().to_path_buf(),
            manifest: serde_json::from_str(&manifest_file).map_err(|e| JavaRuntimeError::Deserialize { what: "runtimes manifest", error: e })?,
        })
    }

    fn get_component_dir(&self, component: &str) -> PathBuf {
        [self.home.as_path(), Path::new(JRE_ARCH), Path::new(component)].into_iter().collect()
    }

    async fn load_runtime_manifest(&self, component: &str, info: &DownloadInfo) -> Result<JavaRuntimeManifest, JavaRuntimeError> {
        let comp_dir = self.get_component_dir(component);
        let manifest_path = comp_dir.join("manifest.json");

        debug!("Ensuring manifest for runtime {JRE_ARCH}.{component}");

        fs::create_dir_all(comp_dir.as_path()).await
            .inspect_err(|e| warn!("Failed to create directory for JRE component {}: {}", component, e))
            .map_err(|e| JavaRuntimeError::IO { what: "creating component directory", error: e })?;

        util::ensure_file(&manifest_path, info.url.as_ref().map(|s| s.as_str()), info.size, info.sha1, self.online, false).await
            .map_err(JavaRuntimeError::EnsureFile)?;

        let manifest_file = fs::read_to_string(&manifest_path).await
            .map_err(|e| JavaRuntimeError::IO { what: "reading runtimes manifest", error: e })?;

        Ok(serde_json::from_str(&manifest_file).map_err(|e| JavaRuntimeError::Deserialize { what: "runtime manifest", error: e })?)
    }

    // not very descriptive function name
    pub async fn choose_runtime(&self, component: &str) -> Result<JavaRuntimeManifest, JavaRuntimeError> {
        let Some(runtime_components) = self.manifest.get(JRE_ARCH) else {
            return Err(JavaRuntimeError::UnsupportedArch(JRE_ARCH));
        };

        let Some(runtime_component) = runtime_components.get(component) else {
            return Err(JavaRuntimeError::UnsupportedComponent { arch: JRE_ARCH, component: component.to_owned() });
        };

        let Some(runtime) = runtime_component.iter().filter(|r| r.availability.progress == 100).next() else {
            if !runtime_components.is_empty() {
                warn!("Weird: the only java runtimes in {JRE_ARCH}.{component} has a progress of less than 100!");
            }

            return Err(JavaRuntimeError::UnsupportedComponent { arch: JRE_ARCH, component: component.to_owned() });
        };

        self.load_runtime_manifest(component, &runtime.manifest).await
    }

    fn clean_up_runtime_sync(path: &Path, manifest: Arc<JavaRuntimeManifest>) -> Result<(), io::Error> {
        for entry in walkdir::WalkDir::new(path).contents_first(true) {
            let entry = entry?;

            if !entry.path().strip_prefix(path)
                .expect("walkdir escaped root (???)")
                .to_str().map_or(None, |s| manifest.files.get(s))
                .is_none_or(|f| (f.is_file() != entry.file_type().is_file())
                    || (f.is_directory() != entry.file_type().is_dir())
                    || (f.is_link() != entry.file_type().is_symlink())) {
                // path is invalid utf-8, extraneous, or of the wrong type
                debug!("File {} is extraneous or of wrong type ({:?}). Deleting it.", entry.path().display(), entry.file_type());

                if entry.file_type().is_dir() {
                    std::fs::remove_dir(entry.path())?;
                } else {
                    std::fs::remove_file(entry.path())?;
                }
            }
        }

        Ok(())
    }

    async fn clean_up_runtime(path: &Path, manifest: Arc<JavaRuntimeManifest>) -> Result<(), io::Error> {
        let (tx, rx) = tokio::sync::oneshot::channel();

        let path = path.to_owned();
        let manifest = manifest.clone();

        tokio::task::spawn_blocking(move || {
            let res = Self::clean_up_runtime_sync(&path, manifest);
            let _ = tx.send(res);
        }).await.expect("clean_up_runtime_sync panicked");

        rx.await.expect("clean_up_runtime_sync hung up")
    }

    async fn ensure_jre_dirs(&self, path: &Path, manifest: &JavaRuntimeManifest) -> Result<(), JavaRuntimeError> {
        stream::iter(manifest.files.iter().filter(|(_, f)| f.is_directory()))
            .map::<Result<_, JavaRuntimeError>, _>(|(name, _)| Ok(async move {
                let ent_path = util::check_path(name).map_err(JavaRuntimeError::MalformedManifest)?;
                let ent_path = [path, ent_path].into_iter().collect::<PathBuf>();

                match fs::metadata(&ent_path).await {
                    Ok(meta) => {
                        if !meta.is_dir() {
                            debug!("Deleting misplaced file at {}", ent_path.display());
                            fs::remove_file(&ent_path).await.map_err(|e| JavaRuntimeError::IO {
                                what: "deleting misplaced file",
                                error: e
                            })?;
                        }
                    },
                    Err(e) if e.kind() == ErrorKind::NotFound => (),
                    Err(e) => return Err(JavaRuntimeError::IO { what: "'stat'ing directory", error: e })
                }

                match fs::create_dir(&ent_path).await {
                    Ok(_) => {
                        debug!("Created directory at {}", ent_path.display());
                        Ok(())
                    },
                    Err(e) if e.kind() == ErrorKind::AlreadyExists => Ok(()),
                    Err(e) => {
                        warn!("Could not create directory {} for JRE!", ent_path.display());
                        return Err(JavaRuntimeError::IO { what: "creating directory", error: e });
                    }
                }
            }))
            .try_buffer_unordered(32)
            .try_fold((), |_, _| async { Ok(()) }).await
    }

    async fn ensure_jre_files(path: &Path, manifest: &JavaRuntimeManifest) -> Result<(), JavaRuntimeError> {
        stream::iter(manifest.files.iter().filter(|(_, f)| f.is_file()))
            .map(|(name, file)| Ok(async move {

            }));

        todo!()
    }

    async fn ensure_jre(&self, component: &str, manifest: JavaRuntimeManifest) -> Result<(), JavaRuntimeError> {
        let runtime_path = self.get_component_dir(component);
        let runtime_path = runtime_path.join("runtime");
        let manifest = Arc::new(manifest);

        fs::create_dir_all(&runtime_path).await
            .map_err(|e| JavaRuntimeError::IO { what: "creating runtime directory", error: e })?;

        debug!("Cleaning up JRE directory for {component}");
        Self::clean_up_runtime(runtime_path.as_path(), manifest).await
            .map_err(|e| JavaRuntimeError::IO { what: "cleaning up runtime directory", error: e })?;

        debug!("Building directory structure for {component}");
        self.ensure_jre_dirs(&runtime_path, manifest.as_ref()).await?;



        todo!()
    }
}

#[derive(Debug)]
pub enum JavaRuntimeError {
    EnsureFile(EnsureFileError),
    IO { what: &'static str, error: io::Error },
    Download { what: &'static str, error: reqwest::Error },
    Deserialize { what: &'static str, error: serde_json::Error },
    UnsupportedArch(&'static str),
    UnsupportedComponent { arch: &'static str, component: String },
    MalformedManifest(&'static str),
    Integrity(IntegrityError)
}

impl Display for JavaRuntimeError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            JavaRuntimeError::EnsureFile(e) => std::fmt::Display::fmt(e, f),
            JavaRuntimeError::IO { what, error } => write!(f, "i/o error ({}): {}", what, error),
            JavaRuntimeError::Download { what, error } => write!(f, "error downloading {}: {}", what, error),
            JavaRuntimeError::Deserialize { what, error } => write!(f, "error deserializing ({what}): {error}"),
            JavaRuntimeError::UnsupportedArch(arch) => write!(f, r#"unsupported architecture "{arch}""#),
            JavaRuntimeError::UnsupportedComponent { arch, component } => write!(f, r#"unsupported component "{component}" for architecture "{arch}""#),
            JavaRuntimeError::MalformedManifest(what) => write!(f, "malformed runtime manifest: {what} (launcher bug?)"),
            JavaRuntimeError::Integrity(e) => std::fmt::Display::fmt(e, f)
        }
    }
}

impl Error for JavaRuntimeError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            JavaRuntimeError::EnsureFile(error) => Some(error),
            JavaRuntimeError::IO { error, .. } => Some(error),
            JavaRuntimeError::Download { error, .. } => Some(error),
            JavaRuntimeError::Deserialize { error, .. } => Some(error),
            JavaRuntimeError::Integrity(error) => Some(error),
            _ => None
        }
    }
}