"""Formatadores Rich para exibição no terminal."""

from __future__ import annotations

from typing import Any

from rich.console import Console
from rich.panel import Panel
from rich.table import Table
from rich.tree import Tree

console = Console()


def print_json_or_rich(data: Any, *, json_mode: bool) -> None:
    """Imprime data como JSON puro ou formatado com Rich."""
    if json_mode:
        import json

        console.print_json(json.dumps(data, ensure_ascii=False, default=str))
        return
    # Fallback: tenta formatador específico, senão imprime dict/str
    if isinstance(data, str):
        console.print(data)
    elif isinstance(data, dict):
        console.print_json(data=data)
    elif isinstance(data, list):
        import json

        console.print_json(json.dumps(data, ensure_ascii=False, default=str))
    else:
        console.print(data)


def format_processos(data: Any, *, json_mode: bool = False) -> None:
    """Formata lista de processos como tabela Rich."""
    if json_mode:
        print_json_or_rich(data, json_mode=True)
        return

    processos = (
        data if isinstance(data, list) else data.get("resultados", data.get("processos", []))
    )
    if not processos:
        console.print("[yellow]Nenhum processo encontrado.[/yellow]")
        return

    table = Table(title="Processos", show_lines=True)
    table.add_column("Número CNJ", style="cyan", no_wrap=True)
    table.add_column("Classe", style="green")
    table.add_column("Partes", style="white")

    for p in processos:
        table.add_row(
            p.get("numero_processo", ""),
            p.get("classe_descricao", p.get("classe_judicial", "")) or "",
            p.get("partes", p.get("assunto", "")) or "",
        )

    console.print(table)
    total = data.get("total") if isinstance(data, dict) else len(processos)
    if total:
        console.print(f"[dim]Total: {total} processo(s)[/dim]")


def format_visao_geral(data: Any, *, json_mode: bool = False) -> None:
    """Formata visão geral de um processo com painéis Rich."""
    if json_mode:
        print_json_or_rich(data, json_mode=True)
        return

    if isinstance(data, str):
        console.print(data)
        return

    # Metadados
    meta = data.get("metadados", data)
    title = meta.get("numero_processo", "Processo")
    panel_content = []
    for key in [
        "classe_judicial",
        "assunto",
        "vara",
        "comarca",
        "tribunal",
        "valor_causa",
        "data_distribuicao",
    ]:
        val = meta.get(key)
        if val:
            label = key.replace("_", " ").title()
            panel_content.append(f"[bold]{label}:[/bold] {val}")

    if panel_content:
        console.print(
            Panel("\n".join(panel_content), title=f"[cyan]{title}[/cyan]", border_style="blue")
        )

    # Partes
    partes = data.get("partes", [])
    if partes:
        tree = Tree("[bold]Partes[/bold]")
        for parte in partes:
            nome = parte.get("nome", "")
            tipo = parte.get("tipo", "")
            advogados = parte.get("advogados", [])
            branch = tree.add(f"[green]{tipo}:[/green] {nome}")
            for adv in advogados:
                if isinstance(adv, dict):
                    branch.add(f"[dim]Adv: {adv.get('nome', adv)}[/dim]")
                else:
                    branch.add(f"[dim]Adv: {adv}[/dim]")
        console.print(tree)

    # Stats
    stats = data.get("estatisticas", {})
    if stats:
        stats_text = []
        for k, v in stats.items():
            label = k.replace("_", " ").title()
            stats_text.append(f"[bold]{label}:[/bold] {v}")
        if stats_text:
            console.print(Panel(" | ".join(stats_text), title="Estatísticas", border_style="green"))

    # Movimentações recentes
    movs = data.get("movimentacoes_recentes", [])
    if movs:
        table = Table(title="Movimentações Recentes", show_lines=True)
        table.add_column("Data", style="cyan", no_wrap=True)
        table.add_column("Descrição", style="white")
        table.add_column("Fonte", style="dim")
        for mov in movs[:10]:
            table.add_row(
                mov.get("data", ""),
                mov.get("descricao", mov.get("titulo", "")),
                mov.get("fonte", ""),
            )
        console.print(table)


