incurs 0.10.1

//! Skill file synchronization — generates and installs skill files from commands.
//!
//! Generates SKILL.md files from the command
//! tree, installs them to agent directories, and tracks a hash for staleness
//! detection so repeated syncs are no-ops when commands haven't changed.

use std::collections::BTreeMap;
use std::fs;
use std::path::{Path, PathBuf};

use crate::agents::{self, AgentInstall, InstallOptions, RemoveOptions};
use crate::skill::{self, CommandInfo, SkillFile};

// ---------------------------------------------------------------------------
// Types
// ---------------------------------------------------------------------------

/// Options for [`sync`].
#[derive(Debug, Clone, Default)]
pub struct SyncOptions {
    /// Working directory for resolving include globs. Defaults to current dir.
    pub cwd: Option<String>,
    /// Grouping depth for skill files. Defaults to `1`.
    pub depth: Option<usize>,
    /// CLI description, used as the top-level group description.
    pub description: Option<String>,
    /// Install globally (`true`) or project-local (`false`). Defaults to `true`.
    pub global: bool,
    /// Glob patterns for directories containing additional SKILL.md files to include.
    pub include: Option<Vec<String>>,
}

/// A synced skill entry.
#[derive(Debug, Clone)]
pub struct SyncedSkill {
    /// Skill directory name.
    pub name: String,
    /// Description extracted from skill frontmatter.
    pub description: Option<String>,
    /// Whether this skill was included from a local file (not generated from commands).
    pub external: bool,
}

/// Result of a [`sync`] operation.
#[derive(Debug, Clone)]
pub struct SyncResult {
    /// Synced skills with metadata.
    pub skills: Vec<SyncedSkill>,
    /// Canonical install paths.
    pub paths: Vec<PathBuf>,
    /// Per-agent install details (non-universal agents only).
    pub agents: Vec<AgentInstall>,
}

/// Stored metadata for staleness detection.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct Meta {
    hash: String,
    #[serde(default)]
    skills: Vec<String>,
    #[serde(default)]
    at: String,
}

// ---------------------------------------------------------------------------
// Public API
// ---------------------------------------------------------------------------

/// Generates skill files from commands and installs them to agent directories.
///
/// Creates a temporary directory, writes SKILL.md files, installs them via
/// [`agents::install`], cleans up stale skills from previous syncs, and
/// writes a hash file for future staleness detection.
pub async fn sync(
    name: &str,
    commands: &[CommandInfo],
    options: &SyncOptions,
) -> Result<SyncResult, crate::errors::Error> {
    let depth = options.depth.unwrap_or(1);
    let is_global = options.global;

    let cwd = options.cwd.clone().unwrap_or_else(|| {
        std::env::current_dir()
            .map(|p| p.to_string_lossy().to_string())
            .unwrap_or_else(|_| ".".to_string())
    });

    // Build groups from description
    let mut groups: BTreeMap<String, String> = BTreeMap::new();
    if let Some(desc) = &options.description {
        groups.insert(name.to_string(), desc.clone());
    }

    let files = skill::split(name, commands, depth, &groups);

    // Create temp directory
    let tmp_dir =
        std::env::temp_dir().join(format!("incurs-skills-{}-{}", name, std::process::id()));
    let _ = fs::create_dir_all(&tmp_dir);

    let result = sync_inner(
        name,
        commands,
        &files,
        &tmp_dir,
        &cwd,
        is_global,
        &options.include,
    );

    // Cleanup temp directory
    let _ = fs::remove_dir_all(&tmp_dir);

    result
}

