"""
Analyzer per colonne con dati booleani.

Rileva colonne contenenti valori vero/falso in vari formati
(True/False, 1/0, Sì/No, ecc.) e ne calcola le distribuzioni.
"""

from .base import BaseAnalyzer
from dataprofiler.models.column_profile import ColumnProfile, ColumnType
from dataprofiler.utils import is_boolean


class BooleanAnalyzer(BaseAnalyzer):
    """Analizza colonne contenenti valori booleani.

    Riconosce diversi formati booleani: True/False, 1/0,
    Sì/No, Yes/No, Vero/Falso.

    Statistiche calcolate:
        - conteggio di valori True e False
        - percentuale di True
        - distribuzione dei valori originali

    Esempio::

        analyzer = BooleanAnalyzer()
        values = ["Sì", "No", "Sì", "Sì", None]
        if analyzer.can_analyze(values, "attivo"):
            profile = analyzer.analyze(values, "attivo")
            print(profile.stats["percentuale_true"])  # 75.0
    """

    BOOLEAN_THRESHOLD = 0.70

    # Valori considerati "True"
    TRUE_VALUES = {"true", "1", "sì", "si", "yes", "vero"}
    # Valori considerati "False"
    FALSE_VALUES = {"false", "0", "no", "falso"}

    def can_analyze(self, values: list, column_name: str) -> bool:
        """Verifica se la colonna è prevalentemente booleana.

        Args:
            values: Lista dei valori della colonna.
            column_name: Nome della colonna.

        Returns:
            True se almeno il 70% dei valori sono booleani.
        """
        non_null = self._get_non_null(values)
        if not non_null:
            return False

        bool_count = sum(1 for v in non_null if is_boolean(v))
        return (bool_count / len(non_null)) >= self.BOOLEAN_THRESHOLD

    def analyze(self, values: list, column_name: str) -> ColumnProfile:
        """Calcola statistiche booleane sulla colonna.

        Args:
            values: Lista dei valori della colonna.
            column_name: Nome della colonna.

        Returns:
            ColumnProfile con tipo BOOLEAN e statistiche calcolate.
        """
        true_count = 0
        false_count = 0
        missing = 0
        value_freq: dict[str, int] = {}

        for v in values:
            if v is None or (isinstance(v, str) and v.strip() == ""):
                missing += 1
                continue

            normalized = str(v).strip().lower()
            value_freq[str(v).strip()] = value_freq.get(str(v).strip(), 0) + 1

            if normalized in self.TRUE_VALUES:
                true_count += 1
            elif normalized in self.FALSE_VALUES:
                false_count += 1
            else:
                missing += 1

        total_bool = true_count + false_count
        stats = {
            "true_count": true_count,
            "false_count": false_count,
            "percentuale_true": round(
                (true_count / total_bool * 100) if total_bool > 0 else 0.0, 1
            ),
            "distribuzione": value_freq,
        }

        return ColumnProfile(
            name=column_name,
            dtype=ColumnType.BOOLEAN,
            total_count=len(values),
            missing_count=missing,
            unique_count=len(value_freq),
            stats=stats,
        )
