ryo-app 0.1.0

//! Type definitions for Spec DSL
//!
//! These types map directly to the YAML schema.

use serde::{Deserialize, Serialize};

/// Root specification for domain-driven construction
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DomainSpec {
    /// Project metadata
    pub project: ProjectSpec,

    /// Module structure definitions
    #[serde(default)]
    pub modules: Vec<ModuleSpec>,

    /// Common types (newtypes, value objects)
    #[serde(default)]
    pub common_types: Option<CommonTypesSpec>,

    /// Domain entities
    #[serde(default)]
    pub entities: Vec<EntitySpec>,

    /// Error type definitions
    #[serde(default)]
    pub errors: Vec<ErrorSpec>,

    /// Implementation blocks
    #[serde(default)]
    pub implementations: Vec<ImplSpec>,

    /// Refactoring steps
    #[serde(default)]
    pub refactors: Vec<RefactorSpec>,

    /// Verification points
    #[serde(default)]
    pub verification: Option<VerificationSpec>,
}

/// Project metadata
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProjectSpec {
    /// Project name
    pub name: String,

    /// Crate name (defaults to project name with underscores)
    #[serde(default)]
    pub crate_name: Option<String>,
}

impl ProjectSpec {
    pub fn crate_name(&self) -> String {
        self.crate_name
            .clone()
            .unwrap_or_else(|| self.name.replace('-', "_"))
    }
}

/// Module definition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModuleSpec {
    /// Module name
    pub name: String,

    /// Is public
    #[serde(default)]
    pub is_pub: bool,

    /// Child modules
    #[serde(default)]
    pub children: Vec<ModuleSpec>,
}

impl ModuleSpec {
    /// Flatten module tree into (path, is_pub) pairs
    pub fn flatten(&self, parent_path: &str) -> Vec<(String, bool)> {
        let mut result = Vec::new();
        let path = if parent_path.is_empty() {
            self.name.clone()
        } else {
            format!("{}::{}", parent_path, self.name)
        };

        result.push((path.clone(), self.is_pub));

        for child in &self.children {
            result.extend(child.flatten(&path));
        }

        result
    }
}

/// Common types specification
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CommonTypesSpec {
    /// Newtype definitions
    #[serde(default)]
    pub newtypes: Vec<NewtypeSpec>,

    /// Value object definitions
    #[serde(default)]
    pub value_objects: Vec<EntitySpec>,
}

/// Newtype definition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NewtypeSpec {
    /// Type name
    pub name: String,

    /// Inner type
    pub inner: String,

    /// Target module
    pub module: String,

    /// Derive macros
    #[serde(default)]
    pub derives: Vec<String>,
}

/// Entity (struct/enum) definition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EntitySpec {
    /// Entity name
    pub name: String,

    /// Target module
    #[serde(default)]
    pub module: String,

    /// Kind (struct or enum)
    #[serde(default)]
    pub kind: EntityKind,

    /// Fields (for structs)
    #[serde(default)]
    pub fields: Vec<FieldSpec>,

    /// Variants (for enums)
    #[serde(default)]
    pub variants: Vec<VariantSpec>,

    /// Derive macros
    #[serde(default)]
    pub derives: Vec<String>,
}

/// Entity kind
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum EntityKind {
    #[default]
    Struct,
    Enum,
    Newtype,
}

/// Field definition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FieldSpec {
    /// Field name
    pub name: String,

    /// Field type
    #[serde(rename = "type")]
    pub ty: String,

    /// Is public
    #[serde(default)]
    pub is_pub: bool,
}

/// Variant definition (for enums)
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum VariantSpec {
    /// Simple unit variant: "Active"
    Unit(String),

    /// Complex variant with type: { name: "NotFound", type: "struct:entity:String" }
    Complex {
        name: String,
        #[serde(rename = "type", default)]
        variant_type: Option<String>,
    },
}

impl VariantSpec {
    pub fn name(&self) -> &str {
        match self {
            VariantSpec::Unit(name) => name,
            VariantSpec::Complex { name, .. } => name,
        }
    }

    pub fn variant_type(&self) -> Option<&str> {
        match self {
            VariantSpec::Unit(_) => None,
            VariantSpec::Complex { variant_type, .. } => variant_type.as_deref(),
        }
    }
}

/// Error type definition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ErrorSpec {
    /// Error type name
    pub name: String,

    /// Target module
    pub module: String,

    /// Kind (always enum for errors)
    #[serde(default)]
    pub kind: EntityKind,

    /// Variants
    #[serde(default)]
    pub variants: Vec<VariantSpec>,

    /// Derive macros
    #[serde(default)]
    pub derives: Vec<String>,
}

/// Implementation block definition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImplSpec {
    /// Target type
    pub target: String,

    /// Trait to implement (None for inherent impl)
    #[serde(default)]
    pub trait_name: Option<String>,

    /// Methods
    #[serde(default)]
    pub methods: Vec<MethodSpec>,
}

/// Method definition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MethodSpec {
    /// Method name
    pub name: String,

    /// Self parameter: "ref", "mut", "owned", or null
    #[serde(default)]
    pub self_param: Option<SelfParamSpec>,

    /// Parameters: [[name, type], ...]
    #[serde(default)]
    pub params: Vec<(String, String)>,

    /// Return type (None for unit)
    #[serde(default)]
    pub return_type: Option<String>,

    /// Method body
    #[serde(default = "default_body")]
    pub body: String,

    /// Is public
    #[serde(default)]
    pub is_pub: bool,
}

