weave-content 0.2.9

use std::collections::HashMap;
use std::path::{Path, PathBuf};

use crate::entity::{Entity, Label};
use crate::parser::ParseError;

/// Maximum length of entity filename stem (without `.md`).
const MAX_FILENAME_LEN: usize = 200;

/// A loaded entity with its source file path.
#[derive(Debug)]
pub struct RegistryEntry {
    pub entity: Entity,
    pub path: PathBuf,
}

/// Entity registry: holds all shared entities loaded from `actors/` and
/// `institutions/` directories. Provides name-based lookup for cross-file
/// resolution.
#[derive(Debug)]
pub struct EntityRegistry {
    entries: Vec<RegistryEntry>,
    /// Name → index into `entries`. Names are case-sensitive.
    name_index: HashMap<String, usize>,
}

impl EntityRegistry {
    /// Build a registry from a content root directory.
    ///
    /// Scans `{root}/actors/*.md` and `{root}/institutions/*.md`, parses each
    /// file, validates for duplicates and filename mismatches.
    pub fn load(root: &Path) -> Result<Self, Vec<ParseError>> {
        let mut entries = Vec::new();
        let mut errors = Vec::new();

        let actor_dir = root.join("actors");
        let institution_dir = root.join("institutions");

        load_directory(&actor_dir, Label::Actor, &mut entries, &mut errors);
        load_directory(
            &institution_dir,
            Label::Institution,
            &mut entries,
            &mut errors,
        );

        // Build name index and detect duplicates
        let name_index = build_name_index(&entries, &mut errors);

        if errors.iter().any(|e| e.message.starts_with("duplicate")) {
            return Err(errors);
        }

        // Filename mismatch warnings are non-fatal, report via errors but don't fail
        // (caller can filter by message prefix if needed)

        if errors.iter().any(|e| !e.message.starts_with("warning:")) {
            return Err(errors);
        }

        // Warnings only -- attach them but succeed
        if !errors.is_empty() {
            for err in &errors {
                eprintln!("{err}");
            }
        }

        Ok(Self {
            entries,
            name_index,
        })
    }

    /// Build a registry from pre-parsed entries.
    pub fn from_entries(entries: Vec<RegistryEntry>) -> Result<Self, Vec<ParseError>> {
        let mut errors = Vec::new();
        let name_index = build_name_index(&entries, &mut errors);

        let has_errors = errors.iter().any(|e| !e.message.starts_with("warning:"));
        if has_errors {
            return Err(errors);
        }

        Ok(Self {
            entries,
            name_index,
        })
    }

    /// Look up an entity by name. Returns None if not found.
    pub fn get_by_name(&self, name: &str) -> Option<&RegistryEntry> {
        self.name_index.get(name).map(|&idx| &self.entries[idx])
    }

    /// Number of entities in the registry.
    pub fn len(&self) -> usize {
        self.entries.len()
    }

    /// Whether the registry is empty.
    pub fn is_empty(&self) -> bool {
        self.entries.is_empty()
    }

    /// All entity names in the registry.
    pub fn names(&self) -> Vec<&str> {
        self.entries
            .iter()
            .map(|e| e.entity.name.as_str())
            .collect()
    }
}

/// Load all `.md` files from a directory, parsing each as an entity file.
fn load_directory(
    dir: &Path,
    label: Label,
    entries: &mut Vec<RegistryEntry>,
    errors: &mut Vec<ParseError>,
) {
    let Ok(read_dir) = std::fs::read_dir(dir) else {
        // Directory doesn't exist -- not an error (may have no actors or no institutions)
        return;
    };

    let mut paths: Vec<PathBuf> = read_dir
        .filter_map(|entry| {
            let entry = entry.ok()?;
            let path = entry.path();
            if path.extension().and_then(|e| e.to_str()) == Some("md") {
                Some(path)
            } else {
                None
            }
        })
        .collect();

    // Sort for deterministic ordering
    paths.sort();

    for path in paths {
        load_entity_file(&path, label, entries, errors);
    }
}

/// Load and parse a single entity file.
fn load_entity_file(
    path: &Path,
    label: Label,
    entries: &mut Vec<RegistryEntry>,
    errors: &mut Vec<ParseError>,
) {
    let content = match std::fs::read_to_string(path) {
        Ok(c) => c,
        Err(e) => {
            errors.push(ParseError {
                line: 0,
                message: format!("{}: error reading file: {e}", path.display()),
            });
            return;
        }
    };

    let parsed = match crate::parser::parse_entity_file(&content) {
        Ok(p) => p,
        Err(parse_errors) => {
            for err in parse_errors {
                errors.push(ParseError {
                    line: err.line,
                    message: format!("{}: {}", path.display(), err.message),
                });
            }
            return;
        }
    };

    let mut field_errors = Vec::new();
    let entity = crate::entity::parse_entity_file_body(
        &parsed.name,
        &parsed.body,
        label,
        parsed.id,
        parsed.title_line,
        &mut field_errors,
    );

    for err in field_errors {
        errors.push(ParseError {
            line: err.line,
            message: format!("{}: {}", path.display(), err.message),
        });
    }

    // Validate filename matches content
    validate_filename(path, &entity, errors);

    entries.push(RegistryEntry {
        entity,
        path: path.to_path_buf(),
    });
}

