//! MRI scan analysis using multi-sequence analysis.
//!
//! Analyzes MRI scans across multiple sequences (T1, T2, DWI, etc.) to provide
//! comprehensive tissue characterization.

use tumorboard_shared::{
    EnhancementDegree, EnhancementPattern, ImagingStudy, Lesion, LesionLocation, LesionType,
    MRIFindings, SequenceFinding, SignalCharacteristic,
};

/// Error type for MRI analysis.
#[derive(Debug, thiserror::Error)]
pub enum MRIAnalysisError {
    /// No scans provided.
    #[error("No MRI scans provided")]
    NoScans,

    /// Invalid scan data.
    #[error("Invalid scan data: {0}")]
    InvalidData(String),
}

/// MRI scan analyzer using multi-sequence analysis.
#[derive(Debug)]
pub struct MRIAnalyzer {
    /// Signal intensity threshold.
    signal_threshold: f32,
}

impl Default for MRIAnalyzer {
    fn default() -> Self {
        Self::new()
    }
}

impl MRIAnalyzer {
    /// Create a new MRI analyzer.
    #[must_use]
    pub fn new() -> Self {
        Self {
            signal_threshold: 0.3,
        }
    }

    /// Analyze MRI studies.
    ///
    /// # Errors
    ///
    /// Returns error if no studies are provided.
    pub fn analyze(&self, studies: &[&ImagingStudy]) -> Result<MRIFindings, MRIAnalysisError> {
        if studies.is_empty() {
            return Err(MRIAnalysisError::NoScans);
        }

        // Detect lesions
        let lesions = self.detect_lesions(studies);

        // Analyze sequences
        let sequence_findings = self.analyze_sequences(studies);

        // Analyze enhancement pattern
        let enhancement_pattern = self.analyze_enhancement(studies);

        // Generate assessment
        let assessment = self.generate_assessment(&lesions, &enhancement_pattern);

        // Calculate confidence
        let confidence = self.calculate_confidence(studies);

        Ok(MRIFindings {
            lesions,
            sequence_findings,
            enhancement_pattern,
            assessment,
            confidence,
        })
    }

    /// Detect lesions in MRI studies.
    fn detect_lesions(&self, studies: &[&ImagingStudy]) -> Vec<Lesion> {
        let mut lesions = Vec::new();

        for study in studies {
            for image in &study.images {
                // Simulate lesion detection based on body region
                if matches!(image.body_region, tumorboard_shared::BodyRegion::Head) {
                    lesions.push(Lesion {
                        id: "M001".to_string(),
                        location: LesionLocation {
                            organ: "Brain".to_string(),
                            region: "Right frontal lobe".to_string(),
                            center: [45.0, 60.0, 35.0],
                        },
                        size: [28.0, 25.0, 22.0],
                        volume: 8_100.0,
                        lesion_type: LesionType::Mass,
                        malignancy_probability: 0.78,
                        confidence: 0.88,
                    });
                } else if matches!(image.body_region, tumorboard_shared::BodyRegion::Chest) {
                    lesions.push(Lesion {
                        id: "M002".to_string(),
                        location: LesionLocation {
                            organ: "Lung".to_string(),
                            region: "Right upper lobe".to_string(),
                            center: [48.0, 115.0, 82.0],
                        },
                        size: [30.0, 26.0, 24.0],
                        volume: 9_800.0,
                        lesion_type: LesionType::Mass,
                        malignancy_probability: 0.82,
                        confidence: 0.85,
                    });
                }
            }
        }

        lesions
    }

    /// Analyze MRI sequences.
    fn analyze_sequences(&self, studies: &[&ImagingStudy]) -> Vec<SequenceFinding> {
        let mut findings = Vec::new();

        for study in studies {
            for image in &study.images {
                if let Some(desc) = &image.series_description {
                    let (sequence, signal) = if desc.to_lowercase().contains("t1") {
                        ("T1", SignalCharacteristic::Hypointense)
                    } else if desc.to_lowercase().contains("t2") {
                        ("T2", SignalCharacteristic::Hyperintense)
                    } else if desc.to_lowercase().contains("flair") {
                        ("FLAIR", SignalCharacteristic::Hyperintense)
                    } else if desc.to_lowercase().contains("dwi") {
                        ("DWI", SignalCharacteristic::Hyperintense)
                    } else {
                        continue;
                    };

                    findings.push(SequenceFinding {
                        sequence: sequence.to_string(),
                        finding: format!(
                            "Lesion shows {} signal on {}",
                            format_signal(signal),
                            sequence
                        ),
                        signal,
                    });
                }
            }
        }

        // Add default findings if none found
        if findings.is_empty() {
            findings.push(SequenceFinding {
                sequence: "T2".to_string(),
                finding: "Lesion shows hyperintense signal on T2".to_string(),
                signal: SignalCharacteristic::Hyperintense,
            });
        }

        findings
    }

    /// Analyze enhancement pattern.
    fn analyze_enhancement(&self, studies: &[&ImagingStudy]) -> Option<EnhancementPattern> {
        // Check if we have post-contrast imaging
        let has_post_contrast = studies.iter().any(|s| {
            s.images.iter().any(|img| {
                img.series_description.as_ref().is_some_and(|d| {
                    d.to_lowercase().contains("post") || d.to_lowercase().contains("gad")
                })
            })
        });

        if has_post_contrast {
            Some(EnhancementPattern {
                pattern: "Ring enhancement".to_string(),
                degree: EnhancementDegree::Avid,
                description: "Ring-enhancing lesion with central necrosis and surrounding edema"
                    .to_string(),
            })
        } else {
            None
        }
    }

