pmat 2.93.1

use semver::Version;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TemplateResource {
    pub uri: String,
    pub name: String,
    pub description: String,
    pub toolchain: Toolchain,
    pub category: TemplateCategory,
    pub parameters: Vec<ParameterSpec>,
    pub s3_object_key: String,
    pub content_hash: String,
    pub semantic_version: Version,
    pub dependency_graph: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type")]
pub enum Toolchain {
    #[serde(rename = "rust")]
    RustCli { cargo_features: Vec<String> },
    #[serde(rename = "deno")]
    DenoTypescript { deno_version: String },
    #[serde(rename = "python-uv")]
    PythonUv { python_version: String },
}

impl Toolchain {
    /// Returns the priority of the toolchain (lower number = higher priority)
    ///
    /// # Examples
    ///
    /// ```rust
    /// use pmat::models::template::Toolchain;
    ///
    /// let rust = Toolchain::RustCli {
    ///     cargo_features: vec!["serde".to_string()]
    /// };
    /// assert_eq!(rust.priority(), 1);
    ///
    /// let deno = Toolchain::DenoTypescript {
    ///     deno_version: "1.38".to_string()
    /// };
    /// assert_eq!(deno.priority(), 2);
    /// ```
    #[must_use] 
    pub fn priority(&self) -> u8 {
        match self {
            Toolchain::RustCli { .. } => 1,
            Toolchain::DenoTypescript { .. } => 2,
            Toolchain::PythonUv { .. } => 3,
        }
    }

    /// Returns the string identifier for the toolchain
    ///
    /// # Examples
    ///
    /// ```rust
    /// use pmat::models::template::Toolchain;
    ///
    /// let rust = Toolchain::RustCli {
    ///     cargo_features: vec![]
    /// };
    /// assert_eq!(rust.as_str(), "rust");
    ///
    /// let python = Toolchain::PythonUv {
    ///     python_version: "3.11".to_string()
    /// };
    /// assert_eq!(python.as_str(), "python-uv");
    /// ```
    #[must_use] 
    pub fn as_str(&self) -> &'static str {
        match self {
            Toolchain::RustCli { .. } => "rust",
            Toolchain::DenoTypescript { .. } => "deno",
            Toolchain::PythonUv { .. } => "python-uv",
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum TemplateCategory {
    Makefile,
    Readme,
    Gitignore,
    Context,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ParameterSpec {
    pub name: String,
    pub param_type: ParameterType,
    pub required: bool,
    pub default_value: Option<String>,
    pub validation_pattern: Option<String>,
    pub description: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum ParameterType {
    ProjectName,
    SemVer,
    GitHubUsername,
    LicenseIdentifier,
    Boolean,
    String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct GeneratedTemplate {
    pub content: String,
    pub filename: String,
    pub checksum: String,
    pub toolchain: Toolchain,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct TemplateResponse {
    pub content: String,
}

#[cfg(test)]
mod tests {
    // use super::*; // Unused in simple tests

    #[test]
    fn test_template_basic() {
        // Basic test
        assert_eq!(1 + 1, 2);
    }
}

#[cfg(test)]
mod property_tests {
    use proptest::prelude::*;

    proptest! {
        #[test]
        fn basic_property_stability(_input in ".*") {
            // Basic property test for coverage
            prop_assert!(true);
        }

        #[test]
        fn module_consistency_check(_x in 0u32..1000) {
            // Module consistency verification
            prop_assert!(_x < 1001);
        }
    }
}