chant/

scoring.rs

//! Spec quality scoring system
//!
//! Multi-dimensional analysis of spec quality including complexity, confidence,
//! splittability, isolation, and acceptance criteria quality.

use serde::{Deserialize, Serialize};
use std::fmt;

/// Macro to generate Display implementations for letter grade enums (A, B, C, D)
macro_rules! impl_letter_grade_display {
    ($type:ty) => {
        impl fmt::Display for $type {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                match self {
                    Self::A => write!(f, "A"),
                    Self::B => write!(f, "B"),
                    Self::C => write!(f, "C"),
                    Self::D => write!(f, "D"),
                }
            }
        }
    };
}

/// Overall score for a spec across all dimensions
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SpecScore {
    /// Complexity grade (size/effort)
    pub complexity: ComplexityGrade,
    /// Confidence grade (structure/clarity)
    pub confidence: ConfidenceGrade,
    /// Splittability grade (decomposability)
    pub splittability: SplittabilityGrade,
    /// Isolation grade (group/split quality) - only for groups with members
    pub isolation: Option<IsolationGrade>,
    /// Acceptance criteria quality grade
    pub ac_quality: ACQualityGrade,
    /// Overall traffic light status
    pub traffic_light: TrafficLight,
}

impl Default for SpecScore {
    fn default() -> Self {
        Self {
            complexity: ComplexityGrade::A,
            confidence: ConfidenceGrade::A,
            splittability: SplittabilityGrade::A,
            isolation: None,
            ac_quality: ACQualityGrade::A,
            traffic_light: TrafficLight::Ready,
        }
    }
}

/// Complexity grade based on criteria count, target files, and word count
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ComplexityGrade {
    /// 1-3 criteria, 1-2 files, <200 words
    A,
    /// 4-5 criteria, 3 files, 200-400 words
    B,
    /// 6-7 criteria, 4 files, 400-600 words
    C,
    /// 8+ criteria, 5+ files, 600+ words
    D,
}

impl_letter_grade_display!(ComplexityGrade);

/// Confidence grade based on structure and clarity
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ConfidenceGrade {
    /// Excellent structure, clear requirements
    A,
    /// Good structure, mostly clear
    B,
    /// Some structure issues or vague language
    C,
    /// Poor structure, vague requirements
    D,
}

impl_letter_grade_display!(ConfidenceGrade);

/// Splittability grade - can this spec be effectively split
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum SplittabilityGrade {
    /// Clear subsections, independent tasks, multiple target files
    A,
    /// Some structure, could be split with effort
    B,
    /// Monolithic, single concern, splitting would fragment
    C,
    /// Tightly coupled, splitting would create circular deps
    D,
}

impl_letter_grade_display!(SplittabilityGrade);

/// Isolation grade - for groups with members, measures independence
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum IsolationGrade {
    /// Excellent isolation, minimal cross-references
    A,
    /// Good isolation, some cross-references
    B,
    /// Some coupling, multiple cross-references
    C,
    /// Tightly coupled, many cross-references
    D,
}

impl_letter_grade_display!(IsolationGrade);

/// Acceptance criteria quality grade
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ACQualityGrade {
    /// Excellent AC: imperative, valuable, testable
    A,
    /// Good AC: mostly well-phrased
    B,
    /// Some AC issues
    C,
    /// Poor AC quality
    D,
}

impl_letter_grade_display!(ACQualityGrade);

/// Overall traffic light status combining all dimensions
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum TrafficLight {
    /// Ready - All dimensions pass (Complexity ≤ B AND Confidence ≥ B AND AC Quality ≥ B)
    Ready,
    /// Review - Some dimensions need attention (Any dimension is C)
    Review,
    /// Refine - Significant issues (Any dimension is D OR Confidence is D)
    Refine,
}

impl fmt::Display for TrafficLight {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Ready => write!(f, "🟢 Ready"),
            Self::Review => write!(f, "🟡 Review"),
            Self::Refine => write!(f, "🔴 Refine"),
        }
    }
}

