use std::hash::Hash;
use std::path::{Path, PathBuf};

use serde::{Deserialize, Serialize};

use crate::class::Class;
use crate::prey::{F_PREY_LOCK, F_PREY_TOML, Prey, PreyLock};

pub const DIR_JAVA: &str = "java/";

/// Hashing is only based off the Prey.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PackageHandler {
    prey: Prey,
    prey_lock: PreyLock,
    /// Path relative to WORKSPACE/src
    package_root: PathBuf,
    target_dir: PathBuf,
}

impl PackageHandler {
    pub fn new<P: AsRef<Path>>(src_dir: P, package_root: P, target_dir: P) -> crate::Result<Self> {
        let package_root = src_dir.as_ref().join(package_root.as_ref());
        let prey_lock = if let Ok(prey_lock) = PreyLock::try_from(package_root.join(F_PREY_LOCK)) {
            prey_lock
        } else {
            PreyLock::new(package_root.clone(), package_root.join(DIR_JAVA))?
        };

        Ok(Self {
            prey: Prey::try_from(package_root.join(F_PREY_TOML))?,
            prey_lock,
            package_root,
            target_dir: target_dir.as_ref().to_path_buf(),
        })
    }

    pub fn entry_point(&self) -> PathBuf {
        self.prey.entry_point()
    }

    pub fn name(&self) -> String {
        self.prey.name()
    }

    pub fn version(&self) -> semver::Version {
        self.prey.version()
    }

    pub fn prey_lock(&mut self) -> &mut PreyLock {
        &mut self.prey_lock
    }

    pub fn get_outdated<P: AsRef<Path>>(&self, class_path: P) -> Vec<Class> {
        self.prey_lock
            .clone()
            .classes()
            .iter()
            .filter(|class| {
                class
                    .is_updated(class_path.as_ref())
                    .is_ok_and(|b| b == false)
            })
            .cloned()
            .collect()
    }

    pub fn write_lock(&self) -> crate::Result<()> {
        self.prey_lock.write(self.package_root.as_path())
    }
}

impl Hash for PackageHandler {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.prey.hash(state);
    }
}

/// Data struct
#[derive(Debug, Clone, Deserialize, Serialize, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct Package {
    pub entry_point: PathBuf,
}

//impl Into<Dependency> for Package {}