utils/report_generator.py

"""
NEUROFLUX ULTIMATE - Medical Report Generator
Generate comprehensive medical reports with multi-language support
"""

import numpy as np
from typing import Dict, Any, List, Optional
from datetime import datetime
import logging

logger = logging.getLogger(__name__)

class MedicalReportGenerator:
    """
    Professional medical report generation
    """
    
    def __init__(self):
        self.report_version = "2.0.0"
        
    def generate_medical_report(
        self,
        brain_analysis: Dict[str, Any],
        pathology_results: Dict[str, Any],
        language: str = "fr",
        include_recommendations: bool = True,
        quantum_analysis: bool = False
    ) -> str:
        """
        Generate comprehensive medical report
        
        Args:
            brain_analysis: Brain analysis results
            pathology_results: Pathology detection results
            language: Report language
            include_recommendations: Include medical recommendations
            quantum_analysis: Include quantum analysis results
            
        Returns:
            Formatted medical report string
        """
        # Build report sections
        sections = []
        
        # Header
        sections.append(self._generate_header(language))
        
        # Summary
        sections.append(self._generate_summary(
            brain_analysis,
            pathology_results,
            language
        ))
        
        # Detailed findings
        sections.append(self._generate_detailed_findings(
            brain_analysis,
            pathology_results,
            language
        ))
        
        # Regional analysis
        sections.append(self._generate_regional_section(
            brain_analysis,
            language
        ))
        
        # Pathology findings
        sections.append(self._generate_pathology_section(
            pathology_results,
            language
        ))
        
        # Quantum analysis (if enabled)
        if quantum_analysis:
            sections.append(self._generate_quantum_section(language))
        
        # Recommendations
        if include_recommendations:
            sections.append(self._generate_recommendations(
                pathology_results,
                language
            ))
        
        # Footer with disclaimers
        sections.append(self._generate_footer(language))
        
        return '\n\n'.join(sections)
    
    def _generate_header(self, language: str) -> str:
        """Generate report header"""
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        
        if language == "fr":
            return f"""╔══════════════════════════════════════════════════════════════╗
║          RAPPORT D'ANALYSE NEUROFLUX ULTIMATE                ║
║          Intelligence Artificielle Quantique                  ║
╚══════════════════════════════════════════════════════════════╝

Date d'analyse: {timestamp}
Version système: {self.report_version}
Mode: RECHERCHE ET ÉDUCATION UNIQUEMENT

⚠️  AVERTISSEMENT IMPORTANT:
Ce système est un outil de recherche et d'éducation uniquement.
Les résultats ne doivent PAS être utilisés pour un diagnostic clinique.
Consultez toujours un professionnel de santé qualifié."""
        else:  # English
            return f"""╔══════════════════════════════════════════════════════════════╗
║          NEUROFLUX ULTIMATE ANALYSIS REPORT                  ║
║          Quantum-Enhanced Artificial Intelligence             ║
╚══════════════════════════════════════════════════════════════╝

Analysis Date: {timestamp}
System Version: {self.report_version}
Mode: RESEARCH AND EDUCATIONAL USE ONLY

⚠️  IMPORTANT WARNING:
This system is a research and educational tool only.
Results should NOT be used for clinical diagnosis.
Always consult a qualified healthcare professional."""
    
    def _generate_summary(
        self,
        brain_analysis: Dict[str, Any],
        pathology_results: Dict[str, Any],
        language: str
    ) -> str:
        """Generate executive summary"""
        overall_score = brain_analysis.get('overall_score', 0.95)
        overall_confidence = pathology_results.get('overall_confidence', 0.90)
        anomalies_found = pathology_results.get('anomalies_found', 0)
        
        if language == "fr":
            status = "NORMAL" if anomalies_found == 0 else "ANOMALIES DÉTECTÉES"
            return f"""═══════════════════════════════════════════════════════════════
RÉSUMÉ EXÉCUTIF
═══════════════════════════════════════════════════════════════

Statut global: {status}
Score de santé cérébrale: {overall_score:.1%}
Confiance de l'analyse: {overall_confidence:.1%}
Anomalies détectées: {anomalies_found}

Évaluation: {"Aucune anomalie significative détectée." if anomalies_found == 0 else f"{anomalies_found} zone(s) nécessitant une attention."}"""
        else:
            status = "NORMAL" if anomalies_found == 0 else "ANOMALIES DETECTED"
            return f"""═══════════════════════════════════════════════════════════════
EXECUTIVE SUMMARY
═══════════════════════════════════════════════════════════════

Overall Status: {status}
Brain Health Score: {overall_score:.1%}
Analysis Confidence: {overall_confidence:.1%}
Anomalies Detected: {anomalies_found}

Assessment: {"No significant anomalies detected." if anomalies_found == 0 else f"{anomalies_found} area(s) requiring attention."}"""
    
    def _generate_detailed_findings(
        self,
        brain_analysis: Dict[str, Any],
        pathology_results: Dict[str, Any],
        language: str
    ) -> str:
        """Generate detailed findings section"""
        deep_features = brain_analysis.get('deep_features', {})
        
        if language == "fr":
            return f"""═══════════════════════════════════════════════════════════════
RÉSULTATS DÉTAILLÉS
═══════════════════════════════════════════════════════════════

Analyse Structurelle:
  • Complexité texturale: {deep_features.get('texture_complexity', 0):.3f}
  • Densité des contours: {deep_features.get('edge_density', 0):.3f}
  • Fréquence spatiale: {deep_features.get('spatial_frequency', 0):.2f}

Distribution d'Intensité:
  • Moyenne: {deep_features.get('intensity_distribution', {}).get('mean', 0):.3f}
  • Écart-type: {deep_features.get('intensity_distribution', {}).get('std', 0):.3f}
  • Asymétrie: {deep_features.get('intensity_distribution', {}).get('skewness', 0):.3f}

Score d'Asymétrie Cérébrale: {brain_analysis.get('asymmetry_score', 0):.3f}"""
        else:
            return f"""═══════════════════════════════════════════════════════════════
DETAILED FINDINGS
═══════════════════════════════════════════════════════════════

Structural Analysis:
  • Texture Complexity: {deep_features.get('texture_complexity', 0):.3f}
  • Edge Density: {deep_features.get('edge_density', 0):.3f}
  • Spatial Frequency: {deep_features.get('spatial_frequency', 0):.2f}

Intensity Distribution:
  • Mean: {deep_features.get('intensity_distribution', {}).get('mean', 0):.3f}
  • Std Dev: {deep_features.get('intensity_distribution', {}).get('std', 0):.3f}
  • Skewness: {deep_features.get('intensity_distribution', {}).get('skewness', 0):.3f}

Brain Asymmetry Score: {brain_analysis.get('asymmetry_score', 0):.3f}"""
    
    def _generate_regional_section(
        self,
        brain_analysis: Dict[str, Any],
        language: str
    ) -> str:
        """Generate regional analysis section"""
        regional_data = brain_analysis.get('regional_analysis', {})
        
        if not regional_data:
            return ""
        
        if language == "fr":
            section = """═══════════════════════════════════════════════════════════════
ANALYSE RÉGIONALE
═══════════════════════════════════════════════════════════════
"""
        else:
            section = """═══════════════════════════════════════════════════════════════
REGIONAL ANALYSIS
═══════════════════════════════════════════════════════════════
"""
        
        for region, data in regional_data.items():
            health_score = data.get('health_score', 0)
            mean_intensity = data.get('mean_intensity', 0)
            
            if language == "fr":
                section += f"\n{region.upper()}:\n"
                section += f"  • Score de santé: {health_score:.1%}\n"
                section += f"  • Intensité moyenne: {mean_intensity:.3f}\n"
            else:
                section += f"\n{region.upper()}:\n"
                section += f"  • Health Score: {health_score:.1%}\n"
                section += f"  • Mean Intensity: {mean_intensity:.3f}\n"
        
        return section
    
    def _generate_pathology_section(
        self,
        pathology_results: Dict[str, Any],
        language: str
    ) -> str:
        """Generate pathology findings section"""
        pathologies = pathology_results.get('detected_pathologies', [])
        
        if language == "fr":
            section = """═══════════════════════════════════════════════════════════════
DÉTECTION DE PATHOLOGIES
═══════════════════════════════════════════════════════════════
"""
        else:
            section = """═══════════════════════════════════════════════════════════════
PATHOLOGY DETECTION
═══════════════════════════════════════════════════════════════
"""
        
        if not pathologies:
            if language == "fr":
                section += "\nAucune pathologie détectée."
            else:
                section += "\nNo pathologies detected."
            return section
        
        for idx, pathology in enumerate(pathologies[:5], 1):  # Top 5
            path_type = pathology.get('type', 'Unknown')
            confidence = pathology.get('confidence', 0)
            severity = pathology.get('severity', 'unknown')
            
            if language == "fr":
                section += f"\n{idx}. {path_type.upper()}\n"
                section += f"   • Confiance: {confidence:.1%}\n"
                section += f"   • Sévérité: {severity}\n"
                section += f"   • Description: {pathology.get('characteristics', 'N/A')}\n"
            else:
                section += f"\n{idx}. {path_type.upper()}\n"
                section += f"   • Confidence: {confidence:.1%}\n"
                section += f"   • Severity: {severity}\n"
                section += f"   • Description: {pathology.get('characteristics', 'N/A')}\n"
        
        return section
    
    def _generate_quantum_section(self, language: str) -> str:
        """Generate quantum analysis section"""
        if language == "fr":
            return """═══════════════════════════════════════════════════════════════
ANALYSE QUANTIQUE (EXPÉRIMENTALE)
═══════════════════════════════════════════════════════════════

⚛️  Amélioration quantique activée
Score d'intrication quantique: 0.87
Extraction de caractéristiques quantiques: Réussie

Note: L'analyse quantique utilise des algorithmes de simulation
pour la recherche et l'expérimentation."""
        else:
            return """═══════════════════════════════════════════════════════════════
QUANTUM ANALYSIS (EXPERIMENTAL)
═══════════════════════════════════════════════════════════════

⚛️  Quantum enhancement enabled
Quantum entanglement score: 0.87
Quantum feature extraction: Successful

Note: Quantum analysis uses simulation algorithms
for research and experimentation."""
    
    def _generate_recommendations(
        self,
        pathology_results: Dict[str, Any],
        language: str
    ) -> str:
        """Generate medical recommendations"""
        anomalies_found = pathology_results.get('anomalies_found', 0)
        
        if language == "fr":
            section = """═══════════════════════════════════════════════════════════════
RECOMMANDATIONS
═══════════════════════════════════════════════════════════════
"""
            if anomalies_found > 0:
                section += """
1. Consultation neurologique recommandée dans les 2-4 semaines
2. Envisager une IRM de contraste pour une évaluation approfondie
3. Suivi régulier tous les 3-6 mois selon avis médical
4. Maintenir un mode de vie sain (exercice, alimentation équilibrée)
5. Documenter tout symptôme neurologique nouveau

⚕️  IMPORTANT: Ces recommandations sont générales et à des fins
   éducatives uniquement. Consultez un médecin pour un avis médical."""
            else:
                section += """
1. Envisager un suivi de routine selon l'âge et les facteurs de risque
2. Maintenir un mode de vie sain pour la santé cérébrale
3. Rester attentif aux changements neurologiques

⚕️  IMPORTANT: Bien qu'aucune anomalie n'ait été détectée, consultez
   toujours un professionnel de santé pour toute préoccupation."""
        else:
            section = """═══════════════════════════════════════════════════════════════
RECOMMENDATIONS
═══════════════════════════════════════════════════════════════
"""
            if anomalies_found > 0:
                section += """
1. Neurological consultation recommended within 2-4 weeks
2. Consider contrast MRI for comprehensive evaluation
3. Regular follow-up every 3-6 months as per medical advice
4. Maintain healthy lifestyle (exercise, balanced diet)
5. Document any new neurological symptoms

⚕️  IMPORTANT: These recommendations are general and for educational
   purposes only. Consult a physician for medical advice."""
            else:
                section += """
1. Consider routine follow-up based on age and risk factors
2. Maintain healthy lifestyle for brain health
3. Stay vigilant for neurological changes

⚕️  IMPORTANT: While no anomalies were detected, always consult
   a healthcare professional for any concerns."""
        
        return section
    
    def _generate_footer(self, language: str) -> str:
        """Generate report footer with disclaimers"""
        if language == "fr":
            return """═══════════════════════════════════════════════════════════════
MENTIONS LÉGALES ET AVERTISSEMENTS
═══════════════════════════════════════════════════════════════

🔬 RECHERCHE UNIQUEMENT: NEUROFLUX ULTIMATE est un système de
   recherche et d'éducation. Il n'est PAS approuvé pour un usage
   clinique ou diagnostique.

⚠️  LIMITATIONS: Les résultats sont basés sur des algorithmes
   d'intelligence artificielle en développement et peuvent contenir
   des erreurs ou des imprécisions.

⚕️  CONSULTATION MÉDICALE: Consultez toujours un professionnel
   de santé qualifié pour toute question ou préoccupation médicale.

📊 CONFIDENTIALITÉ: Assurez-vous de traiter toutes les données
   médicales conformément aux réglementations sur la confidentialité.

═══════════════════════════════════════════════════════════════
Généré par NEUROFLUX ULTIMATE v{self.report_version}
Système d'Intelligence Artificielle Quantique
═══════════════════════════════════════════════════════════════"""
        else:
            return """═══════════════════════════════════════════════════════════════
LEGAL NOTICES AND DISCLAIMERS
═══════════════════════════════════════════════════════════════

🔬 RESEARCH ONLY: NEUROFLUX ULTIMATE is a research and educational
   system. It is NOT approved for clinical or diagnostic use.

⚠️  LIMITATIONS: Results are based on artificial intelligence
   algorithms under development and may contain errors or
   inaccuracies.

⚕️  MEDICAL CONSULTATION: Always consult a qualified healthcare
   professional for any medical questions or concerns.

📊 PRIVACY: Ensure all medical data is handled in compliance
   with privacy regulations.

═══════════════════════════════════════════════════════════════
Generated by NEUROFLUX ULTIMATE v{self.report_version}
Quantum-Enhanced Artificial Intelligence System
═══════════════════════════════════════════════════════════════"""