cml-rs 0.4.0

//! CML Profile System
//!
//! JSON-based profile definitions for validating CML documents.
//! Profiles define allowed elements, attributes, and type vocabularies.
//!
//! ## Directory Structure
//!
//! Each profile lives in its own directory with separate concerns:
//! ```text
//! schemas/0.2/profiles/
//! ├── core/
//! │   ├── core.json        # Element definitions
//! │   └── constraints.json # Validation rules
//! ├── standard/
//! │   ├── standard.json
//! │   ├── constraints.json
//! │   └── dictionary.json  # BytePunch compression
//! └── legal/
//!     ├── legal.json
//!     ├── constraints.json
//!     └── dictionary.json
//! ```
//!
//! ## Profile Hierarchy
//!
//! - **core**: Structural minimum (cml, header, body, footer, title)
//! - **standard**: All v0.2 elements (extends core)
//! - **legal**: Legal documents (extends standard with include whitelist)
//! - **code**: API documentation (extends standard)
//! - **bookstack**: Wiki-style documentation (extends standard)

use crate::{CmlError, Result};
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};
use std::path::Path;

/// A CML profile definition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Profile {
    /// Profile name (e.g., "core", "standard", "legal")
    pub name: String,

    /// Profile version
    pub version: String,

    /// Parent profile to inherit from
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extends: Option<String>,

    /// Human-readable description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,

    /// Whitelist of elements to include from parent
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub include: Vec<String>,

    /// Blacklist of elements to exclude from parent
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub exclude: Vec<String>,

    /// Element definitions
    #[serde(default)]
    pub elements: HashMap<String, ElementDef>,

    /// Global attribute definitions
    #[serde(default)]
    pub attributes: HashMap<String, AttributeDef>,

    /// Type vocabularies (enums for type attributes)
    #[serde(default)]
    pub types: HashMap<String, Vec<String>>,
}

/// Element definition within a profile
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ElementDef {
    /// Human-readable description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,

    /// Content model: "empty", "text", "inline", "block", "mixed"
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,

    /// Attribute definitions for this element
    #[serde(default)]
    pub attributes: HashMap<String, AttributeDef>,

    /// Allowed child elements
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub children: Vec<String>,

    /// Valid parent elements
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub parents: Vec<String>,

    /// Required child elements
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub required_children: Vec<String>,

    /// Minimum occurrences
    #[serde(skip_serializing_if = "Option::is_none")]
    pub min_occurs: Option<u32>,

    /// Maximum occurrences
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_occurs: Option<u32>,
}

/// Attribute definition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AttributeDef {
    /// Human-readable description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,

    /// Attribute type: "string", "integer", "boolean", "date", "uri", "enum"
    #[serde(rename = "type", default = "default_attr_type")]
    pub attr_type: String,

    /// Whether the attribute is required
    #[serde(default)]
    pub required: bool,

    /// Default value
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default: Option<String>,

    /// Valid values if type is "enum"
    #[serde(rename = "enum", default, skip_serializing_if = "Vec::is_empty")]
    pub enum_values: Vec<String>,

    /// Regex pattern for validation
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pattern: Option<String>,
}

fn default_attr_type() -> String {
    "string".to_string()
}

// =============================================================================
// Constraint Types
// =============================================================================

/// Profile constraints definition
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ProfileConstraints {
    /// Profile this constraint applies to
    #[serde(default)]
    pub profile: String,

    /// Constraint version
    #[serde(default)]
    pub version: String,

    /// Parent constraints to inherit from
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extends: Option<String>,

    /// Description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,

    /// Document-level constraints
    #[serde(default)]
    pub document: Option<DocumentConstraint>,

    /// Element-specific constraints
    #[serde(default)]
    pub elements: HashMap<String, ElementConstraint>,

    /// Attribute validation rules
    #[serde(default)]
    pub attributes: HashMap<String, AttributeConstraint>,

    /// Parent-child relationship constraints
    #[serde(default)]
    pub hierarchy: HashMap<String, HierarchyConstraint>,

    /// Nesting constraints
    #[serde(default)]
    pub nesting: Option<NestingConstraint>,

    /// List-specific constraints
    #[serde(default)]
    pub list_constraints: Option<ListConstraints>,

    /// Semantic rules
    #[serde(default)]
    pub semantic_rules: HashMap<String, SemanticRule>,
}