fn sync_inner(
    name: &str,
    commands: &[CommandInfo],
    files: &[SkillFile],
    tmp_dir: &Path,
    cwd: &str,
    is_global: bool,
    include: &Option<Vec<String>>,
) -> Result<SyncResult, crate::errors::Error> {
    let mut skills: Vec<SyncedSkill> = Vec::new();

    for file in files {
        let file_path = if file.dir.is_empty() {
            tmp_dir.join("SKILL.md")
        } else {
            tmp_dir.join(&file.dir).join("SKILL.md")
        };
        if let Some(parent) = file_path.parent() {
            let _ = fs::create_dir_all(parent);
        }
        let content = format!("{}\n", file.content);
        let _ = fs::write(&file_path, &content);

        let desc = extract_description(&content);
        let skill_name = if file.dir.is_empty() {
            name.to_string()
        } else {
            file.dir.clone()
        };
        skills.push(SyncedSkill {
            name: skill_name,
            description: desc,
            external: false,
        });
    }

    // Include additional SKILL.md files matched by patterns
    if let Some(patterns) = include {
        for pattern in patterns {
            let is_root = pattern == "_root";
            let search_path = if is_root {
                PathBuf::from(cwd).join("SKILL.md")
            } else {
                PathBuf::from(cwd).join(pattern).join("SKILL.md")
            };

            if search_path.exists()
                && let Ok(content) = fs::read_to_string(&search_path)
            {
                let skill_name = if is_root {
                    extract_skill_name(&content).unwrap_or_else(|| name.to_string())
                } else {
                    search_path
                        .parent()
                        .and_then(|p| p.file_name())
                        .and_then(|n| n.to_str())
                        .unwrap_or(pattern)
                        .to_string()
                };

                let dest = tmp_dir.join(&skill_name).join("SKILL.md");
                if let Some(parent) = dest.parent() {
                    let _ = fs::create_dir_all(parent);
                }
                let _ = fs::write(&dest, &content);

                if !skills.iter().any(|s| s.name == skill_name) {
                    let desc = extract_description(&content);
                    skills.push(SyncedSkill {
                        name: skill_name,
                        description: desc,
                        external: true,
                    });
                }
            }
        }
    }

    // Install via agents module
    let install_result = agents::install(
        tmp_dir,
        &InstallOptions {
            global: Some(is_global),
            cwd: Some(cwd.to_string()),
            ..Default::default()
        },
    );

    // Remove stale skills from previous installs
    let current_names: std::collections::HashSet<String> = install_result
        .paths
        .iter()
        .filter_map(|p| {
            p.file_name()
                .and_then(|n| n.to_str())
                .map(|s| s.to_string())
        })
        .collect();

    let prev = read_meta(name);
    if let Some(prev_meta) = prev {
        for old in &prev_meta.skills {
            if !current_names.contains(old) {
                agents::remove(
                    old,
                    &RemoveOptions {
                        global: Some(is_global),
                        cwd: Some(cwd.to_string()),
                    },
                );
            }
        }
    }

    // Write hash for staleness detection
    let hash = skill::hash(commands);
    let skill_names: Vec<String> = current_names.into_iter().collect();
    write_meta(name, &hash, &skill_names);

    Ok(SyncResult {
        skills,
        paths: install_result.paths,
        agents: install_result.agents,
    })
}

/// Reads the stored skills hash for a CLI. Returns `None` if no hash exists.
pub fn read_hash(name: &str) -> Option<String> {
    read_meta(name).map(|m| m.hash)
}

/// Returns the set of stored skill names for this CLI that are currently
/// installed (a `SKILL.md` exists under `~/.agents/skills/<skill>` or
/// `<cwd>/.agents/skills/<skill>`).
fn installed_skills(name: &str, cwd: Option<&str>) -> std::collections::HashSet<String> {
    let meta = match read_meta(name) {
        Some(m) if !m.skills.is_empty() => m,
        _ => return std::collections::HashSet::new(),
    };
    let cwd = cwd
        .map(PathBuf::from)
        .or_else(|| std::env::current_dir().ok())
        .unwrap_or_default();
    let bases = [
        dirs::home_dir()
            .unwrap_or_default()
            .join(".agents")
            .join("skills"),
        cwd.join(".agents").join("skills"),
    ];
    meta.skills
        .into_iter()
        .filter(|skill| {
            bases
                .iter()
                .any(|base| base.join(skill).join("SKILL.md").exists())
        })
        .collect()
}

/// Returns `true` if any of the stored skills for this CLI are currently
/// installed.
pub fn has_installed_skills(name: &str, cwd: Option<&str>) -> bool {
    !installed_skills(name, cwd).is_empty()
}

/// A skill entry returned by [`list`].
pub struct ListedSkill {
    /// The skill name.
    pub name: String,
    /// The skill description, if any.
    pub description: Option<String>,
    /// Whether this skill is currently installed on disk.
    pub installed: bool,
}

/// Lists the skills this CLI would generate, annotated with whether each is
/// currently installed.
pub fn list(
    name: &str,
    commands: &[CommandInfo],
    depth: usize,
    description: Option<&str>,
) -> Vec<ListedSkill> {
    let mut groups: BTreeMap<String, String> = BTreeMap::new();
    if let Some(desc) = description {
        groups.insert(name.to_string(), desc.to_string());
    }
    let files = skill::split(name, commands, depth, &groups);
    let installed = installed_skills(name, None);

    let mut skills: Vec<ListedSkill> = files
        .iter()
        .map(|file| {
            let content = format!("{}\n", file.content);
            let skill_name = extract_skill_name(&content).unwrap_or_else(|| {
                if file.dir.is_empty() {
                    name.to_string()
                } else {
                    file.dir.clone()
                }
            });
            let desc = extract_description(&content);
            let is_installed = installed.contains(&skill_name);
            ListedSkill {
                name: skill_name,
                description: desc,
                installed: is_installed,
            }
        })
        .collect();
    skills.sort_by(|a, b| a.name.cmp(&b.name));
    skills
}