fn default_body() -> String {
    "todo!()".to_string()
}

/// Self parameter kind
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum SelfParamSpec {
    Ref,
    Mut,
    Owned,
}

/// Refactoring step definition
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind")]
pub enum RefactorSpec {
    /// Add builder pattern
    AddBuilderPattern { targets: Vec<String> },

    /// Add From/Into implementations
    AddFromInto { pairs: Vec<(String, String)> },

    /// Add Default implementation
    AddDefault { targets: Vec<String> },

    /// Organize imports
    OrganizeImports {
        #[serde(default)]
        target_modules: TargetModules,
    },
}

/// Target modules specification
#[derive(Debug, Clone, Default, Serialize)]
pub enum TargetModules {
    #[default]
    All,
    List(Vec<String>),
}

impl<'de> Deserialize<'de> for TargetModules {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        use serde::de::{self, Visitor};

        struct TargetModulesVisitor;

        impl<'de> Visitor<'de> for TargetModulesVisitor {
            type Value = TargetModules;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str(r#""all" or a list of module names"#)
            }

            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
            where
                E: de::Error,
            {
                if v == "all" {
                    Ok(TargetModules::All)
                } else {
                    Err(de::Error::custom(format!(
                        "expected 'all' or a list, got '{}'",
                        v
                    )))
                }
            }

            fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
            where
                A: de::SeqAccess<'de>,
            {
                let modules = Vec::deserialize(de::value::SeqAccessDeserializer::new(seq))?;
                Ok(TargetModules::List(modules))
            }

            fn visit_unit<E>(self) -> Result<Self::Value, E>
            where
                E: de::Error,
            {
                Ok(TargetModules::All)
            }
        }

        deserializer.deserialize_any(TargetModulesVisitor)
    }
}

impl TargetModules {
    pub fn is_all(&self) -> bool {
        matches!(self, TargetModules::All)
    }
}

/// Verification specification
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct VerificationSpec {
    /// After Phase 1
    #[serde(default)]
    pub phase1: Vec<VerificationPointSpec>,

    /// After Phase 2
    #[serde(default)]
    pub phase2: Vec<VerificationPointSpec>,

    /// After Phase 3
    #[serde(default)]
    pub phase3: Vec<VerificationPointSpec>,

    /// After Phase 4
    #[serde(default)]
    pub phase4: Vec<VerificationPointSpec>,

    /// After Phase 5
    #[serde(default)]
    pub phase5: Vec<VerificationPointSpec>,

    /// After Phase 6
    #[serde(default)]
    pub phase6: Vec<VerificationPointSpec>,

    /// Final verification
    #[serde(default, rename = "final")]
    pub final_: Vec<VerificationPointSpec>,
}

/// Verification point definition
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind")]
pub enum VerificationPointSpec {
    /// Check module exists
    ModuleExists { paths: Vec<String> },

    /// Check type exists
    TypeExists { types: Vec<String> },

    /// Check type has specific derive
    HasDerive {
        #[serde(rename = "type")]
        ty: String,
        derives: Vec<String>,
    },

    /// Check struct has specific field
    HasField {
        #[serde(rename = "type")]
        ty: String,
        field: String,
        field_type: String,
    },

    /// Check type has specific method
    MethodExists {
        #[serde(rename = "type")]
        ty: String,
        method: String,
    },

    /// Check compilation
    Compiles,

    /// Check no warnings (except allowed)
    NoWarnings {
        #[serde(default)]
        allowed: Vec<String>,
    },
}

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

    #[test]
    fn test_module_flatten() {
        let module = ModuleSpec {
            name: "lib".to_string(),
            is_pub: true,
            children: vec![
                ModuleSpec {
                    name: "user".to_string(),
                    is_pub: true,
                    children: vec![],
                },
                ModuleSpec {
                    name: "common".to_string(),
                    is_pub: true,
                    children: vec![ModuleSpec {
                        name: "types".to_string(),
                        is_pub: true,
                        children: vec![],
                    }],
                },
            ],
        };

        let flattened = module.flatten("");
        assert_eq!(flattened.len(), 4);
        assert!(flattened.iter().any(|(p, _)| p == "lib"));
        assert!(flattened.iter().any(|(p, _)| p == "lib::user"));
        assert!(flattened.iter().any(|(p, _)| p == "lib::common"));
        assert!(flattened.iter().any(|(p, _)| p == "lib::common::types"));
    }

    #[test]
    fn test_variant_spec_parsing() {
        // Unit variant
        let yaml = r#""Active""#;
        let variant: VariantSpec = serde_yaml::from_str(yaml).unwrap();
        assert_eq!(variant.name(), "Active");
        assert!(variant.variant_type().is_none());

        // Complex variant
        let yaml = r#"{ name: "NotFound", type: "struct:entity:String" }"#;
        let variant: VariantSpec = serde_yaml::from_str(yaml).unwrap();
        assert_eq!(variant.name(), "NotFound");
        assert_eq!(variant.variant_type(), Some("struct:entity:String"));
    }
}