// cli/admin.rs — admin subcommand handlers

use anyhow::Result;
use crate::hippocampus as memory;
use crate::hippocampus::store;

fn install_default_file(data_dir: &std::path::Path, name: &str, content: &str) -> Result<()> {
    let path = data_dir.join(name);
    if !path.exists() {
        std::fs::write(&path, content)?;
        println!("Created {}", path.display());
    }
    Ok(())
}

pub async fn cmd_init() -> Result<()> {
    let cfg = crate::config::get();

    // Ensure data directory exists
    std::fs::create_dir_all(&cfg.data_dir)?;

    // Install filesystem files (not store nodes)
    install_default_file(&cfg.data_dir, "instructions.md",
        include_str!("../../defaults/instructions.md"))?;
    install_default_file(&cfg.data_dir, "on-consciousness.md",
        include_str!("../../defaults/on-consciousness.md"))?;

    // Seed identity node if empty
    let arc = memory::access_local()?;
    let mut store = arc.lock().await;
    if !store.contains_key("identity").unwrap_or(false) {
        let default = include_str!("../../defaults/identity.md");
        store.upsert("identity", default)?;
        println!("Seeded identity in store");
    }
    store.save()?;
    println!("Initialized with {} nodes", store.all_keys().unwrap_or_default().len());

    // Create config if none exists
    let config_path = std::env::var("POC_MEMORY_CONFIG")
        .map(std::path::PathBuf::from)
        .unwrap_or_else(|_| {
            dirs::home_dir().unwrap_or_default()
                .join(".consciousness/config.jsonl")
        });
    if !config_path.exists() {
        let config_dir = config_path.parent().unwrap();
        std::fs::create_dir_all(config_dir)?;
        let example = include_str!("../../config.example.jsonl");
        std::fs::write(&config_path, example)?;
        println!("Created config at {} — edit with your name and context groups",
            config_path.display());
    }

    println!("Done. Run `poc-memory load-context --stats` to verify.");
    Ok(())
}

pub async fn cmd_fsck() -> Result<()> {
    // Check/repair capnp log integrity first
    store::fsck()?;

    let arc = memory::access_local()?;
    let mut store = arc.lock().await;

    // Check node-key consistency
    let mut issues = 0;
    let all_keys = store.all_keys().unwrap_or_default();
    for key in &all_keys {
        if let Ok(Some(node)) = store.get_node(key) {
            if key != &node.key {
                eprintln!("MISMATCH: map key '{}' vs node.key '{}'", key, node.key);
                issues += 1;
            }
        }
    }

    // Check edge endpoints using index
    use crate::hippocampus::store::StoreView;
    let mut dangling = 0;
    let mut orphan_edges: Vec<(String, String)> = Vec::new();
    store.for_each_relation(|source, target, _, _| {
        let s_missing = !store.contains_key(source).unwrap_or(false);
        let t_missing = !store.contains_key(target).unwrap_or(false);
        if s_missing {
            eprintln!("DANGLING: edge source '{}'", source);
            dangling += 1;
        }
        if t_missing {
            eprintln!("DANGLING: edge target '{}'", target);
            dangling += 1;
        }
        if s_missing || t_missing {
            orphan_edges.push((source.to_string(), target.to_string()));
        }
    });

    // Prune orphan edges
    if !orphan_edges.is_empty() {
        let count = orphan_edges.len();
        for (source, target) in &orphan_edges {
            // set_link_strength with 0 would delete, but we don't have that
            // For now just report - full cleanup requires more work
            eprintln!("Would prune: {} → {}", source, target);
        }
        eprintln!("Found {} orphan edges (prune not yet implemented for index)", count);
    }

    let g = store.build_graph();
    println!("fsck: {} nodes, {} edges, {} issues, {} dangling",
        all_keys.len(), g.edge_count(), issues, dangling);
    Ok(())
}