// ---------------------------------------------------------------------------
// Metadata persistence
// ---------------------------------------------------------------------------

/// Returns the metadata file path for a CLI.
fn meta_path(name: &str) -> PathBuf {
    let data_home = std::env::var("XDG_DATA_HOME")
        .ok()
        .filter(|s| !s.is_empty())
        .map(PathBuf::from)
        .unwrap_or_else(|| {
            dirs::home_dir()
                .unwrap_or_default()
                .join(".local")
                .join("share")
        });
    data_home.join("incurs").join(format!("{}.json", name))
}

/// Writes the skills metadata for staleness detection and cleanup.
fn write_meta(name: &str, hash: &str, skills: &[String]) {
    let file = meta_path(name);
    if let Some(dir) = file.parent() {
        let _ = fs::create_dir_all(dir);
    }
    let meta = Meta {
        hash: hash.to_string(),
        skills: skills.to_vec(),
        at: chrono_now(),
    };
    if let Ok(json) = serde_json::to_string(&meta) {
        let _ = fs::write(&file, format!("{}\n", json));
    }
}

/// Reads the stored metadata for a CLI.
fn read_meta(name: &str) -> Option<Meta> {
    let file = meta_path(name);
    let content = fs::read_to_string(&file).ok()?;
    serde_json::from_str(&content).ok()
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

/// Extracts the `description:` frontmatter value from SKILL.md content.
fn extract_description(content: &str) -> Option<String> {
    for line in content.lines() {
        if let Some(rest) = line.strip_prefix("description:") {
            let desc = rest.trim();
            if !desc.is_empty() {
                return Some(desc.to_string());
            }
        }
    }
    None
}

/// Extracts the `name:` frontmatter value from SKILL.md content.
fn extract_skill_name(content: &str) -> Option<String> {
    for line in content.lines() {
        if let Some(rest) = line.strip_prefix("name:") {
            let name = rest.trim();
            if !name.is_empty() {
                return Some(name.to_string());
            }
        }
    }
    None
}

/// Returns a basic ISO 8601 timestamp without pulling in the chrono crate.
fn chrono_now() -> String {
    // Use std SystemTime for a basic timestamp
    use std::time::SystemTime;
    match SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
        Ok(d) => format!("{}s", d.as_secs()),
        Err(_) => "0s".to_string(),
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_extract_description() {
        let content = "---\nname: test\ndescription: A test skill\n---\n";
        assert_eq!(
            extract_description(content),
            Some("A test skill".to_string())
        );
    }

    #[test]
    fn test_extract_description_missing() {
        let content = "---\nname: test\n---\n";
        assert_eq!(extract_description(content), None);
    }

    #[test]
    fn test_extract_skill_name() {
        let content = "---\nname: my-skill\n---\n";
        assert_eq!(extract_skill_name(content), Some("my-skill".to_string()));
    }

    #[test]
    fn test_meta_path() {
        let path = meta_path("mycli");
        assert!(path.to_string_lossy().contains("incurs"));
        assert!(path.to_string_lossy().ends_with("mycli.json"));
    }

    #[test]
    fn test_read_hash_nonexistent() {
        assert_eq!(read_hash("nonexistent-test-cli-12345"), None);
    }

    // F10: has_installed_skills returns false when no meta exists.
    #[test]
    fn test_has_installed_skills_no_meta() {
        assert!(!has_installed_skills("nonexistent-cli-f10-aaa", None));
    }

    // F10: has_installed_skills returns true when a stored skill has a SKILL.md
    // under `<cwd>/.agents/skills/<skill>`.
    #[test]
    fn test_has_installed_skills_detects_installed() {
        let unique = format!("f10-cli-{}", std::process::id());
        // Record metadata (uses the ambient XDG/home data dir for this name only).
        write_meta(&unique, "abc123", std::slice::from_ref(&unique));

        // Create a temp cwd with the skill installed.
        let tmp = std::env::temp_dir().join(format!("f10-cwd-{}", std::process::id()));
        let skill_dir = tmp.join(".agents").join("skills").join(&unique);
        fs::create_dir_all(&skill_dir).unwrap();
        fs::write(skill_dir.join("SKILL.md"), "x").unwrap();

        assert!(has_installed_skills(&unique, Some(&tmp.to_string_lossy())));

        // No matching skill dir → false.
        let empty = std::env::temp_dir().join(format!("f10-empty-{}", std::process::id()));
        fs::create_dir_all(&empty).unwrap();
        assert!(!has_installed_skills(
            &unique,
            Some(&empty.to_string_lossy())
        ));

        // Cleanup
        let _ = fs::remove_file(meta_path(&unique));
        let _ = fs::remove_dir_all(&tmp);
        let _ = fs::remove_dir_all(&empty);
    }
}