"""
Modello per il profilo completo di un dataset.

La dataclass DatasetProfile aggrega i profili di tutte le colonne
e fornisce metodi per accedere al riepilogo complessivo.
"""

from dataclasses import dataclass, field
from datetime import datetime

from .column_profile import ColumnProfile


@dataclass
class DatasetProfile:
    """Profilo completo di un dataset analizzato.

    Aggrega i profili di tutte le colonne e fornisce
    statistiche riassuntive sull'intero dataset.

    Attributes:
        filename: Nome del file analizzato.
        row_count: Numero totale di righe.
        column_count: Numero di colonne.
        columns: Lista dei profili delle singole colonne.
        file_size_bytes: Dimensione del file sorgente in byte.
        created_at: Timestamp di creazione del profilo.
        warnings: Lista di avvisi generati durante l'analisi.

    Esempio::

        profile = DatasetProfile(filename="dati.csv", row_count=1000, column_count=5)
        print(profile.summary())
    """
    filename: str
    row_count: int = 0
    column_count: int = 0
    columns: list[ColumnProfile] = field(default_factory=list)
    file_size_bytes: int = 0
    created_at: datetime = field(default_factory=datetime.now)
    warnings: list[str] = field(default_factory=list)

    def get_column(self, name: str) -> ColumnProfile | None:
        """Cerca un profilo colonna per nome.

        Args:
            name: Nome della colonna da cercare.

        Returns:
            Il ColumnProfile corrispondente, o None se non trovato.
        """
        for col in self.columns:
            if col.name == name:
                return col
        return None

    @property
    def overall_completeness(self) -> float:
        """Percentuale media di completezza dell'intero dataset.

        Returns:
            Media della completezza di tutte le colonne (0.0 - 100.0).
        """
        if not self.columns:
            return 0.0
        return sum(c.completeness for c in self.columns) / len(self.columns)

    @property
    def total_missing(self) -> int:
        """Numero totale di valori mancanti in tutto il dataset."""
        return sum(c.missing_count for c in self.columns)

    @property
    def total_cells(self) -> int:
        """Numero totale di celle nel dataset."""
        return self.row_count * self.column_count

    def summary(self) -> dict:
        """Restituisce un dizionario riassuntivo del dataset.

        Returns:
            Dizionario con le informazioni principali.
        """
        return {
            "file": self.filename,
            "righe": self.row_count,
            "colonne": self.column_count,
            "completezza": f"{self.overall_completeness:.1f}%",
            "celle_totali": self.total_cells,
            "valori_mancanti": self.total_missing,
            "warnings": len(self.warnings),
        }

    def __str__(self) -> str:
        return (
            f"DatasetProfile('{self.filename}', "
            f"{self.row_count} righe × {self.column_count} colonne, "
            f"completezza={self.overall_completeness:.1f}%)"
        )