def format_documentos(data: Any, *, json_mode: bool = False) -> None:
    """Formata lista de documentos como tabela."""
    if json_mode:
        print_json_or_rich(data, json_mode=True)
        return

    docs = data if isinstance(data, list) else data.get("documentos", [])
    if not docs:
        console.print("[yellow]Nenhum documento encontrado.[/yellow]")
        return

    table = Table(title="Documentos", show_lines=True)
    table.add_column("ID", style="dim", no_wrap=True)
    table.add_column("Tipo", style="cyan")
    table.add_column("Título", style="white")
    table.add_column("Fonte", style="green")
    table.add_column("Páginas", style="yellow", justify="right")

    for doc in docs:
        table.add_row(
            str(doc.get("id", "")),
            doc.get("tipo", ""),
            doc.get("titulo", doc.get("descricao", "")),
            doc.get("fonte", ""),
            str(doc.get("paginas", "")),
        )

    console.print(table)
    paginacao = data.get("paginacao") if isinstance(data, dict) else None
    if paginacao:
        console.print(
            f"[dim]Página {paginacao.get('pagina_atual')}/{paginacao.get('total_paginas')} — Total: {paginacao.get('total_itens')}[/dim]"
        )


def format_movimentacoes(data: Any, *, json_mode: bool = False) -> None:
    """Formata lista de movimentações como tabela."""
    if json_mode:
        print_json_or_rich(data, json_mode=True)
        return

    movs = data if isinstance(data, list) else data.get("movimentacoes", [])
    if not movs:
        console.print("[yellow]Nenhuma movimentação encontrada.[/yellow]")
        return

    table = Table(title="Movimentações", show_lines=True)
    table.add_column("Data", style="cyan", no_wrap=True)
    table.add_column("Descrição", style="white")
    table.add_column("Fonte", style="green")

    for mov in movs:
        table.add_row(
            mov.get("data", ""),
            mov.get("descricao", mov.get("titulo", "")),
            mov.get("fonte", ""),
        )

    console.print(table)
    paginacao = data.get("paginacao") if isinstance(data, dict) else None
    if paginacao:
        console.print(
            f"[dim]Página {paginacao.get('pagina_atual')}/{paginacao.get('total_paginas')} — Total: {paginacao.get('total_itens')}[/dim]"
        )


def format_documento_conteudo(data: Any, *, json_mode: bool = False) -> None:
    """Formata conteúdo de um documento."""
    if json_mode:
        print_json_or_rich(data, json_mode=True)
        return

    if isinstance(data, str):
        console.print(data)
        return

    titulo = data.get("titulo", data.get("tipo", "Documento"))
    conteudo = data.get("conteudo", data.get("texto", ""))
    fonte = data.get("fonte", "")
    confianca = data.get("confianca")

    header_parts = [f"[cyan]{titulo}[/cyan]"]
    if fonte:
        header_parts.append(f"[dim](fonte: {fonte})[/dim]")
    if confianca is not None:
        header_parts.append(f"[dim](confiança: {confianca})[/dim]")

    console.print(Panel(conteudo, title=" ".join(header_parts), border_style="blue"))

    meta = data.get("metadata", {})
    if meta.get("foi_resumido"):
        console.print(
            f"[yellow]Conteúdo resumido: {meta.get('tamanho_original')} → {meta.get('tamanho_final')} chars[/yellow]"
        )


def format_grep_results(data: Any, *, json_mode: bool = False) -> None:
    """Formata resultados de busca grep."""
    if json_mode:
        print_json_or_rich(data, json_mode=True)
        return

    resultados = data if isinstance(data, list) else data.get("resultados", [])
    if not resultados:
        console.print("[yellow]Nenhum resultado encontrado.[/yellow]")
        return

    for r in resultados:
        titulo = r.get("titulo", r.get("documento", ""))
        trechos = r.get("trechos", r.get("matches", []))
        console.print(f"\n[bold cyan]{titulo}[/bold cyan]")
        for trecho in trechos:
            if isinstance(trecho, dict):
                console.print(
                    f"  [dim]pos {trecho.get('posicao', '?')}:[/dim] ...{trecho.get('contexto', trecho.get('texto', ''))}..."
                )
            else:
                console.print(f"  ...{trecho}...")

    total = data.get("total_matches") if isinstance(data, dict) else len(resultados)
    if total:
        console.print(f"\n[dim]Total: {total} resultado(s)[/dim]")