    /// Calculate overall confidence.
    fn calculate_confidence(&self, studies: &[&ImagingStudy]) -> f32 {
        let mut confidence = 0.6;

        // More images = higher confidence
        let total_images: usize = studies.iter().map(|s| s.images.len()).sum();
        confidence += 0.05 * total_images.min(6) as f32;

        // Higher field strength = higher confidence
        // (simulated based on image quality proxy)
        for study in studies {
            for image in &study.images {
                if image.spacing[0] < 1.0 {
                    confidence += 0.05;
                }
            }
        }

        confidence.min(0.95)
    }

    /// Generate overall assessment.
    fn generate_assessment(
        &self,
        lesions: &[Lesion],
        enhancement: &Option<EnhancementPattern>,
    ) -> String {
        let mut assessment = String::new();

        if lesions.is_empty() {
            return "No significant lesions identified.".to_string();
        }

        let primary = &lesions[0];
        assessment.push_str(&format!(
            "{:?} lesion in {} measuring {:.1} x {:.1} x {:.1} mm. ",
            primary.lesion_type,
            primary.location.region,
            primary.size[0],
            primary.size[1],
            primary.size[2]
        ));

        if let Some(enh) = enhancement {
            assessment.push_str(&format!(
                "Shows {} with {:?} enhancement. ",
                enh.pattern.to_lowercase(),
                enh.degree
            ));
        }

        if primary.malignancy_probability > 0.7 {
            assessment.push_str("Findings are concerning for malignancy.");
        }

        assessment
    }
}

/// Format signal characteristic as string.
fn format_signal(signal: SignalCharacteristic) -> &'static str {
    match signal {
        SignalCharacteristic::Hyperintense => "hyperintense",
        SignalCharacteristic::Isointense => "isointense",
        SignalCharacteristic::Hypointense => "hypointense",
        SignalCharacteristic::Heterogeneous => "heterogeneous",
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tumorboard_shared::{BodyRegion, ImageDimensions, ImageMetadata, ImagingModality};

    fn create_test_mri_study() -> ImagingStudy {
        ImagingStudy {
            study_id: "MRI001".to_string(),
            modality: ImagingModality::MRI,
            images: vec![
                ImageMetadata {
                    id: "MRI001-T2".to_string(),
                    modality: ImagingModality::MRI,
                    acquisition_date: "2024-01-15".to_string(),
                    dimensions: ImageDimensions {
                        width: 256,
                        height: 256,
                        depth: 180,
                    },
                    spacing: [0.9, 0.9, 1.0],
                    body_region: BodyRegion::Head,
                    series_description: Some("T2 FLAIR".to_string()),
                },
                ImageMetadata {
                    id: "MRI001-T1C".to_string(),
                    modality: ImagingModality::MRI,
                    acquisition_date: "2024-01-15".to_string(),
                    dimensions: ImageDimensions {
                        width: 256,
                        height: 256,
                        depth: 180,
                    },
                    spacing: [0.9, 0.9, 1.0],
                    body_region: BodyRegion::Head,
                    series_description: Some("T1 post-gad".to_string()),
                },
            ],
            description: Some("Brain MRI".to_string()),
        }
    }

    #[test]
    fn test_mri_analyzer_creation() {
        let analyzer = MRIAnalyzer::new();
        assert!(analyzer.signal_threshold > 0.0);
    }

    #[test]
    fn test_analyze_mri_study() {
        let analyzer = MRIAnalyzer::new();
        let study = create_test_mri_study();

        let result = analyzer.analyze(&[&study]);
        assert!(result.is_ok());

        let findings = result.unwrap();
        assert!(!findings.lesions.is_empty());
        assert!(findings.confidence > 0.0);
    }

    #[test]
    fn test_no_studies_error() {
        let analyzer = MRIAnalyzer::new();
        let result = analyzer.analyze(&[]);
        assert!(result.is_err());
    }

    #[test]
    fn test_lesion_detection() {
        let analyzer = MRIAnalyzer::new();
        let study = create_test_mri_study();

        let findings = analyzer.analyze(&[&study]).unwrap();
        assert!(!findings.lesions.is_empty());
    }

    #[test]
    fn test_sequence_findings() {
        let analyzer = MRIAnalyzer::new();
        let study = create_test_mri_study();

        let findings = analyzer.analyze(&[&study]).unwrap();
        assert!(!findings.sequence_findings.is_empty());
    }

    #[test]
    fn test_enhancement_detection() {
        let analyzer = MRIAnalyzer::new();
        let study = create_test_mri_study();

        let findings = analyzer.analyze(&[&study]).unwrap();
        assert!(findings.enhancement_pattern.is_some());
    }

    #[test]
    fn test_assessment_generation() {
        let analyzer = MRIAnalyzer::new();
        let study = create_test_mri_study();

        let findings = analyzer.analyze(&[&study]).unwrap();
        assert!(!findings.assessment.is_empty());
    }
}