Découvrez Ralph

use serde::{Deserialize, Serialize};
use std::fs;
use anyhow::Result;

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Prd {
    pub project: String,
    pub branch_name: String,
    pub description: String,
    pub user_stories: Vec<UserStory>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UserStory {
    pub id: String,
    pub title: String,
    pub description: String,
    pub acceptance_criteria: Vec<String>,
    pub priority: u32,
    pub passes: bool,
    #[serde(default)]
    pub notes: String,
}

impl Prd {
    pub fn load(path: &str) -> Result<Self> {
        let content = fs::read_to_string(path)?;
        let prd: Prd = serde_json::from_str(&content)?;
        Ok(prd)
    }
    
    pub fn save(&self, path: &str) -> Result<()> {
        let content = serde_json::to_string_pretty(self)?;
        fs::write(path, content)?;
        Ok(())
    }
    
    pub fn get_next_task(&self) -> Option<&UserStory> {
        self.user_stories
            .iter()
            .filter(|story| !story.passes)
            .min_by_key(|story| story.priority)
    }
    
    pub fn mark_complete(&mut self, task_id: &str) -> Result<()> {
        if let Some(story) = self.user_stories
            .iter_mut()
            .find(|s| s.id == task_id) 
        {
            story.passes = true;
        }
        Ok(())
    }
    
    pub fn is_complete(&self) -> bool {
        self.user_stories.iter().all(|story| story.passes)
    }
    
    pub fn stats(&self) -> (usize, usize) {
        let complete = self.user_stories
            .iter()
            .filter(|s| s.passes)
            .count();
        let total = self.user_stories.len();
        (complete, total)
    }
}