"""
Generate Reports Use Case - Erstellt detaillierte Berichte
"""

import logging
import json
import csv
from io import StringIO
from typing import Dict, Any, List, Optional
from datetime import datetime, timedelta
import uuid

from domain.services.analytics_service import IAnalyticsService
from domain.value_objects.report import (
    Report, ReportType, Metric, PlatformStats, 
    TimeSeriesData, MetricType
)

logger = logging.getLogger("generate_reports_use_case")


class GenerateReportsUseCase:
    """
    Use Case für Report-Generierung.
    Erstellt tägliche/wöchentliche Reports mit Erfolgsstatistiken,
    Performance-Metriken und Fehler-Zusammenfassungen.
    """
    
    def __init__(self, analytics_service: IAnalyticsService):
        self.analytics_service = analytics_service
        self.report_templates = {
            ReportType.DAILY: self._generate_daily_report,
            ReportType.WEEKLY: self._generate_weekly_report,
            ReportType.MONTHLY: self._generate_monthly_report,
            ReportType.CUSTOM: self._generate_custom_report,
            ReportType.REAL_TIME: self._generate_realtime_report
        }
        
    def execute(self, 
                report_type: ReportType,
                start_date: Optional[datetime] = None,
                end_date: Optional[datetime] = None,
                platforms: Optional[List[str]] = None,
                include_charts: bool = True) -> Report:
        """
        Generiert einen Report.
        
        Args:
            report_type: Typ des Reports
            start_date: Startdatum (optional für vordefinierte Typen)
            end_date: Enddatum (optional für vordefinierte Typen)
            platforms: Filter für spezifische Plattformen
            include_charts: Ob Zeitreihen-Daten inkludiert werden sollen
            
        Returns:
            Generierter Report
        """
        # Bestimme Zeitrahmen basierend auf Report-Typ
        if not start_date or not end_date:
            start_date, end_date = self._determine_timeframe(report_type)
        
        # Generiere Report mit entsprechendem Template
        generator = self.report_templates.get(report_type, self._generate_custom_report)
        report = generator(start_date, end_date, platforms, include_charts)
        
        # Logge Report-Generierung
        logger.info(f"Generated {report_type.value} report: {report.report_id} "
                   f"({report.total_accounts_created} accounts, "
                   f"{report.overall_success_rate:.1%} success rate)")
        
        return report
    
    def _determine_timeframe(self, report_type: ReportType) -> tuple[datetime, datetime]:
        """Bestimmt Zeitrahmen basierend auf Report-Typ"""
        end_date = datetime.now()
        
        if report_type == ReportType.DAILY:
            start_date = end_date - timedelta(days=1)
        elif report_type == ReportType.WEEKLY:
            start_date = end_date - timedelta(weeks=1)
        elif report_type == ReportType.MONTHLY:
            start_date = end_date - timedelta(days=30)
        elif report_type == ReportType.REAL_TIME:
            start_date = end_date - timedelta(hours=1)
        else:
            start_date = end_date - timedelta(days=7)  # Default
        
        return start_date, end_date
    
    def _generate_daily_report(self, 
                             start: datetime,
                             end: datetime,
                             platforms: Optional[List[str]],
                             include_charts: bool) -> Report:
        """Generiert täglichen Report"""
        # Hole Basis-Report
        base_report = self.analytics_service.generate_report(
            ReportType.DAILY, start, end, platforms
        )
        
        # Erweitere mit täglichen Insights
        insights = [
            self._generate_daily_summary(base_report),
            self._generate_peak_time_insight(base_report),
            self._generate_error_trend_insight(base_report)
        ]
        
        # Füge Empfehlungen hinzu
        recommendations = self._generate_daily_recommendations(base_report)
        
        # Erstelle finalen Report
        return Report(
            report_id=base_report.report_id,
            report_type=ReportType.DAILY,
            start_date=start,
            end_date=end,
            generated_at=datetime.now(),
            total_accounts_created=base_report.total_accounts_created,
            total_attempts=base_report.total_attempts,
            overall_success_rate=base_report.overall_success_rate,
            avg_creation_time=base_report.avg_creation_time,
            metrics=base_report.metrics,
            platform_stats=base_report.platform_stats,
            error_summaries=base_report.error_summaries,
            success_rate_timeline=base_report.success_rate_timeline,
            creation_rate_timeline=base_report.creation_rate_timeline,
            error_rate_timeline=base_report.error_rate_timeline,
            insights=insights,
            recommendations=recommendations
        )
    
    def _generate_weekly_report(self, 
                              start: datetime,
                              end: datetime,
                              platforms: Optional[List[str]],
                              include_charts: bool) -> Report:
        """Generiert wöchentlichen Report"""
        base_report = self.analytics_service.generate_report(
            ReportType.WEEKLY, start, end, platforms
        )
        
        # Wöchentliche Trends
        insights = [
            self._generate_weekly_trend(base_report),
            self._generate_platform_comparison(base_report),
            self._generate_success_pattern_insight(base_report)
        ]
        
        recommendations = self._generate_weekly_recommendations(base_report)
        
        return Report(
            report_id=base_report.report_id,
            report_type=ReportType.WEEKLY,
            start_date=start,
            end_date=end,
            generated_at=datetime.now(),
            total_accounts_created=base_report.total_accounts_created,
            total_attempts=base_report.total_attempts,
            overall_success_rate=base_report.overall_success_rate,
            avg_creation_time=base_report.avg_creation_time,
            metrics=base_report.metrics,
            platform_stats=base_report.platform_stats,
            error_summaries=base_report.error_summaries,
            success_rate_timeline=base_report.success_rate_timeline,
            creation_rate_timeline=base_report.creation_rate_timeline,
            error_rate_timeline=base_report.error_rate_timeline,
            insights=insights,
            recommendations=recommendations
        )
    
    def _generate_monthly_report(self, 
                               start: datetime,
                               end: datetime,
                               platforms: Optional[List[str]],
                               include_charts: bool) -> Report:
        """Generiert monatlichen Report"""
        base_report = self.analytics_service.generate_report(
            ReportType.MONTHLY, start, end, platforms
        )
        
        # Monatliche Zusammenfassung
        insights = [
            self._generate_monthly_summary(base_report),
            self._generate_growth_analysis(base_report),
            self._generate_efficiency_insight(base_report)
        ]
        
        recommendations = self._generate_strategic_recommendations(base_report)
        
        return Report(
            report_id=base_report.report_id,
            report_type=ReportType.MONTHLY,
            start_date=start,
            end_date=end,
            generated_at=datetime.now(),
            total_accounts_created=base_report.total_accounts_created,
            total_attempts=base_report.total_attempts,
            overall_success_rate=base_report.overall_success_rate,
            avg_creation_time=base_report.avg_creation_time,
            metrics=base_report.metrics,
            platform_stats=base_report.platform_stats,
            error_summaries=base_report.error_summaries,
            success_rate_timeline=base_report.success_rate_timeline,
            creation_rate_timeline=base_report.creation_rate_timeline,
            error_rate_timeline=base_report.error_rate_timeline,
            insights=insights,
            recommendations=recommendations
        )
    
    def _generate_custom_report(self, 
                              start: datetime,
                              end: datetime,
                              platforms: Optional[List[str]],
                              include_charts: bool) -> Report:
        """Generiert benutzerdefinierten Report"""
        return self.analytics_service.generate_report(
            ReportType.CUSTOM, start, end, platforms
        )
    
    def _generate_realtime_report(self, 
                                start: datetime,
                                end: datetime,
                                platforms: Optional[List[str]],
                                include_charts: bool) -> Report:
        """Generiert Echtzeit-Report"""
        # Hole aktuelle Metriken
        realtime_metrics = self.analytics_service.get_real_time_metrics()
        
        # Konvertiere zu Report-Format
        metrics = [
            Metric(
                name="active_sessions",
                value=realtime_metrics.get('active_sessions', 0),
                unit="count",
                trend=0.0
            ),
            Metric(
                name="accounts_last_hour",
                value=realtime_metrics.get('accounts_last_hour', 0),
                unit="count",
                trend=realtime_metrics.get('hourly_trend', 0.0)
            ),
            Metric(
                name="current_success_rate",
                value=realtime_metrics.get('success_rate_last_hour', 0.0),
                unit="percentage",
                trend=realtime_metrics.get('success_trend', 0.0)
            )
        ]
        
        return Report(
            report_id=str(uuid.uuid4()),
            report_type=ReportType.REAL_TIME,
            start_date=start,
            end_date=end,
            generated_at=datetime.now(),
            total_accounts_created=realtime_metrics.get('accounts_last_hour', 0),
            total_attempts=realtime_metrics.get('attempts_last_hour', 0),
            overall_success_rate=realtime_metrics.get('success_rate_last_hour', 0.0),
            avg_creation_time=realtime_metrics.get('avg_creation_time', 0.0),
            metrics=metrics,
            platform_stats=[],
            error_summaries=[],
            insights=[
                f"Aktuell {realtime_metrics.get('active_sessions', 0)} aktive Sessions",
                f"Erfolgsrate letzte Stunde: {realtime_metrics.get('success_rate_last_hour', 0):.1%}"
            ],
            recommendations=[]
        )
    
    def _generate_daily_summary(self, report: Report) -> str:
        """Generiert tägliche Zusammenfassung"""
        if report.overall_success_rate >= 0.9:
            performance = "ausgezeichnet"
        elif report.overall_success_rate >= 0.7:
            performance = "gut"
        elif report.overall_success_rate >= 0.5:
            performance = "durchschnittlich"
        else:
            performance = "verbesserungswürdig"
        
        return (f"Tagesleistung war {performance} mit "
                f"{report.total_accounts_created} erstellten Accounts "
                f"({report.overall_success_rate:.1%} Erfolgsrate)")
    
    def _generate_peak_time_insight(self, report: Report) -> str:
        """Generiert Insight über Peak-Zeiten"""
        if report.creation_rate_timeline:
            peak_hour = max(zip(report.creation_rate_timeline.timestamps,
                               report.creation_rate_timeline.values),
                           key=lambda x: x[1])
            return f"Höchste Aktivität um {peak_hour[0].strftime('%H:%M')} Uhr"
        return "Keine ausgeprägten Peak-Zeiten erkennbar"
    
    def _generate_error_trend_insight(self, report: Report) -> str:
        """Generiert Insight über Fehler-Trends"""
        if report.error_rate_timeline:
            trend = report.error_rate_timeline.get_trend()
            if trend > 10:
                return "⚠️ Fehlerrate steigt - Intervention empfohlen"
            elif trend < -10:
                return "✅ Fehlerrate sinkt - positive Entwicklung"
            else:
                return "Fehlerrate stabil"
        return "Keine Fehler-Trend-Daten verfügbar"
    
    def _generate_daily_recommendations(self, report: Report) -> List[str]:
        """Generiert tägliche Empfehlungen"""
        recommendations = []
        
        if report.overall_success_rate < 0.7:
            recommendations.append(
                "Erfolgsrate unter 70% - prüfen Sie Rate Limits und Proxy-Qualität"
            )
        
        if report.avg_creation_time > 120:
            recommendations.append(
                "Durchschnittliche Erstellungszeit über 2 Minuten - "
                "Performance-Optimierung empfohlen"
            )
        
        # Platform-spezifische Empfehlungen
        for platform_stat in report.platform_stats:
            if platform_stat.success_rate < 0.5:
                recommendations.append(
                    f"{platform_stat.platform}: Niedrige Erfolgsrate - "
                    f"spezifische Anpassungen erforderlich"
                )
        
        if not recommendations:
            recommendations.append("Keine dringenden Maßnahmen erforderlich")
        
        return recommendations
    
    def _generate_weekly_trend(self, report: Report) -> str:
        """Generiert wöchentlichen Trend"""
        trend_direction = "stabil"
        if report.success_rate_timeline:
            trend = report.success_rate_timeline.get_trend()
            if trend > 5:
                trend_direction = "steigend"
            elif trend < -5:
                trend_direction = "fallend"
        
        return f"Wöchentlicher Trend: {trend_direction} ({report.accounts_per_day:.1f} Accounts/Tag)"
    
    def _generate_platform_comparison(self, report: Report) -> str:
        """Vergleicht Platform-Performance"""
        if not report.platform_stats:
            return "Keine Platform-Daten verfügbar"
        
        best_platform = max(report.platform_stats, key=lambda p: p.success_rate)
        worst_platform = min(report.platform_stats, key=lambda p: p.success_rate)
        
        return (f"Beste Performance: {best_platform.platform} ({best_platform.success_rate:.1%}), "
                f"Schlechteste: {worst_platform.platform} ({worst_platform.success_rate:.1%})")
    
    def _generate_success_pattern_insight(self, report: Report) -> str:
        """Analysiert Erfolgsmuster"""
        success_metric = report.get_metric(MetricType.SUCCESS_RATE)
        if success_metric and success_metric.trend > 0:
            return f"Erfolgsrate verbessert sich um {success_metric.trend:.1f}%"
        return "Erfolgsrate zeigt keine klare Tendenz"
    
    def _generate_weekly_recommendations(self, report: Report) -> List[str]:
        """Generiert wöchentliche Empfehlungen"""
        recommendations = []
        
        # Trend-basierte Empfehlungen
        if report.success_rate_timeline:
            trend = report.success_rate_timeline.get_trend()
            if trend < -10:
                recommendations.append(
                    "Negativer Trend erkannt - analysieren Sie Änderungen der letzten Woche"
                )
        
        # Effizienz-Empfehlungen
        if report.total_attempts > report.total_accounts_created * 2:
            recommendations.append(
                "Hohe Retry-Rate - verbessern Sie Fehlerbehandlung"
            )
        
        return recommendations
    
    def _generate_monthly_summary(self, report: Report) -> str:
        """Generiert monatliche Zusammenfassung"""
        total_value = report.total_accounts_created
        daily_avg = report.accounts_per_day
        
        return (f"Monat: {total_value} Accounts erstellt "
                f"(Ø {daily_avg:.1f}/Tag, {report.overall_success_rate:.1%} Erfolg)")
    
    def _generate_growth_analysis(self, report: Report) -> str:
        """Analysiert Wachstum"""
        # Vereinfacht - würde historische Daten vergleichen
        return "Wachstumsanalyse: Vergleich mit Vormonat ausstehend"
    
    def _generate_efficiency_insight(self, report: Report) -> str:
        """Analysiert Effizienz"""
        efficiency = report.total_accounts_created / report.total_attempts if report.total_attempts > 0 else 0
        return f"Effizienz: {efficiency:.1%} der Versuche erfolgreich"
    
    def _generate_strategic_recommendations(self, report: Report) -> List[str]:
        """Generiert strategische Empfehlungen"""
        return [
            "Monatliche Review der Error-Patterns durchführen",
            "Proxy-Pool-Qualität evaluieren",
            "Fingerprint-Rotation-Strategie anpassen"
        ]
    
    def export_report(self, 
                     report: Report,
                     format: str = 'json',
                     include_sensitive: bool = False) -> bytes:
        """
        Exportiert Report in verschiedenen Formaten.
        
        Args:
            report: Zu exportierender Report
            format: Export-Format ('json', 'csv', 'html')
            include_sensitive: Ob sensitive Daten inkludiert werden sollen
            
        Returns:
            Report als Bytes
        """
        if format == 'json':
            return self._export_json(report, include_sensitive)
        elif format == 'csv':
            return self._export_csv(report)
        elif format == 'html':
            return self._export_html(report)
        else:
            raise ValueError(f"Unsupported format: {format}")
    
    def _export_json(self, report: Report, include_sensitive: bool) -> bytes:
        """Exportiert als JSON"""
        data = report.to_dict()
        
        # Entferne sensitive Daten wenn gewünscht
        if not include_sensitive:
            # Entferne Account-spezifische Daten
            for platform_stat in data.get('platform_stats', []):
                if 'account_details' in platform_stat:
                    del platform_stat['account_details']
        
        return json.dumps(data, indent=2).encode('utf-8')
    
    def _export_csv(self, report: Report) -> bytes:
        """Exportiert als CSV"""
        output = StringIO()
        writer = csv.writer(output)
        
        # Header
        writer.writerow(['Metric', 'Value', 'Unit', 'Trend'])
        
        # Metrics
        for metric in report.metrics:
            writer.writerow([metric.name, metric.value, metric.unit, metric.trend])
        
        # Platform Stats
        writer.writerow([])
        writer.writerow(['Platform', 'Attempts', 'Success', 'Success Rate', 'Avg Duration'])
        
        for stat in report.platform_stats:
            writer.writerow([
                stat.platform,
                stat.total_attempts,
                stat.successful_accounts,
                f"{stat.success_rate:.1%}",
                f"{stat.avg_duration_seconds:.1f}s"
            ])
        
        return output.getvalue().encode('utf-8')
    
    def _export_html(self, report: Report) -> bytes:
        """Exportiert als HTML"""
        html = f"""
        <html>
        <head>
            <title>Report {report.report_id}</title>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 20px; }}
                h1 {{ color: #333; }}
                .metric {{ margin: 10px 0; }}
                .success {{ color: green; }}
                .warning {{ color: orange; }}
                .error {{ color: red; }}
                table {{ border-collapse: collapse; width: 100%; }}
                th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
                th {{ background-color: #f2f2f2; }}
            </style>
        </head>
        <body>
            <h1>{report.report_type.value.title()} Report</h1>
            <p>Period: {report.start_date.strftime('%Y-%m-%d')} to {report.end_date.strftime('%Y-%m-%d')}</p>
            
            <h2>Summary</h2>
            <div class="metric">Total Accounts: <strong>{report.total_accounts_created}</strong></div>
            <div class="metric">Success Rate: <strong class="{'success' if report.overall_success_rate > 0.7 else 'warning'}">{report.overall_success_rate:.1%}</strong></div>
            <div class="metric">Average Creation Time: <strong>{report.avg_creation_time:.1f}s</strong></div>
            
            <h2>Platform Statistics</h2>
            <table>
                <tr>
                    <th>Platform</th>
                    <th>Attempts</th>
                    <th>Success</th>
                    <th>Success Rate</th>
                </tr>
        """
        
        for stat in report.platform_stats:
            html += f"""
                <tr>
                    <td>{stat.platform}</td>
                    <td>{stat.total_attempts}</td>
                    <td>{stat.successful_accounts}</td>
                    <td class="{'success' if stat.success_rate > 0.7 else 'warning'}">{stat.success_rate:.1%}</td>
                </tr>
            """
        
        html += """
            </table>
            
            <h2>Insights</h2>
            <ul>
        """
        
        for insight in report.insights:
            html += f"<li>{insight}</li>"
        
        html += """
            </ul>
            
            <h2>Recommendations</h2>
            <ul>
        """
        
        for rec in report.recommendations:
            html += f"<li>{rec}</li>"
        
        html += """
            </ul>
        </body>
        </html>
        """
        
        return html.encode('utf-8')