use crate::{
    destination::{Destination, resolve_variables},
    sexpr::Node,
};
use anyhow::{Context, Result, bail};
use sha2::{Digest, Sha256};
use std::{
    collections::{BTreeMap, BTreeSet},
    path::{Path, PathBuf},
};
use walkdir::WalkDir;

#[derive(Debug, Default)]
pub struct ModelPlan {
    pub copies: Vec<(PathBuf, Vec<u8>)>,
    pub messages: Vec<String>,
}

fn supported(path: &Path) -> bool {
    path.extension()
        .and_then(|e| e.to_str())
        .is_some_and(|e| matches!(e.to_ascii_lowercase().as_str(), "step" | "stp" | "wrl"))
}
fn digest(bytes: &[u8]) -> String {
    format!("{:x}", Sha256::digest(bytes))
}
fn reference_parts(reference: &str) -> Vec<String> {
    reference
        .replace('\\', "/")
        .split('/')
        .filter(|s| !s.is_empty() && *s != ".")
        .map(|s| s.to_ascii_lowercase())
        .collect()
}
fn suffix_score(path: &Path, reference: &[String]) -> usize {
    let parts = reference_parts(&path.to_string_lossy());
    parts
        .iter()
        .rev()
        .zip(reference.iter().rev())
        .take_while(|(a, b)| a == b)
        .count()
}

// KIPRJMOD belongs to the footprint's source project when copying a
// registered project library into another project. The target project is only
// the fallback for fresh bundle imports without discoverable source context.
fn source_project(source: &Path) -> Option<PathBuf> {
    for directory in source.parent()?.ancestors() {
        let Ok(entries) = std::fs::read_dir(directory) else {
            continue;
        };
        if entries.filter_map(Result::ok).any(|entry| {
            entry
                .path()
                .extension()
                .is_some_and(|ext| ext == "kicad_pro")
                && entry.path().is_file()
        }) {
            return Some(directory.to_path_buf());
        }
    }
    None
}

/// Resolve an original path first; otherwise rank recursive bundle/search-root
/// matches by trailing path components. Equal-content candidates collapse safely.
pub fn model_candidates(
    reference: &str,
    source_footprint: &Path,
    source_root: &Path,
    search_roots: &[PathBuf],
    variables: &BTreeMap<String, String>,
    project: Option<&Path>,
) -> Result<Vec<PathBuf>> {
    let source_project = source_project(source_footprint);
    let project = source_project.as_deref().or(project);
    let normalized = reference.replace('\\', "/");
    if let Ok(expanded) = resolve_variables(&normalized, project, variables) {
        let path = PathBuf::from(&expanded);
        let direct = if path.is_absolute() {
            path
        } else {
            source_footprint.parent().unwrap_or(source_root).join(path)
        };
        if direct.is_file() && supported(&direct) {
            return Ok(vec![direct]);
        }
        let bundled = source_root.join(expanded.trim_start_matches('/'));
        if bundled.is_file() && supported(&bundled) {
            return Ok(vec![bundled]);
        }
    }
    let parts = reference_parts(&normalized);
    let Some(filename) = parts.last() else {
        return Ok(vec![]);
    };
    let mut roots = vec![source_root.to_path_buf()];
    roots.extend_from_slice(search_roots);
    let mut candidates = BTreeSet::new();
    let mut best_score = 0;
    for root in roots {
        if !root.exists() {
            continue;
        }
        if root.is_file() {
            if supported(&root)
                && root
                    .file_name()
                    .is_some_and(|s| s.to_string_lossy().eq_ignore_ascii_case(filename))
            {
                let score = suffix_score(&root, &parts);
                if score > best_score {
                    candidates.clear();
                    best_score = score;
                }
                if score == best_score {
                    candidates.insert(root.canonicalize()?);
                }
            }
            continue;
        }
        for entry in WalkDir::new(&root).follow_links(false) {
            let entry =
                entry.with_context(|| format!("Search model files in {}", root.display()))?;
            if !entry.file_type().is_file() || !supported(entry.path()) {
                continue;
            }
            if !entry
                .file_name()
                .to_string_lossy()
                .eq_ignore_ascii_case(filename)
            {
                continue;
            }
            let score = suffix_score(entry.path(), &parts);
            if score > best_score {
                candidates.clear();
                best_score = score;
            }
            if score == best_score {
                candidates.insert(entry.path().canonicalize()?);
            }
        }
    }
    let mut unique = BTreeMap::new();
    for candidate in candidates {
        let bytes = std::fs::read(&candidate)
            .with_context(|| format!("Read model {}", candidate.display()))?;
        unique.entry(digest(&bytes)).or_insert(candidate);
    }
    let mut paths: Vec<_> = unique.into_values().collect();
    paths.sort();
    Ok(paths)
}

