//! Transcript analyzer for extracting requirements, decisions, and action items.

use serde::{Deserialize, Serialize};
use utoipa::ToSchema;
use crate::db::models::TranscriptEntry;

/// An extracted requirement from the transcript
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct ExtractedRequirement {
    pub text: String,
    pub speaker: String,
    pub timestamp: f32,
    pub confidence: f32,
    pub category: Option<String>,  // functional, technical, non-functional, business
}

/// An extracted decision from the transcript
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct ExtractedDecision {
    pub text: String,
    pub speaker: String,
    pub timestamp: f32,
    pub confidence: f32,
    pub context: Option<String>,
}

/// An extracted action item from the transcript
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct ExtractedActionItem {
    pub text: String,
    pub speaker: String,
    pub timestamp: f32,
    pub assignee: Option<String>,
    pub priority: Option<String>,
}

/// Result of transcript analysis
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct TranscriptAnalysisResult {
    pub requirements: Vec<ExtractedRequirement>,
    pub decisions: Vec<ExtractedDecision>,
    pub action_items: Vec<ExtractedActionItem>,
    pub key_topics: Vec<String>,
    pub suggested_contract_name: Option<String>,
    pub suggested_description: Option<String>,
    pub speaker_summary: Vec<SpeakerStats>,
}

#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct SpeakerStats {
    pub speaker: String,
    pub word_count: usize,
    pub speaking_time_seconds: f32,
    pub contribution_percentage: f32,
}

/// Format transcript entries into readable text for LLM analysis
pub fn format_transcript_for_analysis(entries: &[TranscriptEntry]) -> String {
    entries
        .iter()
        .map(|e| format!("[{:.1}s] {}: {}", e.start, e.speaker, e.text))
        .collect::<Vec<_>>()
        .join("\n")
}

/// Calculate speaker statistics from transcript
pub fn calculate_speaker_stats(entries: &[TranscriptEntry]) -> Vec<SpeakerStats> {
    use std::collections::HashMap;

    let mut stats: HashMap<String, (usize, f32)> = HashMap::new();

    for entry in entries {
        let word_count = entry.text.split_whitespace().count();
        let duration = entry.end - entry.start;

        let (count, time) = stats.entry(entry.speaker.clone()).or_insert((0, 0.0));
        *count += word_count;
        *time += duration;
    }

    let total_words: usize = stats.values().map(|(c, _)| c).sum();
    let total_time: f32 = stats.values().map(|(_, t)| t).sum();

    // Suppress unused variable warning
    let _ = total_time;

    stats
        .into_iter()
        .map(|(speaker, (word_count, speaking_time))| SpeakerStats {
            speaker,
            word_count,
            speaking_time_seconds: speaking_time,
            contribution_percentage: if total_words > 0 {
                (word_count as f32 / total_words as f32) * 100.0
            } else {
                0.0
            },
        })
        .collect()
}