/// Calculate complexity grade based on criteria count, target files, and word count
///
/// Grading rules:
/// - Grade A: 1-3 criteria, 1-2 files, <200 words
/// - Grade B: 4-5 criteria, 3 files, 200-400 words
/// - Grade C: 6-7 criteria, 4 files, 400-600 words
/// - Grade D: 8+ criteria OR 5+ files OR 600+ words
///
/// If any single metric triggers D, overall grade is D.
pub fn calculate_complexity(spec: &crate::spec::Spec) -> ComplexityGrade {
    // Count acceptance criteria
    let criteria_count = spec.count_total_checkboxes();

    // Count target files (default to 0 if None)
    let file_count = spec
        .frontmatter
        .target_files
        .as_ref()
        .map(|files| files.len())
        .unwrap_or(0);

    // Count words in body (split by whitespace, filter empty)
    let word_count = spec.body.split_whitespace().count();

    // Determine grade based on all three metrics
    // If any single metric triggers D, overall is D
    if criteria_count >= 8 || file_count >= 5 || word_count >= 600 {
        return ComplexityGrade::D;
    }

    // Check for Grade C thresholds
    if criteria_count >= 6 || file_count >= 4 || word_count >= 400 {
        return ComplexityGrade::C;
    }

    // Check for Grade B thresholds
    if criteria_count >= 4 || file_count >= 3 || word_count >= 200 {
        return ComplexityGrade::B;
    }

    // Otherwise Grade A
    ComplexityGrade::A
}

/// Extract acceptance criteria from a spec's body
fn extract_acceptance_criteria(spec: &crate::spec::Spec) -> Vec<String> {
    let acceptance_criteria_marker = "## Acceptance Criteria";
    let mut criteria = Vec::new();
    let mut in_code_fence = false;
    let mut in_ac_section = false;

    for line in spec.body.lines() {
        let trimmed = line.trim_start();

        if trimmed.starts_with("```") {
            in_code_fence = !in_code_fence;
            continue;
        }

        if !in_code_fence && trimmed.starts_with(acceptance_criteria_marker) {
            in_ac_section = true;
            continue;
        }

        // Stop if we hit another ## heading
        if in_ac_section && !in_code_fence && trimmed.starts_with("## ") {
            break;
        }

        // Extract checkbox items
        if in_ac_section
            && !in_code_fence
            && (trimmed.starts_with("- [ ]") || trimmed.starts_with("- [x]"))
        {
            // Extract text after checkbox
            let text = trimmed
                .trim_start_matches("- [ ]")
                .trim_start_matches("- [x]")
                .trim()
                .to_string();
            criteria.push(text);
        }
    }

    criteria
}