/// Document-level constraints
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DocumentConstraint {
    /// Required attributes on root element
    #[serde(default)]
    pub required_attributes: Vec<String>,

    /// Required child elements
    #[serde(default)]
    pub required_children: Vec<String>,

    /// Required order of children
    #[serde(default)]
    pub child_order: Vec<String>,
}

/// Element-specific constraint
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ElementConstraint {
    /// Minimum occurrences
    #[serde(skip_serializing_if = "Option::is_none")]
    pub min_occurs: Option<u32>,

    /// Maximum occurrences
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_occurs: Option<u32>,

    /// Minimum number of children
    #[serde(skip_serializing_if = "Option::is_none")]
    pub min_children: Option<u32>,

    /// Maximum number of children
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_children: Option<u32>,

    /// Minimum content length
    #[serde(skip_serializing_if = "Option::is_none")]
    pub min_content: Option<u32>,

    /// Minimum text length
    #[serde(skip_serializing_if = "Option::is_none")]
    pub min_length: Option<u32>,

    /// Required attributes
    #[serde(default)]
    pub required_attributes: Vec<String>,

    /// Required children
    #[serde(default)]
    pub required_children: Vec<String>,

    /// Required child types
    #[serde(default)]
    pub required_child_types: Vec<String>,

    /// Preserve whitespace
    #[serde(default)]
    pub preserve_whitespace: bool,

    /// Disallow nesting
    #[serde(default)]
    pub no_nesting: bool,

    /// Allow self-nesting
    #[serde(default)]
    pub allow_nesting: bool,

    /// Reserved for future use
    #[serde(default)]
    pub reserved: bool,

    /// Warning message
    #[serde(skip_serializing_if = "Option::is_none")]
    pub warning: Option<String>,

    /// Size constraints
    #[serde(skip_serializing_if = "Option::is_none")]
    pub size: Option<SizeConstraint>,
}

/// Size constraint for heading levels etc.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SizeConstraint {
    pub min: Option<u32>,
    pub max: Option<u32>,
}

/// Attribute constraint
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct AttributeConstraint {
    /// Description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,

    /// Type (string, integer, boolean, etc.)
    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
    pub attr_type: Option<String>,

    /// Format (iso8601, uri, etc.)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub format: Option<String>,

    /// Regex pattern
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pattern: Option<String>,

    /// Enum values
    #[serde(rename = "enum", default)]
    pub enum_values: Vec<String>,

    /// Recommended values
    #[serde(default)]
    pub recommended: Vec<String>,

    /// Must be unique across document
    #[serde(default)]
    pub unique: bool,

    /// Minimum value
    #[serde(skip_serializing_if = "Option::is_none")]
    pub min: Option<i32>,

    /// Maximum value
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max: Option<i32>,

    /// Default value
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default: Option<serde_json::Value>,
}

/// Hierarchy constraint
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct HierarchyConstraint {
    /// Allowed parent elements
    #[serde(default)]
    pub allowed_parents: Vec<String>,

    /// Allowed child elements
    #[serde(default)]
    pub allowed_children: Vec<String>,

    /// Maximum occurrences within parent
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_occurs: Option<u32>,

    /// Must be first child of parent
    #[serde(default)]
    pub must_be_first: bool,
}

/// Nesting constraints
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct NestingConstraint {
    /// Maximum section nesting depth
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_section_depth: Option<u32>,

    /// Maximum inline nesting depth
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_inline_depth: Option<u32>,

    /// Elements that cannot self-nest
    #[serde(default)]
    pub no_self_nesting: Vec<String>,
}

/// List-specific constraints
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ListConstraints {
    /// Ordered list constraints
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ordered: Option<OrderedListConstraint>,

    /// Unordered list constraints
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unordered: Option<UnorderedListConstraint>,
}