/// Build name → index map, detecting duplicate names.
fn build_name_index(
    entries: &[RegistryEntry],
    errors: &mut Vec<ParseError>,
) -> HashMap<String, usize> {
    let mut index = HashMap::new();

    for (i, entry) in entries.iter().enumerate() {
        let name = &entry.entity.name;
        if let Some(&existing_idx) = index.get(name.as_str()) {
            let existing: &RegistryEntry = &entries[existing_idx];
            errors.push(ParseError {
                line: entry.entity.line,
                message: format!(
                    "duplicate entity name {name:?} in {} (first defined in {})",
                    entry.path.display(),
                    existing.path.display(),
                ),
            });
        } else {
            index.insert(name.clone(), i);
        }
    }

    index
}

/// Warn if entity filename doesn't match content.
/// Expected: `<name>--<qualifier>.md` in kebab-case.
fn validate_filename(path: &Path, entity: &Entity, errors: &mut Vec<ParseError>) {
    let Some(stem) = path.file_stem().and_then(|s| s.to_str()) else {
        return;
    };

    if stem.len() > MAX_FILENAME_LEN {
        errors.push(ParseError {
            line: 0,
            message: format!(
                "warning: {}: filename stem exceeds {MAX_FILENAME_LEN} chars",
                path.display()
            ),
        });
    }

    let expected_name = to_kebab_case(&entity.name);
    let qualifier = entity
        .fields
        .iter()
        .find(|(k, _)| k == "qualifier")
        .and_then(|(_, v)| match v {
            crate::entity::FieldValue::Single(s) => Some(s.as_str()),
            crate::entity::FieldValue::List(_) => None,
        });

    let expected_stem = match qualifier {
        Some(q) => format!("{expected_name}--{}", to_kebab_case(q)),
        None => expected_name,
    };

    if stem != expected_stem {
        errors.push(ParseError {
            line: 0,
            message: format!(
                "warning: {}: filename {stem:?} doesn't match expected {expected_stem:?}",
                path.display()
            ),
        });
    }
}

/// Convert a display name to kebab-case for filename comparison.
fn to_kebab_case(s: &str) -> String {
    s.chars()
        .map(|c| {
            if c.is_alphanumeric() {
                c.to_ascii_lowercase()
            } else {
                '-'
            }
        })
        .collect::<String>()
        .split('-')
        .filter(|p| !p.is_empty())
        .collect::<Vec<_>>()
        .join("-")
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::entity::{Entity, FieldValue, Label};

    fn make_entry(name: &str, label: Label, path: &str) -> RegistryEntry {
        RegistryEntry {
            entity: Entity {
                name: name.to_string(),
                label,
                fields: Vec::new(),
                id: None,
                line: 1,
            },
            path: PathBuf::from(path),
        }
    }

    #[test]
    fn registry_from_entries_lookup() {
        let entries = vec![
            make_entry("Alice", Label::Actor, "actors/alice.md"),
            make_entry("Corp Inc", Label::Institution, "institutions/corp-inc.md"),
        ];

        let registry = EntityRegistry::from_entries(entries).unwrap();
        assert_eq!(registry.len(), 2);
        assert!(registry.get_by_name("Alice").is_some());
        assert!(registry.get_by_name("Corp Inc").is_some());
        assert!(registry.get_by_name("Bob").is_none());
    }

    #[test]
    fn registry_detects_duplicate_names() {
        let entries = vec![
            make_entry("Alice", Label::Actor, "actors/alice-a.md"),
            make_entry("Alice", Label::Actor, "actors/alice-b.md"),
        ];

        let errors = EntityRegistry::from_entries(entries).unwrap_err();
        assert!(errors.iter().any(|e| e.message.contains("duplicate")));
    }

    #[test]
    fn registry_names_list() {
        let entries = vec![
            make_entry("Alice", Label::Actor, "actors/alice.md"),
            make_entry("Bob", Label::Actor, "actors/bob.md"),
        ];

        let registry = EntityRegistry::from_entries(entries).unwrap();
        let names = registry.names();
        assert!(names.contains(&"Alice"));
        assert!(names.contains(&"Bob"));
    }

    #[test]
    fn to_kebab_case_conversion() {
        assert_eq!(to_kebab_case("Mark Bonnick"), "mark-bonnick");
        assert_eq!(to_kebab_case("Arsenal FC"), "arsenal-fc");
        assert_eq!(
            to_kebab_case("English Football Club"),
            "english-football-club"
        );
        assert_eq!(to_kebab_case("Bob"), "bob");
    }

    #[test]
    fn validate_filename_matching() {
        let entity = Entity {
            name: "Mark Bonnick".to_string(),
            label: Label::Actor,
            fields: vec![(
                "qualifier".to_string(),
                FieldValue::Single("Arsenal Kit Manager".to_string()),
            )],
            id: None,
            line: 1,
        };

        let mut errors = Vec::new();

        // Correct filename
        validate_filename(
            Path::new("actors/mark-bonnick--arsenal-kit-manager.md"),
            &entity,
            &mut errors,
        );
        assert!(errors.is_empty(), "errors: {errors:?}");

        // Wrong filename
        validate_filename(Path::new("actors/wrong-name.md"), &entity, &mut errors);
        assert!(errors.iter().any(|e| e.message.contains("warning:")));
    }

    #[test]
    fn validate_filename_no_qualifier() {
        let entity = Entity {
            name: "Bob".to_string(),
            label: Label::Actor,
            fields: Vec::new(),
            id: None,
            line: 1,
        };

        let mut errors = Vec::new();
        validate_filename(Path::new("actors/bob.md"), &entity, &mut errors);
        assert!(errors.is_empty(), "errors: {errors:?}");
    }

    #[test]
    fn empty_registry() {
        let registry = EntityRegistry::from_entries(Vec::new()).unwrap();
        assert!(registry.is_empty());
        assert_eq!(registry.len(), 0);
        assert!(registry.get_by_name("anything").is_none());
    }
}