from dataclasses import dataclass, field
from enum import Enum
from typing import Any


class StatusDaAnalise(str, Enum):
    CONCLUIDA = "concluida"
    CONCLUIDA_COM_AVISOS = "concluida_com_avisos"
    FALHOU = "falhou"


@dataclass(frozen=True)
class ErroDeAnalise(Exception):
    codigo: str
    mensagem: str
    caminho: str | None = None
    detalhes: dict[str, Any] = field(default_factory=dict)

    def __post_init__(self) -> None:
        Exception.__init__(self, self.mensagem)


@dataclass
class ResultadoDaAnalise:
    status: StatusDaAnalise
    timeline: Any = None
    erros: list[ErroDeAnalise] = field(default_factory=list)
    avisos: list[str] = field(default_factory=list)


@dataclass(frozen=True)
class PalavraDeTranscricao:
    texto: str
    inicio: float
    fim: float
    confianca: float | None = None
    falante: str | None = None

    def __post_init__(self) -> None:
        if self.inicio < 0 or self.fim < self.inicio:
            raise ValueError("Intervalo de palavra inválido.")


@dataclass(frozen=True)
class SegmentoDeTranscricao:
    inicio: float
    fim: float
    texto: str
    confianca: float | None = None
    palavras: tuple[PalavraDeTranscricao, ...] = ()
    emocao: str | None = None
    confianca_emocao: float | None = None
    caracteristicas_acusticas: dict[str, float] = field(default_factory=dict)
    falante: str | None = None
    voz_aparente: str | None = None
    confianca_voz: float | None = None

    def __post_init__(self) -> None:
        if self.inicio < 0 or self.fim < self.inicio:
            raise ValueError("Intervalo de transcrição inválido.")


@dataclass(frozen=True)
class Cena:
    inicio: float
    fim: float
    confianca: float | None = None
    referencias: tuple[float, ...] = ()


@dataclass(frozen=True)
class Evento:
    tipo: str
    inicio: float
    fim: float
    confianca: float | None = None


@dataclass(frozen=True)
class EvidenciaVisual:
    """Fato visual normalizado, independente da biblioteca que o produziu."""

    tipo: str
    inicio: float
    fim: float
    valor: dict[str, Any]
    confianca: float | None = None
    provider: str = ""
    modelo: str | None = None

    def __post_init__(self) -> None:
        if self.inicio < 0 or self.fim < self.inicio:
            raise ValueError("Intervalo de evidência visual inválido.")


ObservacaoVisual = EvidenciaVisual


@dataclass(frozen=True)
class CenaVisual:
    """Intervalo visual enriquecido com as observações que o sustentam."""

    identificador_do_clipe: str
    inicio: float
    fim: float
    observacoes: tuple[EvidenciaVisual, ...] = ()
    referencias_de_cena: tuple[float, ...] = ()

    def __post_init__(self) -> None:
        if self.inicio < 0 or self.fim < self.inicio:
            raise ValueError("Intervalo de cena visual inválido.")