archy/core/container/src/dependency_resolver.rs

use crate::manifest::{AppManifest, Dependency};
use indexmap::IndexMap;
use std::collections::{HashMap, HashSet};
use thiserror::Error;

#[derive(Debug, Error)]
pub enum DependencyError {
    #[error("Circular dependency detected: {0}")]
    CircularDependency(String),
    #[error("Missing dependency: {0}")]
    MissingDependency(String),
    #[error("Version conflict: {0}")]
    VersionConflict(String),
}

pub struct DependencyResolver {
    manifests: IndexMap<String, AppManifest>,
}

impl DependencyResolver {
    pub fn new() -> Self {
        Self {
            manifests: IndexMap::new(),
        }
    }

    pub fn add_manifest(&mut self, manifest: AppManifest) {
        self.manifests.insert(manifest.app.id.clone(), manifest);
    }

    pub fn resolve_dependencies(&self, app_id: &str) -> Result<Vec<String>, DependencyError> {
        let mut visited = HashSet::new();
        let mut visiting = HashSet::new();
        let mut result = Vec::new();

        self.resolve_recursive(app_id, &mut visited, &mut visiting, &mut result)?;

        // Result is already in installation order (dependencies first)
        Ok(result)
    }

    fn resolve_recursive(
        &self,
        app_id: &str,
        visited: &mut HashSet<String>,
        visiting: &mut HashSet<String>,
        result: &mut Vec<String>,
    ) -> Result<(), DependencyError> {
        if visited.contains(app_id) {
            return Ok(());
        }

        if visiting.contains(app_id) {
            return Err(DependencyError::CircularDependency(format!(
                "Circular dependency detected involving: {}",
                app_id
            )));
        }

        visiting.insert(app_id.to_string());

        let manifest = self.manifests.get(app_id).ok_or_else(|| {
            DependencyError::MissingDependency(format!("App not found: {}", app_id))
        })?;

        // Resolve all dependencies first
        for dep in &manifest.app.dependencies {
            match dep {
                Dependency::App {
                    app_id: dep_id,
                    version: _,
                } => {
                    self.resolve_recursive(dep_id, visited, visiting, result)?;
                }
                Dependency::Storage { storage: _ } => {
                    // Storage dependencies are checked but don't require other apps
                }
                Dependency::Simple(dep_id) => {
                    self.resolve_recursive(dep_id, visited, visiting, result)?;
                }
            }
        }

        visiting.remove(app_id);
        visited.insert(app_id.to_string());

        if !result.contains(&app_id.to_string()) {
            result.push(app_id.to_string());
        }

        Ok(())
    }

    pub fn check_conflicts(&self, app_id: &str) -> Result<(), DependencyError> {
        let manifest = self.manifests.get(app_id).ok_or_else(|| {
            DependencyError::MissingDependency(format!("App not found: {}", app_id))
        })?;

        // Check for port conflicts
        let mut port_usage: HashMap<u16, String> = HashMap::new();

        for (id, m) in &self.manifests {
            if id == app_id {
                continue;
            }

            for port in &m.app.ports {
                if let Some(existing) = port_usage.get(&port.host) {
                    return Err(DependencyError::VersionConflict(format!(
                        "Port {} already used by {}",
                        port.host, existing
                    )));
                }
                port_usage.insert(port.host, id.clone());
            }
        }

        // Check for new app's ports
        for port in &manifest.app.ports {
            if let Some(existing) = port_usage.get(&port.host) {
                return Err(DependencyError::VersionConflict(format!(
                    "Port {} already used by {}",
                    port.host, existing
                )));
            }
        }

        Ok(())
    }

    pub fn calculate_resources(&self, app_ids: &[String]) -> ResourceRequirements {
        let mut total = ResourceRequirements {
            cpu: 0,
            memory_mb: 0,
            disk_gb: 0,
        };

        for app_id in app_ids {
            if let Some(manifest) = self.manifests.get(app_id) {
                if let Some(cpu) = manifest.app.resources.cpu_limit {
                    total.cpu += cpu;
                }

                if let Some(memory) = &manifest.app.resources.memory_limit {
                    // Parse memory string (e.g., "1Gi", "512Mi")
                    if let Ok(mb) = parse_memory(memory) {
                        total.memory_mb += mb;
                    }
                }

                if let Some(disk) = &manifest.app.resources.disk_limit {
                    // Parse disk string (e.g., "10Gi", "500Mi")
                    if let Ok(gb) = parse_disk(disk) {
                        total.disk_gb += gb;
                    }
                }
            }
        }

        total
    }
}

fn parse_memory(s: &str) -> Result<u32, ()> {
    let s = s.trim().to_lowercase();
    if s.ends_with("gi") {
        let num: f64 = s.trim_end_matches("gi").parse().map_err(|_| ())?;
        Ok((num * 1024.0) as u32)
    } else if s.ends_with("mi") {
        let num: f64 = s.trim_end_matches("mi").parse().map_err(|_| ())?;
        Ok(num as u32)
    } else {
        Err(())
    }
}

fn parse_disk(s: &str) -> Result<u32, ()> {
    let s = s.trim().to_lowercase();
    if s.ends_with("gi") {
        let num: f64 = s.trim_end_matches("gi").parse().map_err(|_| ())?;
        Ok(num as u32)
    } else if s.ends_with("ti") {
        let num: f64 = s.trim_end_matches("ti").parse().map_err(|_| ())?;
        Ok((num * 1024.0) as u32)
    } else {
        Err(())
    }
}

#[derive(Debug, Clone)]
pub struct ResourceRequirements {
    pub cpu: u32,
    pub memory_mb: u32,
    pub disk_gb: u32,
}

impl Default for DependencyResolver {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::manifest::{AppDefinition, AppManifest, ContainerConfig};

    fn create_test_manifest(id: &str, deps: Vec<Dependency>) -> AppManifest {
        AppManifest {
            app: AppDefinition {
                id: id.to_string(),
                name: format!("Test {}", id),
                version: "1.0.0".to_string(),
                description: None,
                container: ContainerConfig {
                    image: format!("test/{}:latest", id),
                    image_signature: None,
                    pull_policy: "if-not-present".to_string(),
                },
                dependencies: deps,
                resources: Default::default(),
                security: Default::default(),
                ports: vec![],
                volumes: vec![],
                environment: vec![],
                health_check: None,
                devices: vec![],
                extensions: Default::default(),
            },
        }
    }

    #[test]
    fn test_simple_dependency() {
        let mut resolver = DependencyResolver::new();
        resolver.add_manifest(create_test_manifest("app1", vec![]));
        resolver.add_manifest(create_test_manifest(
            "app2",
            vec![Dependency::Simple("app1".to_string())],
        ));

        let deps = resolver.resolve_dependencies("app2").unwrap();
        assert_eq!(deps, vec!["app1", "app2"]);
    }

    #[test]
    fn test_circular_dependency() {
        let mut resolver = DependencyResolver::new();
        resolver.add_manifest(create_test_manifest(
            "app1",
            vec![Dependency::Simple("app2".to_string())],
        ));
        resolver.add_manifest(create_test_manifest(
            "app2",
            vec![Dependency::Simple("app1".to_string())],
        ));

        let result = resolver.resolve_dependencies("app1");
        assert!(result.is_err());
    }
}