def format_stats(data: Any, *, json_mode: bool = False) -> None:
    """Formata estatísticas de documentos."""
    if json_mode:
        print_json_or_rich(data, json_mode=True)
        return

    if isinstance(data, str):
        console.print(data)
        return

    table = Table(title="Estatísticas de Documentos", show_lines=True)
    table.add_column("Métrica", style="cyan")
    table.add_column("Valor", style="white", justify="right")

    for k, v in data.items():
        if k == "por_fonte":
            continue
        label = k.replace("_", " ").title()
        table.add_row(label, str(v))

    console.print(table)

    por_fonte = data.get("por_fonte", {})
    if por_fonte:
        ft = Table(title="Por Fonte", show_lines=True)
        ft.add_column("Fonte", style="green")
        ft.add_column("Quantidade", style="white", justify="right")
        for fonte, qtd in por_fonte.items():
            ft.add_row(fonte, str(qtd))
        console.print(ft)


def format_analise(data: Any, *, json_mode: bool = False) -> None:
    """Formata resultado de análise."""
    if json_mode:
        print_json_or_rich(data, json_mode=True)
        return

    if isinstance(data, str):
        console.print(Panel(data, title="Análise", border_style="magenta"))
        return

    resposta = data.get("resposta", data.get("analise", ""))
    custo = data.get("custo")

    console.print(Panel(str(resposta), title="[magenta]Análise[/magenta]", border_style="magenta"))

    if custo:
        console.print(f"[dim]Custo: ${custo}[/dim]")


def format_precedentes(data: Any, *, json_mode: bool = False) -> None:
    """Formata resultados de busca de precedentes."""
    if json_mode:
        print_json_or_rich(data, json_mode=True)
        return

    resultados = (
        data if isinstance(data, list) else data.get("resultados", data.get("precedentes", []))
    )
    if not resultados:
        console.print("[yellow]Nenhum precedente encontrado.[/yellow]")
        return

    for r in resultados:
        titulo = r.get("titulo", r.get("nome", ""))
        tipo = r.get("tipo", "")
        orgao = r.get("orgao", "")
        texto = r.get("texto", r.get("ementa", ""))

        header = f"[bold]{titulo}[/bold]"
        if tipo:
            header += f" [dim]({tipo})[/dim]"
        if orgao:
            header += f" [dim]— {orgao}[/dim]"

        console.print(Panel(str(texto)[:500], title=header, border_style="yellow"))


def format_calculadora(data: Any, *, json_mode: bool = False) -> None:
    """Formata resultado da calculadora."""
    if json_mode:
        print_json_or_rich(data, json_mode=True)
        return

    if isinstance(data, str):
        console.print(data)
        return

    resultado = data.get("resultado", data)
    console.print(Panel(str(resultado), title="Calculadora", border_style="green"))


def format_whoami(data: Any, *, json_mode: bool = False) -> None:
    """Formata resultado do whoami."""
    if json_mode:
        print_json_or_rich(data, json_mode=True)
        return

    if isinstance(data, str):
        console.print(data)
        return

    parts = []
    for key in ["email", "user_id", "nome", "role"]:
        val = data.get(key)
        if val:
            label = key.replace("_", " ").title()
            parts.append(f"[bold]{label}:[/bold] {val}")

    if parts:
        console.print(Panel("\n".join(parts), title="[cyan]Usuário[/cyan]", border_style="cyan"))
    else:
        print_json_or_rich(data, json_mode=False)


def format_generic(data: Any, *, json_mode: bool = False) -> None:
    """Formatador genérico para qualquer resposta."""
    print_json_or_rich(data, json_mode=json_mode)