/// Build the analysis prompt for the LLM
pub fn build_analysis_prompt(transcript_text: &str) -> String {
    format!(r#"Analyze this meeting/conversation transcript and extract structured information.

TRANSCRIPT:
{}

Extract the following information in JSON format:

1. **Requirements**: Statements where someone expresses a need, want, or must-have. Look for phrases like:
   - "we need to...", "it should...", "must have...", "requirement is..."
   - "the system should...", "users need to be able to..."

2. **Decisions**: Explicit decisions made during the conversation. Look for:
   - "let's go with...", "we decided...", "we'll use...", "agreed to..."
   - "the decision is...", "we're going with..."

3. **Action Items**: Tasks or todos mentioned. Look for:
   - "someone needs to...", "we should...", "next step is..."
   - "I'll do...", "can you...", "TODO:..."

4. **Key Topics**: Main subjects discussed

5. **Suggested Contract Name**: A short name (3-5 words) that captures the main goal

6. **Suggested Description**: A 1-2 sentence description of what should be built/done

Return your analysis as JSON with this structure:
{{
  "requirements": [
    {{"text": "...", "speaker": "Speaker X", "timestamp": 12.5, "confidence": 0.9, "category": "functional"}}
  ],
  "decisions": [
    {{"text": "...", "speaker": "Speaker X", "timestamp": 45.2, "confidence": 0.85, "context": "..."}}
  ],
  "action_items": [
    {{"text": "...", "speaker": "Speaker X", "timestamp": 78.0, "assignee": null, "priority": "high"}}
  ],
  "key_topics": ["topic1", "topic2"],
  "suggested_contract_name": "...",
  "suggested_description": "..."
}}

Be conservative - only extract items with high confidence. If nothing is found for a category, return an empty array."#, transcript_text)
}

/// Parse LLM response into analysis result
pub fn parse_analysis_response(response: &str, speaker_stats: Vec<SpeakerStats>) -> Result<TranscriptAnalysisResult, String> {
    // Try to extract JSON from the response (it might be wrapped in markdown code blocks)
    let json_str = extract_json_from_response(response)?;

    #[derive(Deserialize)]
    struct LlmResponse {
        requirements: Option<Vec<ExtractedRequirement>>,
        decisions: Option<Vec<ExtractedDecision>>,
        action_items: Option<Vec<ExtractedActionItem>>,
        key_topics: Option<Vec<String>>,
        suggested_contract_name: Option<String>,
        suggested_description: Option<String>,
    }

    let parsed: LlmResponse = serde_json::from_str(&json_str)
        .map_err(|e| format!("Failed to parse LLM response as JSON: {}", e))?;

    Ok(TranscriptAnalysisResult {
        requirements: parsed.requirements.unwrap_or_default(),
        decisions: parsed.decisions.unwrap_or_default(),
        action_items: parsed.action_items.unwrap_or_default(),
        key_topics: parsed.key_topics.unwrap_or_default(),
        suggested_contract_name: parsed.suggested_contract_name,
        suggested_description: parsed.suggested_description,
        speaker_summary: speaker_stats,
    })
}

/// Extract JSON from LLM response (handles markdown code blocks)
fn extract_json_from_response(response: &str) -> Result<String, String> {
    // Try to find JSON in code blocks first
    if let Some(start) = response.find("```json") {
        if let Some(end) = response[start..].find("```\n").or_else(|| response[start..].rfind("```")) {
            let json_start = start + 7; // Skip "```json"
            let json_end = start + end;
            if json_end > json_start {
                return Ok(response[json_start..json_end].trim().to_string());
            }
        }
    }

    // Try plain code blocks
    if let Some(start) = response.find("```") {
        let after_start = start + 3;
        if let Some(end) = response[after_start..].find("```") {
            let json_str = &response[after_start..after_start + end];
            // Skip language identifier if present
            let json_str = if let Some(newline) = json_str.find('\n') {
                &json_str[newline + 1..]
            } else {
                json_str
            };
            return Ok(json_str.trim().to_string());
        }
    }

    // Try to find raw JSON (starts with { or [)
    if let Some(start) = response.find('{') {
        if let Some(end) = response.rfind('}') {
            if end > start {
                return Ok(response[start..=end].to_string());
            }
        }
    }

    Err("Could not find JSON in LLM response".to_string())
}

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

    #[test]
    fn test_format_transcript() {
        let entries = vec![
            TranscriptEntry {
                id: "1".to_string(),
                speaker: "Speaker 0".to_string(),
                start: 0.0,
                end: 2.5,
                text: "Hello world".to_string(),
                is_final: true,
            },
        ];

        let formatted = format_transcript_for_analysis(&entries);
        assert!(formatted.contains("[0.0s] Speaker 0: Hello world"));
    }

    #[test]
    fn test_speaker_stats() {
        let entries = vec![
            TranscriptEntry {
                id: "1".to_string(),
                speaker: "Speaker 0".to_string(),
                start: 0.0,
                end: 5.0,
                text: "One two three four five".to_string(),
                is_final: true,
            },
            TranscriptEntry {
                id: "2".to_string(),
                speaker: "Speaker 1".to_string(),
                start: 5.0,
                end: 10.0,
                text: "Six seven eight nine ten".to_string(),
                is_final: true,
            },
        ];

        let stats = calculate_speaker_stats(&entries);
        assert_eq!(stats.len(), 2);

        for s in &stats {
            assert_eq!(s.word_count, 5);
            assert_eq!(s.speaking_time_seconds, 5.0);
            assert!((s.contribution_percentage - 50.0).abs() < 0.1);
        }
    }

    #[test]
    fn test_extract_json_from_response() {
        let response = r#"Here is the analysis:
```json
{"key": "value"}
```
Done."#;

        let json = extract_json_from_response(response).unwrap();
        assert_eq!(json, r#"{"key": "value"}"#);
    }

    #[test]
    fn test_extract_raw_json() {
        let response = r#"Analysis: {"key": "value"}"#;
        let json = extract_json_from_response(response).unwrap();
        assert_eq!(json, r#"{"key": "value"}"#);
    }
}