/// Ordered list constraint
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct OrderedListConstraint {
    /// Order enforcement: "alphanumeric", "numeric", "none"
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enforce_order: Option<String>,

    /// Description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}

/// Unordered list constraint
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct UnorderedListConstraint {
    /// Description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}

/// Semantic rule
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SemanticRule {
    /// Description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,

    /// Preferred element
    #[serde(skip_serializing_if = "Option::is_none")]
    pub prefer: Option<String>,

    /// Element to avoid
    #[serde(skip_serializing_if = "Option::is_none")]
    pub instead_of: Option<String>,
}

/// Resolved constraints with inheritance applied
#[derive(Debug, Clone, Default)]
pub struct ResolvedConstraints {
    /// Profile name
    pub profile: String,

    /// Document constraints
    pub document: Option<DocumentConstraint>,

    /// Element constraints
    pub elements: HashMap<String, ElementConstraint>,

    /// Attribute constraints
    pub attributes: HashMap<String, AttributeConstraint>,

    /// Hierarchy constraints
    pub hierarchy: HashMap<String, HierarchyConstraint>,

    /// Nesting constraints
    pub nesting: Option<NestingConstraint>,

    /// List constraints
    pub list_constraints: Option<ListConstraints>,

    /// Semantic rules
    pub semantic_rules: HashMap<String, SemanticRule>,
}

/// Resolved profile with inheritance applied
#[derive(Debug, Clone)]
pub struct ResolvedProfile {
    /// Profile name
    pub name: String,

    /// Profile version
    pub version: String,

    /// All allowed elements (after inheritance + include/exclude)
    pub elements: HashMap<String, ElementDef>,

    /// All type vocabularies (merged from inheritance chain)
    pub types: HashMap<String, Vec<String>>,
}

/// Profile registry for loading and resolving profiles
pub struct ProfileRegistry {
    /// Loaded profiles by name
    profiles: HashMap<String, Profile>,

    /// Resolved profiles (with inheritance applied)
    resolved: HashMap<String, ResolvedProfile>,
}

impl ProfileRegistry {
    /// Create a new empty registry
    pub fn new() -> Self {
        Self {
            profiles: HashMap::new(),
            resolved: HashMap::new(),
        }
    }

    /// Create a registry with built-in profiles
    pub fn with_builtins() -> Result<Self> {
        let mut registry = Self::new();
        registry.load_builtin_profiles()?;
        Ok(registry)
    }

    /// Load built-in profiles (core, standard, legal, legal:constitution, code, code:api, wiki)
    fn load_builtin_profiles(&mut self) -> Result<()> {
        // Core profile
        let core: Profile = serde_json::from_str(include_str!(
            "../schemas/0.2/profiles/core/core.json"
        ))
        .map_err(|e| CmlError::ValidationError(format!("Failed to parse core profile: {}", e)))?;
        self.profiles.insert("core".to_string(), core);

        // Standard profile
        let standard: Profile = serde_json::from_str(include_str!(
            "../schemas/0.2/profiles/standard/standard.json"
        ))
        .map_err(|e| {
            CmlError::ValidationError(format!("Failed to parse standard profile: {}", e))
        })?;
        self.profiles.insert("standard".to_string(), standard);

        // Legal profile (base)
        let legal: Profile =
            serde_json::from_str(include_str!("../schemas/0.2/profiles/legal/legal.json"))
                .map_err(|e| {
                    CmlError::ValidationError(format!("Failed to parse legal profile: {}", e))
                })?;
        self.profiles.insert("legal".to_string(), legal);

        // Legal:constitution sub-profile
        let legal_constitution: Profile = serde_json::from_str(include_str!(
            "../schemas/0.2/profiles/legal/constitution/constitution.json"
        ))
        .map_err(|e| {
            CmlError::ValidationError(format!("Failed to parse legal:constitution profile: {}", e))
        })?;
        self.profiles
            .insert("legal:constitution".to_string(), legal_constitution);

        // Code profile (base)
        let code: Profile = serde_json::from_str(include_str!(
            "../schemas/0.2/profiles/code/code.json"
        ))
        .map_err(|e| CmlError::ValidationError(format!("Failed to parse code profile: {}", e)))?;
        self.profiles.insert("code".to_string(), code);

        // Code:api sub-profile
        let code_api: Profile =
            serde_json::from_str(include_str!("../schemas/0.2/profiles/code/api/api.json"))
                .map_err(|e| {
                    CmlError::ValidationError(format!("Failed to parse code:api profile: {}", e))
                })?;
        self.profiles.insert("code:api".to_string(), code_api);

        // Wiki profile
        let wiki: Profile = serde_json::from_str(include_str!(
            "../schemas/0.2/profiles/wiki/wiki.json"
        ))
        .map_err(|e| CmlError::ValidationError(format!("Failed to parse wiki profile: {}", e)))?;
        self.profiles.insert("wiki".to_string(), wiki);

        Ok(())
    }

    /// Load a profile from a JSON file
    pub fn load_from_file<P: AsRef<Path>>(&mut self, path: P) -> Result<()> {
        let content = std::fs::read_to_string(path.as_ref())?;
        let profile: Profile = serde_json::from_str(&content)
            .map_err(|e| CmlError::ValidationError(format!("Failed to parse profile: {}", e)))?;
        self.profiles.insert(profile.name.clone(), profile);
        Ok(())
    }

    /// Load a profile from a JSON string
    pub fn load_from_str(&mut self, json: &str) -> Result<()> {
        let profile: Profile = serde_json::from_str(json)
            .map_err(|e| CmlError::ValidationError(format!("Failed to parse profile: {}", e)))?;
        self.profiles.insert(profile.name.clone(), profile);
        Ok(())
    }

    /// Get a resolved profile by name
    pub fn get(&mut self, name: &str) -> Result<&ResolvedProfile> {
        // Check if already resolved
        if self.resolved.contains_key(name) {
            return Ok(self.resolved.get(name).unwrap());
        }

        // Resolve the profile
        let resolved = self.resolve_profile(name)?;
        self.resolved.insert(name.to_string(), resolved);
        Ok(self.resolved.get(name).unwrap())
    }

    /// Resolve a profile with inheritance
    fn resolve_profile(&self, name: &str) -> Result<ResolvedProfile> {
        let profile = self
            .profiles
            .get(name)
            .ok_or_else(|| CmlError::ValidationError(format!("Profile not found: {}", name)))?;

        // Start with parent profile if exists
        let mut elements: HashMap<String, ElementDef> = HashMap::new();
        let mut types: HashMap<String, Vec<String>> = HashMap::new();

        if let Some(parent_name) = &profile.extends {
            let parent = self.resolve_profile(parent_name)?;

            // Apply include/exclude filtering
            if !profile.include.is_empty() {
                // Whitelist mode: only include specified elements
                let include_set: HashSet<&str> =
                    profile.include.iter().map(|s| s.as_str()).collect();
                for (name, def) in parent.elements {
                    if include_set.contains(name.as_str()) {
                        elements.insert(name, def);
                    }
                }
            } else if !profile.exclude.is_empty() {
                // Blacklist mode: exclude specified elements
                let exclude_set: HashSet<&str> =
                    profile.exclude.iter().map(|s| s.as_str()).collect();
                for (name, def) in parent.elements {
                    if !exclude_set.contains(name.as_str()) {
                        elements.insert(name, def);
                    }
                }
            } else {
                // No filtering: inherit all
                elements = parent.elements;
            }

            // Inherit types
            types = parent.types;
        }

        // Add/override with this profile's elements
        for (name, def) in &profile.elements {
            elements.insert(name.clone(), def.clone());
        }

        // Merge types (profile types override parent)
        for (name, values) in &profile.types {
            types.insert(name.clone(), values.clone());
        }

        Ok(ResolvedProfile {
            name: profile.name.clone(),
            version: profile.version.clone(),
            elements,
            types,
        })
    }

    /// Check if an element is allowed in a profile
    pub fn is_element_allowed(&mut self, profile: &str, element: &str) -> Result<bool> {
        let resolved = self.get(profile)?;
        Ok(resolved.elements.contains_key(element))
    }

    /// Get valid type values for an element
    pub fn get_type_values(
        &mut self,
        profile: &str,
        type_name: &str,
    ) -> Result<Option<Vec<String>>> {
        let resolved = self.get(profile)?;
        Ok(resolved.types.get(type_name).cloned())
    }

    /// Validate a type value against the profile
    pub fn validate_type_value(
        &mut self,
        profile: &str,
        type_name: &str,
        value: &str,
    ) -> Result<bool> {
        let resolved = self.get(profile)?;
        match resolved.types.get(type_name) {
            Some(values) => Ok(values.contains(&value.to_string())),
            None => Ok(true), // No restriction if type not defined
        }
    }
}

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

// =============================================================================
// Constraint Registry
// =============================================================================

/// Constraint registry for loading and resolving profile constraints
pub struct ConstraintRegistry {
    /// Loaded constraints by profile name
    constraints: HashMap<String, ProfileConstraints>,

    /// Resolved constraints (with inheritance applied)
    resolved: HashMap<String, ResolvedConstraints>,
}

impl ConstraintRegistry {
    /// Create a new empty registry
    pub fn new() -> Self {
        Self {
            constraints: HashMap::new(),
            resolved: HashMap::new(),
        }
    }

    /// Create a registry with built-in constraints
    pub fn with_builtins() -> Result<Self> {
        let mut registry = Self::new();
        registry.load_builtin_constraints()?;
        Ok(registry)
    }

    /// Load built-in constraints
    fn load_builtin_constraints(&mut self) -> Result<()> {
        // Core constraints
        let core: ProfileConstraints = serde_json::from_str(include_str!(
            "../schemas/0.2/profiles/core/constraints.json"
        ))
        .map_err(|e| {
            CmlError::ValidationError(format!("Failed to parse core constraints: {}", e))
        })?;
        self.constraints.insert("core".to_string(), core);

        // Standard constraints
        let standard: ProfileConstraints = serde_json::from_str(include_str!(
            "../schemas/0.2/profiles/standard/constraints.json"
        ))
        .map_err(|e| {
            CmlError::ValidationError(format!("Failed to parse standard constraints: {}", e))
        })?;
        self.constraints.insert("standard".to_string(), standard);

        // Legal constraints
        let legal: ProfileConstraints = serde_json::from_str(include_str!(
            "../schemas/0.2/profiles/legal/constraints.json"
        ))
        .map_err(|e| {
            CmlError::ValidationError(format!("Failed to parse legal constraints: {}", e))
        })?;
        self.constraints.insert("legal".to_string(), legal);

        // Code constraints
        let code: ProfileConstraints = serde_json::from_str(include_str!(
            "../schemas/0.2/profiles/code/constraints.json"
        ))
        .map_err(|e| {
            CmlError::ValidationError(format!("Failed to parse code constraints: {}", e))
        })?;
        self.constraints.insert("code".to_string(), code);

        // Wiki constraints
        let wiki: ProfileConstraints = serde_json::from_str(include_str!(
            "../schemas/0.2/profiles/wiki/constraints.json"
        ))
        .map_err(|e| {
            CmlError::ValidationError(format!("Failed to parse wiki constraints: {}", e))
        })?;
        self.constraints.insert("wiki".to_string(), wiki);

        Ok(())
    }

    /// Load constraints from a JSON string
    pub fn load_from_str(&mut self, json: &str) -> Result<()> {
        let constraints: ProfileConstraints = serde_json::from_str(json).map_err(|e| {
            CmlError::ValidationError(format!("Failed to parse constraints: {}", e))
        })?;
        self.constraints
            .insert(constraints.profile.clone(), constraints);
        Ok(())
    }

    /// Get resolved constraints by profile name
    pub fn get(&mut self, name: &str) -> Result<&ResolvedConstraints> {
        if self.resolved.contains_key(name) {
            return Ok(self.resolved.get(name).unwrap());
        }

        let resolved = self.resolve_constraints(name)?;
        self.resolved.insert(name.to_string(), resolved);
        Ok(self.resolved.get(name).unwrap())
    }

    /// Resolve constraints with inheritance
    fn resolve_constraints(&self, name: &str) -> Result<ResolvedConstraints> {
        let constraints = self
            .constraints
            .get(name)
            .ok_or_else(|| CmlError::ValidationError(format!("Constraints not found: {}", name)))?;

        let mut resolved = ResolvedConstraints {
            profile: name.to_string(),
            ..Default::default()
        };

        // Inherit from parent if exists
        if let Some(parent_name) = &constraints.extends {
            let parent = self.resolve_constraints(parent_name)?;
            resolved.document = parent.document;
            resolved.elements = parent.elements;
            resolved.attributes = parent.attributes;
            resolved.hierarchy = parent.hierarchy;
            resolved.nesting = parent.nesting;
            resolved.list_constraints = parent.list_constraints;
            resolved.semantic_rules = parent.semantic_rules;
        }

        // Override with this profile's constraints
        if constraints.document.is_some() {
            resolved.document = constraints.document.clone();
        }

        for (name, constraint) in &constraints.elements {
            resolved.elements.insert(name.clone(), constraint.clone());
        }

        for (name, constraint) in &constraints.attributes {
            resolved.attributes.insert(name.clone(), constraint.clone());
        }

        for (name, constraint) in &constraints.hierarchy {
            resolved.hierarchy.insert(name.clone(), constraint.clone());
        }

        if constraints.nesting.is_some() {
            resolved.nesting = constraints.nesting.clone();
        }

        if constraints.list_constraints.is_some() {
            resolved.list_constraints = constraints.list_constraints.clone();
        }

        for (name, rule) in &constraints.semantic_rules {
            resolved.semantic_rules.insert(name.clone(), rule.clone());
        }

        Ok(resolved)
    }
}

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

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

    #[test]
    fn test_load_core_profile() {
        let json = r#"{
            "name": "test-core",
            "version": "0.2",
            "elements": {
                "cml": { "content": "block" },
                "header": { "content": "block" },
                "body": { "content": "block" },
                "footer": { "content": "block" }
            }
        }"#;

        let profile: Profile = serde_json::from_str(json).unwrap();
        assert_eq!(profile.name, "test-core");
        assert_eq!(profile.elements.len(), 4);
    }

    #[test]
    fn test_profile_inheritance() {
        let mut registry = ProfileRegistry::new();

        // Load parent
        registry
            .load_from_str(
                r#"{
                "name": "parent",
                "version": "0.2",
                "elements": {
                    "a": { "content": "text" },
                    "b": { "content": "text" },
                    "c": { "content": "text" }
                }
            }"#,
            )
            .unwrap();

        // Load child with include whitelist
        registry
            .load_from_str(
                r#"{
                "name": "child",
                "version": "0.2",
                "extends": "parent",
                "include": ["a", "b"],
                "elements": {
                    "d": { "content": "text" }
                }
            }"#,
            )
            .unwrap();

        let resolved = registry.get("child").unwrap();
        assert!(resolved.elements.contains_key("a"));
        assert!(resolved.elements.contains_key("b"));
        assert!(!resolved.elements.contains_key("c")); // Excluded by whitelist
        assert!(resolved.elements.contains_key("d")); // Added by child
    }

    #[test]
    fn test_type_vocabularies() {
        let mut registry = ProfileRegistry::new();

        registry
            .load_from_str(
                r#"{
                "name": "typed",
                "version": "0.2",
                "types": {
                    "date": ["created", "updated", "published"],
                    "section": ["intro", "body", "conclusion"]
                }
            }"#,
            )
            .unwrap();

        assert!(registry
            .validate_type_value("typed", "date", "created")
            .unwrap());
        assert!(registry
            .validate_type_value("typed", "date", "published")
            .unwrap());
        assert!(!registry
            .validate_type_value("typed", "date", "invalid")
            .unwrap());
    }
}