#[cfg(test)]
pub fn repair_models(
    footprint: &mut Node,
    source_footprint: &Path,
    source_root: &Path,
    destination: &Destination,
    search_roots: &[PathBuf],
    variables: &BTreeMap<String, String>,
    enabled: bool,
) -> Result<ModelPlan> {
    repair_models_with_choices(
        footprint,
        source_footprint,
        source_root,
        destination,
        search_roots,
        variables,
        enabled,
        &BTreeMap::new(),
    )
}

#[allow(clippy::too_many_arguments)]
pub fn repair_models_with_choices(
    footprint: &mut Node,
    source_footprint: &Path,
    source_root: &Path,
    destination: &Destination,
    search_roots: &[PathBuf],
    variables: &BTreeMap<String, String>,
    enabled: bool,
    choices: &BTreeMap<String, PathBuf>,
) -> Result<ModelPlan> {
    let mut plan = ModelPlan::default();
    repair_node(
        footprint,
        source_footprint,
        source_root,
        destination,
        search_roots,
        variables,
        enabled,
        choices,
        &mut plan,
    )?;
    Ok(plan)
}

#[allow(clippy::too_many_arguments)]
fn repair_node(
    node: &mut Node,
    source_footprint: &Path,
    source_root: &Path,
    destination: &Destination,
    search_roots: &[PathBuf],
    variables: &BTreeMap<String, String>,
    enabled: bool,
    choices: &BTreeMap<String, PathBuf>,
    plan: &mut ModelPlan,
) -> Result<()> {
    let Node::List(items) = node else {
        return Ok(());
    };
    if matches!(items.first(), Some(Node::Atom(head)) if head == "model") {
        let reference = match items.get(1) {
            Some(Node::Str(s) | Node::Atom(s)) => s.clone(),
            _ => bail!(
                "Model reference missing a filename in {}",
                source_footprint.display()
            ),
        };
        if reference.starts_with("embedded://")
            || reference.starts_with("kicad-embed://")
            || reference.starts_with("${KICAD_EMBEDDED}")
        {
            plan.messages
                .push(format!("Preserved embedded model: {reference}"));
            return Ok(());
        }
        if !enabled {
            plan.messages.push(format!("Model import disabled; external dependency remains unresolved for portability: {reference}"));
            return Ok(());
        }
        let candidates = model_candidates(
            &reference,
            source_footprint,
            source_root,
            search_roots,
            variables,
            destination.project.as_deref(),
        )?;
        let source = if let Some(choice) = choices.get(&reference) {
            let canonical = choice
                .canonicalize()
                .with_context(|| format!("Chosen model is unavailable: {}", choice.display()))?;
            if !candidates
                .iter()
                .any(|candidate| candidate.canonicalize().ok().as_ref() == Some(&canonical))
            {
                bail!(
                    "pending: chosen model is no longer a matching candidate: {}",
                    choice.display()
                );
            }
            canonical
        } else {
            match candidates.as_slice() {
                [] => {
                    plan.messages.push(format!("Missing model; dependency unresolved, original reference preserved: {reference}"));
                    return Ok(());
                }
                [one] => one.clone(),
                many => bail!(
                    "pending: ambiguous model {reference}; choose one of: {}",
                    many.iter()
                        .map(|p| p.display().to_string())
                        .collect::<Vec<_>>()
                        .join(" | ")
                ),
            }
        };
        let bytes =
            std::fs::read(&source).with_context(|| format!("Read model {}", source.display()))?;
        // A footprint already in this destination must not acquire another hash
        // suffix each time its models are reviewed or the component is reimported.
        if source.parent().and_then(|p| p.canonicalize().ok())
            == destination.models_dir.canonicalize().ok()
            && destination.models_dir.is_dir()
        {
            items[1] = Node::Str(destination.model_uri(&source));
            plan.messages
                .push(format!("Reused model: {}", source.display()));
            return Ok(());
        }
        let hash = digest(&bytes);
        let stem = source.file_stem().unwrap_or_default().to_string_lossy();
        let safe_stem: String = stem
            .chars()
            .map(|c| {
                if c.is_alphanumeric() || c == '-' || c == '_' {
                    c
                } else {
                    '_'
                }
            })
            .collect();
        let extension = source
            .extension()
            .unwrap_or_default()
            .to_string_lossy()
            .to_ascii_lowercase();
        let mut target =
            destination
                .models_dir
                .join(format!("{safe_stem}_{}.{}", &hash[..12], extension));
        if target.exists()
            && std::fs::read(&target)
                .with_context(|| format!("Read existing model {}", target.display()))?
                != bytes
        {
            target = destination
                .models_dir
                .join(format!("{safe_stem}_{hash}.{extension}"));
            if target.exists() && std::fs::read(&target)? != bytes {
                bail!("Model storage collision at {}", target.display());
            }
        }
        let uri = destination.model_uri(&target);
        let reused = target.is_file();
        if !reused && !plan.copies.iter().any(|(path, _)| path == &target) {
            plan.copies.push((target.clone(), bytes));
        }
        items[1] = Node::Str(uri.clone());
        plan.messages.push(format!(
            "{} model: {} -> {}{}",
            if reused { "Reused" } else { "Copied" },
            source.display(),
            uri,
            if reference != source.to_string_lossy() {
                " (reference repaired)"
            } else {
                ""
            }
        ));
        return Ok(());
    }
    for child in items {
        repair_node(
            child,
            source_footprint,
            source_root,
            destination,
            search_roots,
            variables,
            enabled,
            choices,
            plan,
        )?;
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::sexpr::parse;
    fn scratch() -> PathBuf {
        let path = std::env::temp_dir().join(format!(
            "uniloader-models-{}-{}",
            std::process::id(),
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos()
        ));
        std::fs::create_dir_all(&path).unwrap();
        path
    }
    #[test]
    fn repairs_windows_paths_preserving_transforms() {
        let root = scratch();
        std::fs::create_dir_all(root.join("bundle/3d")).unwrap();
        std::fs::write(root.join("bundle/3d/part.STEP"), b"model").unwrap();
        std::fs::write(root.join("board.kicad_pro"), b"{}").unwrap();
        let dest = Destination::new(
            &root.join("global"),
            Some(&root.join("board.kicad_pro")),
            &root.join("config"),
        )
        .unwrap();
        let mut fp = parse(r#"(footprint "x" (model "C:\\old\\3d\\part.STEP" (offset (xyz 1 2 3)) (scale (xyz 1 1 1)) (rotate (xyz 0 0 90))))"#).unwrap();
        let plan = repair_models(
            &mut fp,
            &root.join("bundle/x.kicad_mod"),
            &root.join("bundle"),
            &dest,
            &[],
            &BTreeMap::new(),
            true,
        )
        .unwrap();
        assert_eq!(plan.copies.len(), 1);
        let rendered = fp.to_string();
        assert!(rendered.contains("${KIPRJMOD}/libraries/models/part_"));
        assert!(rendered.contains("(xyz 0 0 90)"));
        assert!(rendered.contains("(xyz 1 2 3)"));
        std::fs::remove_dir_all(root).unwrap();
    }
    #[test]
    fn collapses_identical_candidates_but_requires_choice_for_different_content() {
        let root = scratch();
        for dir in ["a", "b"] {
            std::fs::create_dir(root.join(dir)).unwrap();
            std::fs::write(root.join(dir).join("part.step"), b"same").unwrap();
        }
        let candidates = model_candidates(
            "C:/obsolete/part.step",
            &root.join("x.kicad_mod"),
            &root,
            &[],
            &BTreeMap::new(),
            None,
        )
        .unwrap();
        assert_eq!(candidates.len(), 1);
        std::fs::write(root.join("b/part.step"), b"different").unwrap();
        assert_eq!(
            model_candidates(
                "C:/obsolete/part.step",
                &root.join("x.kicad_mod"),
                &root,
                &[],
                &BTreeMap::new(),
                None
            )
            .unwrap()
            .len(),
            2
        );
        let dest = Destination::new(&root.join("global"), None, &root.join("config")).unwrap();
        let mut fp = parse(r#"(footprint "x" (model "C:/obsolete/part.step"))"#).unwrap();
        assert!(
            repair_models(
                &mut fp,
                &root.join("x.kicad_mod"),
                &root,
                &dest,
                &[],
                &BTreeMap::new(),
                true
            )
            .unwrap_err()
            .to_string()
            .starts_with("pending:")
        );
        let choices = BTreeMap::from([("C:/obsolete/part.step".into(), root.join("b/part.step"))]);
        let plan = repair_models_with_choices(
            &mut fp,
            &root.join("x.kicad_mod"),
            &root,
            &dest,
            &[],
            &BTreeMap::new(),
            true,
            &choices,
        )
        .unwrap();
        assert_eq!(plan.copies[0].1, b"different");
        std::fs::remove_dir_all(root).unwrap();
    }
    #[test]
    fn external_project_model_uses_source_context_and_becomes_portable() {
        let root = scratch();
        let source = root.join("source");
        let target = root.join("target");
        for project in [&source, &target] {
            std::fs::create_dir_all(project.join("libraries/models")).unwrap();
            std::fs::create_dir_all(project.join("libraries/Parts.pretty")).unwrap();
            std::fs::write(project.join("board.kicad_pro"), b"{}").unwrap();
        }
        std::fs::write(source.join("libraries/models/chip.step"), b"SOURCE MODEL").unwrap();
        // Same URI in another project is not the same dependency.
        std::fs::write(
            target.join("libraries/models/chip.step"),
            b"WRONG TARGET MODEL",
        )
        .unwrap();
        let dest = Destination::new(
            &root.join("global"),
            Some(&target.join("board.kicad_pro")),
            &root.join("config"),
        )
        .unwrap();
        let mut fp = parse(r#"(footprint "chip" (model "${KIPRJMOD}/libraries/models/chip.step" (offset (xyz 1 2 3))))"#).unwrap();
        let source_fp = source.join("libraries/Parts.pretty/chip.kicad_mod");
        let plan = repair_models(
            &mut fp,
            &source_fp,
            source_fp.parent().unwrap(),
            &dest,
            &[],
            &BTreeMap::new(),
            true,
        )
        .unwrap();
        assert_eq!(plan.copies.len(), 1);
        assert_eq!(plan.copies[0].1, b"SOURCE MODEL");
        assert!(plan.copies[0].0.starts_with(&target));
        assert!(
            fp.to_string()
                .contains("${KIPRJMOD}/libraries/models/chip_")
        );
        assert!(fp.to_string().contains("(xyz 1 2 3)"));
        std::fs::remove_dir_all(root).unwrap();
    }
    #[test]
    fn conflicting_model_storage_keeps_existing_bytes() {
        let root = scratch();
        std::fs::write(root.join("chip.step"), b"NEW MODEL").unwrap();
        let dest = Destination::new(&root.join("global"), None, &root.join("config")).unwrap();
        std::fs::create_dir_all(&dest.models_dir).unwrap();
        let hash = digest(b"NEW MODEL");
        let collision = dest.models_dir.join(format!("chip_{}.step", &hash[..12]));
        std::fs::write(&collision, b"EXISTING USER MODEL").unwrap();
        let mut fp = parse(r#"(footprint "chip" (model "chip.step"))"#).unwrap();
        let plan = repair_models(
            &mut fp,
            &root.join("chip.kicad_mod"),
            &root,
            &dest,
            &[],
            &BTreeMap::new(),
            true,
        )
        .unwrap();
        assert_ne!(plan.copies[0].0, collision);
        assert_eq!(std::fs::read(&collision).unwrap(), b"EXISTING USER MODEL");
        assert_eq!(plan.copies[0].1, b"NEW MODEL");
        // A second collision refuses to plan an overwrite.
        std::fs::write(&plan.copies[0].0, b"ANOTHER EXISTING MODEL").unwrap();
        let mut original = parse(r#"(footprint "chip" (model "chip.step"))"#).unwrap();
        assert!(
            repair_models(
                &mut original,
                &root.join("chip.kicad_mod"),
                &root,
                &dest,
                &[],
                &BTreeMap::new(),
                true
            )
            .is_err()
        );
        std::fs::remove_dir_all(root).unwrap();
    }
    #[test]
    fn embedded_references_are_preserved_without_warnings() {
        let root = scratch();
        let dest = Destination::new(&root.join("global"), None, &root.join("config")).unwrap();
        for reference in [
            "embedded://chip.step",
            "kicad-embed://chip.step",
            "${KICAD_EMBEDDED}/chip.step",
        ] {
            let mut fp = Node::list(vec![
                Node::symbol("footprint"),
                Node::string("chip"),
                Node::list(vec![Node::symbol("model"), Node::string(reference)]),
            ]);
            let before = fp.to_string();
            let plan = repair_models(
                &mut fp,
                &root.join("chip.kicad_mod"),
                &root,
                &dest,
                &[],
                &BTreeMap::new(),
                true,
            )
            .unwrap();
            assert_eq!(fp.to_string(), before);
            assert!(plan.copies.is_empty());
            assert!(plan.messages[0].contains("Preserved embedded"));
        }
        std::fs::remove_dir_all(root).unwrap();
    }
    #[test]
    fn missing_models_remain_visible() {
        let root = scratch();
        let dest = Destination::new(&root.join("global"), None, &root.join("config")).unwrap();
        let mut fp = parse(r#"(footprint "x" (model "missing.wrl"))"#).unwrap();
        let before = fp.to_string();
        let plan = repair_models(
            &mut fp,
            &root.join("x.kicad_mod"),
            &root,
            &dest,
            &[],
            &BTreeMap::new(),
            true,
        )
        .unwrap();
        assert_eq!(fp.to_string(), before);
        assert!(plan.copies.is_empty());
        assert!(plan.messages[0].contains("Missing model"));
        std::fs::remove_dir_all(root).unwrap();
    }
}