pub async fn cmd_dedup(apply: bool) -> Result<()> {
    use std::collections::{HashMap, HashSet};

    let arc = memory::access_local()?;
    let mut store = arc.lock().await;
    let duplicates = store.find_duplicates()?;

    if duplicates.is_empty() {
        println!("No duplicate keys found.");
        return Ok(());
    }

    // Count edges per key (we'll map to UUID later)
    use crate::hippocampus::store::StoreView;
    let mut edges_by_key: HashMap<String, usize> = HashMap::new();
    store.for_each_relation(|source, target, _, _| {
        *edges_by_key.entry(source.to_string()).or_default() += 1;
        *edges_by_key.entry(target.to_string()).or_default() += 1;
    });
    // Convert to edges_by_uuid for compatibility
    let mut edges_by_uuid: HashMap<[u8; 16], usize> = HashMap::new();
    for (key, count) in &edges_by_key {
        if let Ok(Some(node)) = store.get_node(key) {
            edges_by_uuid.insert(node.uuid, *count);
        }
    }

    let mut identical_groups = Vec::new();
    let mut diverged_groups = Vec::new();

    for (key, mut nodes) in duplicates {
        // Sort by version descending so highest-version is first
        nodes.sort_by(|a, b| b.version.cmp(&a.version));

        // Check if all copies have identical content
        let all_same = nodes.windows(2).all(|w| w[0].content == w[1].content);

        let info: Vec<_> = nodes.iter().map(|n| {
            let edge_count = edges_by_uuid.get(&n.uuid).copied().unwrap_or(0);
            (n.clone(), edge_count)
        }).collect();

        if all_same {
            identical_groups.push((key, info));
        } else {
            diverged_groups.push((key, info));
        }
    }

    // Report
    println!("=== Duplicate key report ===\n");
    println!("{} identical groups, {} diverged groups\n",
        identical_groups.len(), diverged_groups.len());

    if !identical_groups.is_empty() {
        println!("── Identical (safe to auto-merge) ──");
        for (key, copies) in &identical_groups {
            let total_edges: usize = copies.iter().map(|c| c.1).sum();
            println!("  {} ({} copies, {} total edges)", key, copies.len(), total_edges);
            for (node, edges) in copies {
                let uuid_hex = node.uuid.iter().map(|b| format!("{:02x}", b)).collect::<String>();
                println!("    v{} uuid={}.. edges={}", node.version, &uuid_hex[..8], edges);
            }
        }
        println!();
    }

    if !diverged_groups.is_empty() {
        println!("── Diverged (need review) ──");
        for (key, copies) in &diverged_groups {
            let total_edges: usize = copies.iter().map(|c| c.1).sum();
            println!("  {} ({} copies, {} total edges)", key, copies.len(), total_edges);
            for (node, edges) in copies {
                let uuid_hex = node.uuid.iter().map(|b| format!("{:02x}", b)).collect::<String>();
                let preview: String = node.content.chars().take(80).collect();
                println!("    v{} uuid={}.. edges={} | {}{}",
                    node.version, &uuid_hex[..8], edges, preview,
                    if node.content.len() > 80 { "..." } else { "" });
            }
        }
        println!();
    }

    if !apply {
        let total_dupes: usize = identical_groups.iter().chain(diverged_groups.iter())
            .map(|(_, copies)| copies.len() - 1)
            .sum();
        println!("Dry run: {} duplicate nodes would be merged. Use --apply to execute.", total_dupes);
        return Ok(());
    }

    // Merge all groups: identical + diverged
    // For diverged: keep the copy with most edges (it's the one that got
    // woven into the graph — the version that lived). Fall back to highest version.
    let all_groups: Vec<_> = identical_groups.into_iter()
        .chain(diverged_groups)
        .collect();

    let mut merged = 0usize;
    let mut edges_redirected = 0usize;
    let mut edges_deduped = 0usize;

    for (_key, mut copies) in all_groups {
        // Pick survivor: most edges first, then highest version
        copies.sort_by(|a, b| b.1.cmp(&a.1).then(b.0.version.cmp(&a.0.version)));

        let survivor_uuid = copies[0].0.uuid;
        let doomed_uuids: Vec<[u8; 16]> = copies[1..].iter().map(|c| c.0.uuid).collect();

        // Redirect edges from doomed UUIDs to survivor
        let mut updated_rels = Vec::new();
        for rel in &mut store.relations {
            if rel.deleted { continue; }
            let mut changed = false;
            if doomed_uuids.contains(&rel.source) {
                rel.source = survivor_uuid;
                changed = true;
            }
            if doomed_uuids.contains(&rel.target) {
                rel.target = survivor_uuid;
                changed = true;
            }
            if changed {
                rel.version += 1;
                updated_rels.push(rel.clone());
                edges_redirected += 1;
            }
        }

        // Dedup edges: same (source, target, rel_type) → keep highest strength
        let mut seen: HashSet<([u8; 16], [u8; 16], String)> = HashSet::new();
        let mut to_tombstone_rels = Vec::new();
        // Sort by strength descending so we keep the strongest
        let mut rels_with_idx: Vec<(usize, &store::Relation)> = store.relations.iter()
            .enumerate()
            .filter(|(_, r)| !r.deleted && (r.source == survivor_uuid || r.target == survivor_uuid))
            .collect();
        rels_with_idx.sort_by(|a, b| b.1.strength.total_cmp(&a.1.strength));

        for (idx, rel) in &rels_with_idx {
            let edge_key = (rel.source, rel.target, format!("{:?}", rel.rel_type));
            if !seen.insert(edge_key) {
                to_tombstone_rels.push(*idx);
                edges_deduped += 1;
            }
        }

        for &idx in &to_tombstone_rels {
            store.relations[idx].deleted = true;
            store.relations[idx].version += 1;
            updated_rels.push(store.relations[idx].clone());
        }

        // Tombstone doomed nodes
        let mut tombstones = Vec::new();
        for (doomed_node, _) in &copies[1..] {
            let mut t = doomed_node.clone();
            t.deleted = true;
            t.version += 1;
            tombstones.push(t);
        }

        store.append_nodes(&tombstones)?;
        if !updated_rels.is_empty() {
            store.append_relations(&updated_rels)?;
        }

        // Remove doomed nodes from index
        for (doomed_node, _) in &copies[1..] {
            store.remove_from_index(&doomed_node.key, &doomed_node.uuid)?;
        }

        merged += doomed_uuids.len();
    }

    // Remove tombstoned relations from cache
    store.relations.retain(|r| !r.deleted);
    store.save()?;

    println!("Merged {} duplicates, redirected {} edges, deduped {} duplicate edges",
        merged, edges_redirected, edges_deduped);

    Ok(())
}

pub async fn cmd_health() -> Result<()> {
    let result = memory::graph_health(None).await
        ?;
    print!("{}", result);
    Ok(())
}

pub async fn cmd_topology() -> Result<()> {
    let result = memory::graph_topology(None).await
        ?;
    print!("{}", result);
    Ok(())
}

pub async fn cmd_daily_check() -> Result<()> {
    let arc = memory::access_local()?;
    let store = arc.lock().await;
    let report = crate::neuro::daily_check(&store);
    print!("{}", report);
    Ok(())
}

pub async fn cmd_status() -> Result<()> {
    let result = memory::graph_topology(None).await
        ?;
    print!("{}", result);
    Ok(())
}