from dataclasses import dataclass, field
from datetime import datetime
from typing import Optional


@dataclass
class JobStatus:
    is_running: bool = False
    progress: int = 0
    total_processados: int = 0
    total_esperado: int = 0
    mensagem: str = ""
    inicio: Optional[datetime] = None
    fim: Optional[datetime] = None
    erro: Optional[str] = None
    batch_atual: int = 0
    total_batches: int = 0

    def iniciar(self, total_esperado: int) -> None:
        self.is_running = True
        self.progress = 0
        self.total_processados = 0
        self.total_esperado = total_esperado
        self.mensagem = "Iniciando processamento..."
        self.inicio = datetime.now()
        self.fim = None
        self.erro = None
        self.batch_atual = 0
        self.total_batches = 0

    def atualizar_progresso(self, processados: int, batch_atual: int, mensagem: str = "") -> None:
        self.total_processados = processados
        self.batch_atual = batch_atual
        if self.total_esperado > 0:
            self.progress = int((processados / self.total_esperado) * 100)
        self.mensagem = mensagem or f"Processando batch {batch_atual}"

    def finalizar(self, sucesso: bool = True, erro: Optional[str] = None) -> None:
        self.is_running = False
        self.fim = datetime.now()
        self.progress = 100 if sucesso else self.progress
        self.erro = erro
        if sucesso:
            self.mensagem = f"Processamento concluído: {self.total_processados} consultores"
        else:
            self.mensagem = f"Processamento falhou: {erro}"

    @property
    def tempo_decorrido(self) -> Optional[str]:
        if not self.inicio:
            return None
        fim = self.fim or datetime.now()
        delta = fim - self.inicio
        minutos, segundos = divmod(int(delta.total_seconds()), 60)
        return f"{minutos}m {segundos}s"

    @property
    def tempo_estimado(self) -> Optional[str]:
        if not self.inicio or self.total_processados == 0 or self.total_esperado == 0:
            return None
        if self.progress >= 100:
            return "0m 0s"

        decorrido = (datetime.now() - self.inicio).total_seconds()
        taxa = self.total_processados / decorrido
        restante = (self.total_esperado - self.total_processados) / taxa
        minutos, segundos = divmod(int(restante), 60)
        return f"{minutos}m {segundos}s"

    def to_dict(self) -> dict:
        return {
            "running": self.is_running,
            "progress": self.progress,
            "processados": self.total_processados,
            "total": self.total_esperado,
            "mensagem": self.mensagem,
            "batch_atual": self.batch_atual,
            "total_batches": self.total_batches,
            "tempo_decorrido": self.tempo_decorrido,
            "tempo_estimado": self.tempo_estimado,
            "inicio": self.inicio.isoformat() if self.inicio else None,
            "fim": self.fim.isoformat() if self.fim else None,
            "erro": self.erro
        }


job_status = JobStatus()