/// Calculate the overall SpecScore for a given spec
///
/// This function computes all scoring dimensions and determines the traffic light status.
pub fn calculate_spec_score(
    spec: &crate::spec::Spec,
    all_specs: &[crate::spec::Spec],
    config: &crate::config::Config,
) -> SpecScore {
    use crate::score::{ac_quality, confidence, isolation, splittability, traffic_light};

    // Calculate each dimension
    let complexity = calculate_complexity(spec);
    let confidence_grade = confidence::calculate_confidence(spec, config);
    let splittability_grade = splittability::calculate_splittability(spec);
    let isolation_grade = isolation::calculate_isolation(spec, all_specs);

    // Calculate AC quality from the spec's acceptance criteria
    let criteria = extract_acceptance_criteria(spec);
    let ac_quality_grade = ac_quality::calculate_ac_quality(&criteria);

    // Create the score struct
    let mut score = SpecScore {
        complexity,
        confidence: confidence_grade,
        splittability: splittability_grade,
        isolation: isolation_grade,
        ac_quality: ac_quality_grade,
        traffic_light: TrafficLight::Ready, // Temporary, will be recalculated
    };

    // Determine the traffic light status
    score.traffic_light = traffic_light::determine_status(&score);

    score
}

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

    #[test]
    fn test_spec_score_creation_with_all_a() {
        let score = SpecScore {
            complexity: ComplexityGrade::A,
            confidence: ConfidenceGrade::A,
            splittability: SplittabilityGrade::A,
            isolation: Some(IsolationGrade::A),
            ac_quality: ACQualityGrade::A,
            traffic_light: TrafficLight::Ready,
        };

        assert_eq!(score.complexity, ComplexityGrade::A);
        assert_eq!(score.confidence, ConfidenceGrade::A);
        assert_eq!(score.splittability, SplittabilityGrade::A);
        assert_eq!(score.isolation, Some(IsolationGrade::A));
        assert_eq!(score.ac_quality, ACQualityGrade::A);
        assert_eq!(score.traffic_light, TrafficLight::Ready);
    }

    #[test]
    fn test_complexity_grade_display() {
        assert_eq!(ComplexityGrade::B.to_string(), "B");
        assert_eq!(ComplexityGrade::A.to_string(), "A");
        assert_eq!(ComplexityGrade::C.to_string(), "C");
        assert_eq!(ComplexityGrade::D.to_string(), "D");
    }

    #[test]
    fn test_confidence_grade_display() {
        assert_eq!(ConfidenceGrade::B.to_string(), "B");
    }

    #[test]
    fn test_splittability_grade_display() {
        assert_eq!(SplittabilityGrade::B.to_string(), "B");
    }

    #[test]
    fn test_isolation_grade_display() {
        assert_eq!(IsolationGrade::B.to_string(), "B");
    }

    #[test]
    fn test_ac_quality_grade_display() {
        assert_eq!(ACQualityGrade::B.to_string(), "B");
    }

    #[test]
    fn test_traffic_light_display() {
        assert_eq!(TrafficLight::Ready.to_string(), "🟢 Ready");
        assert_eq!(TrafficLight::Review.to_string(), "🟡 Review");
        assert_eq!(TrafficLight::Refine.to_string(), "🔴 Refine");
    }

    #[test]
    fn test_spec_score_serialization() {
        let score = SpecScore {
            complexity: ComplexityGrade::A,
            confidence: ConfidenceGrade::B,
            splittability: SplittabilityGrade::A,
            isolation: None,
            ac_quality: ACQualityGrade::A,
            traffic_light: TrafficLight::Ready,
        };

        let json = serde_json::to_string(&score).unwrap();
        let deserialized: SpecScore = serde_json::from_str(&json).unwrap();

        assert_eq!(deserialized.complexity, ComplexityGrade::A);
        assert_eq!(deserialized.confidence, ConfidenceGrade::B);
        assert_eq!(deserialized.splittability, SplittabilityGrade::A);
        assert_eq!(deserialized.isolation, None);
        assert_eq!(deserialized.ac_quality, ACQualityGrade::A);
        assert_eq!(deserialized.traffic_light, TrafficLight::Ready);
    }

    #[test]
    fn test_isolation_is_optional() {
        let score = SpecScore {
            complexity: ComplexityGrade::A,
            confidence: ConfidenceGrade::A,
            splittability: SplittabilityGrade::A,
            isolation: None, // Should work fine without isolation
            ac_quality: ACQualityGrade::A,
            traffic_light: TrafficLight::Ready,
        };

        assert_eq!(score.isolation, None);
    }

    #[test]
    fn test_default_spec_score() {
        let score = SpecScore::default();
        assert_eq!(score.complexity, ComplexityGrade::A);
        assert_eq!(score.confidence, ConfidenceGrade::A);
        assert_eq!(score.splittability, SplittabilityGrade::A);
        assert_eq!(score.isolation, None);
        assert_eq!(score.ac_quality, ACQualityGrade::A);
        assert_eq!(score.traffic_light, TrafficLight::Ready);
    }

    #[test]
    fn test_calculate_complexity_grade_a() {
        use crate::spec::{Spec, SpecFrontmatter};

        // 2 criteria, 1 file, 150 words → Grade A
        let spec = Spec {
            id: "test".to_string(),
            frontmatter: SpecFrontmatter {
                target_files: Some(vec!["file1.rs".to_string()]),
                ..Default::default()
            },
            title: Some("Test".to_string()),
            body: format!(
                "## Acceptance Criteria\n- [ ] First\n- [ ] Second\n\n{}",
                "word ".repeat(150)
            ),
        };

        assert_eq!(calculate_complexity(&spec), ComplexityGrade::A);
    }

    #[test]
    fn test_calculate_complexity_grade_b() {
        use crate::spec::{Spec, SpecFrontmatter};

        // 5 criteria, 3 files, 300 words → Grade B
        let spec = Spec {
            id: "test".to_string(),
            frontmatter: SpecFrontmatter {
                target_files: Some(vec![
                    "file1.rs".to_string(),
                    "file2.rs".to_string(),
                    "file3.rs".to_string(),
                ]),
                ..Default::default()
            },
            title: Some("Test".to_string()),
            body: format!(
                "## Acceptance Criteria\n- [ ] First\n- [ ] Second\n- [ ] Third\n- [ ] Fourth\n- [ ] Fifth\n\n{}",
                "word ".repeat(300)
            ),
        };

        assert_eq!(calculate_complexity(&spec), ComplexityGrade::B);
    }

    #[test]
    fn test_calculate_complexity_grade_c() {
        use crate::spec::{Spec, SpecFrontmatter};

        // 6 criteria, 4 files, 500 words → Grade C
        let spec = Spec {
            id: "test".to_string(),
            frontmatter: SpecFrontmatter {
                target_files: Some(vec![
                    "file1.rs".to_string(),
                    "file2.rs".to_string(),
                    "file3.rs".to_string(),
                    "file4.rs".to_string(),
                ]),
                ..Default::default()
            },
            title: Some("Test".to_string()),
            body: format!(
                "## Acceptance Criteria\n- [ ] First\n- [ ] Second\n- [ ] Third\n- [ ] Fourth\n- [ ] Fifth\n- [ ] Sixth\n\n{}",
                "word ".repeat(500)
            ),
        };

        assert_eq!(calculate_complexity(&spec), ComplexityGrade::C);
    }

    #[test]
    fn test_calculate_complexity_grade_d_criteria() {
        use crate::spec::{Spec, SpecFrontmatter};

        // 10 criteria, 2 files, 100 words → Grade D (criteria exceeds threshold)
        let spec = Spec {
            id: "test".to_string(),
            frontmatter: SpecFrontmatter {
                target_files: Some(vec!["file1.rs".to_string(), "file2.rs".to_string()]),
                ..Default::default()
            },
            title: Some("Test".to_string()),
            body: format!(
                "## Acceptance Criteria\n{}\n\n{}",
                (1..=10)
                    .map(|i| format!("- [ ] Item {}", i))
                    .collect::<Vec<_>>()
                    .join("\n"),
                "word ".repeat(100)
            ),
        };

        assert_eq!(calculate_complexity(&spec), ComplexityGrade::D);
    }

    #[test]
    fn test_calculate_complexity_grade_d_files() {
        use crate::spec::{Spec, SpecFrontmatter};

        // 2 criteria, 5 files, 100 words → Grade D (files exceeds threshold)
        let spec = Spec {
            id: "test".to_string(),
            frontmatter: SpecFrontmatter {
                target_files: Some(vec![
                    "file1.rs".to_string(),
                    "file2.rs".to_string(),
                    "file3.rs".to_string(),
                    "file4.rs".to_string(),
                    "file5.rs".to_string(),
                ]),
                ..Default::default()
            },
            title: Some("Test".to_string()),
            body: format!(
                "## Acceptance Criteria\n- [ ] First\n- [ ] Second\n\n{}",
                "word ".repeat(100)
            ),
        };

        assert_eq!(calculate_complexity(&spec), ComplexityGrade::D);
    }

    #[test]
    fn test_calculate_complexity_grade_d_words() {
        use crate::spec::{Spec, SpecFrontmatter};

        // 2 criteria, 1 file, 700 words → Grade D (words exceeds threshold)
        let spec = Spec {
            id: "test".to_string(),
            frontmatter: SpecFrontmatter {
                target_files: Some(vec!["file1.rs".to_string()]),
                ..Default::default()
            },
            title: Some("Test".to_string()),
            body: format!(
                "## Acceptance Criteria\n- [ ] First\n- [ ] Second\n\n{}",
                "word ".repeat(700)
            ),
        };

        assert_eq!(calculate_complexity(&spec), ComplexityGrade::D);
    }

    #[test]
    fn test_calculate_complexity_no_target_files() {
        use crate::spec::{Spec, SpecFrontmatter};

        // Specs with no target_files should default to 0 files
        let spec = Spec {
            id: "test".to_string(),
            frontmatter: SpecFrontmatter {
                target_files: None,
                ..Default::default()
            },
            title: Some("Test".to_string()),
            body:
                "## Acceptance Criteria\n- [ ] First\n- [ ] Second\n\nSome content here with words."
                    .to_string(),
        };

        assert_eq!(calculate_complexity(&spec), ComplexityGrade::A);
    }

    #[test]
    fn test_calculate_complexity_empty_body() {
        use crate::spec::{Spec, SpecFrontmatter};

        // Empty body should have word count of 0
        let spec = Spec {
            id: "test".to_string(),
            frontmatter: SpecFrontmatter {
                target_files: Some(vec!["file1.rs".to_string()]),
                ..Default::default()
            },
            title: Some("Test".to_string()),
            body: String::new(),
        };

        assert_eq!(calculate_complexity(&spec), ComplexityGrade::A);
    }
}