"""
Project Together — powered by AI: CONSOLIDAR respostas de IAs diferentes.

POR QUE ISTO EXISTE
  O curso é "powered by AI": você usa a SUA IA. Mas a melhor forma de aprender a
  confiar (e a desconfiar) de uma IA é ouvir DUAS e comparar. Onde elas concordam,
  você pode confiar; onde DIVERGEM, é você quem decide — e é aí que mora o aprendizado.

  Fazer isso na mão (abrir as duas respostas lado a lado, achar as diferenças, escrever
  uma versão final) é trabalho operacional. Este script tira esse trabalho do caminho:
  você já cola as respostas no quadro — ele encontra as que competem e entrega o prompt
  PRONTO que faz a sua IA propor UMA resposta consolidada. A IA propõe, você decide.

COMO USAR (o mesmo ritmo do curso — você não edita arquivo nenhum)
  1. Rode um passo (ex.: Passo 1) e pegue o prompt pronto.
  2. Cole o MESMO prompt em DUAS IAs diferentes (ou na mesma, duas vezes).
  3. Cole AS DUAS respostas no cartão "0. Caixa de entrada" do seu quadro, uma embaixo
     da outra. Cada uma já vem com rótulos em colchetes ([1.2], [2.1]...) — e é isso que
     este script procura: o MESMO rótulo aparecendo mais de uma vez = respostas para
     comparar. Você não escreve de onde veio cada uma; o rótulo repetido basta.
  4. Rode esta opção (C). Ela monta o prompt de consolidação, já com as duas respostas
     dentro, e o põe na sua área de transferência.
  5. Cole esse prompt em QUALQUER IA (pode ser uma terceira). Ela devolve: a comparação
     (onde concordam · onde divergem · o que conferir) e a resposta CONSOLIDADA.
  6. Copie a resposta consolidada INTEIRA, cole no cartão "0. Caixa de entrada"
     (substituindo as duas de antes) e rode o passo normal — ele lê a versão final.

O QUE ELE NÃO FAZ
  Não chama nenhuma IA por conta própria e não escolhe uma IA por você: o curso é
  agnóstico de IA. Quem compara é a SUA IA; quem decide é você. E ele NÃO apaga nada do
  seu quadro — só lê a caixa e monta o prompt.
"""
import os
import sys
from idioma import T, Tf, escolher

try:
    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
except Exception:
    pass

from env import cfg, require
from runner import header, ok, step, warn, done, copiar

HERE = os.path.dirname(os.path.abspath(__file__))
_SAIDA = os.path.join(HERE, "_saida")


def _ids():
    """As listas do quadro, lidas do .env (LIST_*), sem MEXER no quadro.

    Consolidar é uma LEITURA: nunca cria nem renomeia listas (ao contrário dos passos).
    Se a lista INPUTS ainda não existe no .env, tenta achá-la pelo nome — e, se nem
    assim, é porque o quadro ainda não foi montado (rode o Passo 1 primeiro).
    """
    c = cfg()
    require(c, "PROJECTADM_TOKEN", "BOARD_ID")
    ids = {k[5:]: v for k, v in c.items() if k.startswith("LIST_")}
    if not ids.get("INPUTS"):
        try:
            from pa_client import find_list_id_by_name
            lid = find_list_id_by_name("INPUTS")
            if lid:
                ids["INPUTS"] = lid
        except Exception:
            pass
    return ids


def _contestados(ids):
    """{rótulo: [variantes]} só dos rótulos que aparecem MAIS DE UMA VEZ na caixa.

    É o coração do script: um rótulo repetido são respostas concorrentes para a mesma
    pergunta. Usa a mesma máquina que o quadro já usa para ler a caixa (blocos_da_caixa
    dá os rótulos presentes; blocos_multiplos_da_caixa devolve TODAS as ocorrências de
    um rótulo — foi feita para o Passo 9, quando a IA analisa várias mudanças de uma vez).
    """
    import quadro
    presentes = quadro.blocos_da_caixa(ids)          # {rótulo: último corpo} — rótulos únicos
    contestados = {}
    for rotulo in presentes:
        variantes = quadro.blocos_multiplos_da_caixa(ids, rotulo)
        if len(variantes) >= 2:
            contestados[rotulo] = variantes
    return contestados, presentes


# ── O prompt de consolidação (o "juiz") ──────────────────────────────────────
# Ele pede a saída JÁ no formato que a caixa lê: a comparação primeiro (texto livre, que
# o distribuidor da caixa ignora por não ter rótulo) e, depois, um bloco [rótulo] por
# pergunta — exatamente como as respostas chegaram. Assim a resposta consolidada volta
# para a caixa e o passo normal a distribui sem nenhum passo extra.
#
# DUAS TABELAS, uma por idioma (escolher()), e não T(): este cabeçalho é um BLOCO de 25
# linhas, não uma frase — a doutrina do idioma.py manda tabela paralela para dado
# estruturado, porque um bloco inteiro dentro do catálogo perde a tradução ao primeiro
# ajuste de vírgula no português e fica ilegível no diff.
# Ele escapava do lint `--pendentes` por não ser argumento de print(): é uma constante de
# módulo que só vira texto do aluno lá no fim, dentro de copiar(). Resultado: o pacote EN
# entregava o prompt inteiro em português (Eduardo, 2026-08-05).
_CABECALHO_PT = """CONSOLIDAR RESPOSTAS DE IAs DIFERENTES

Recebi, para uma mesma pergunta do meu projeto, MAIS DE UMA resposta — cada uma de uma
IA diferente. Quero UMA resposta consolidada: a melhor de cada, sem inventar nada que
nenhuma delas disse.

A regra de ouro do meu curso é "a IA propõe, eu decido". Por isso o que mais me importa
NÃO é só a resposta pronta — é enxergar ONDE as IAs divergem, porque é aí que eu preciso
pensar e decidir.

Para CADA pergunta abaixo (identificada por um rótulo entre colchetes, ex.: [1.2]),
devolva DUAS coisas, nesta ordem:

1) COMPARAÇÃO (texto livre e curto — NÃO use colchetes [ ] aqui):
   - Concordam: o que as respostas dizem igual (posso confiar).
   - Divergem: onde se contradizem — e qual você recomenda, e por quê.
   - Conferir: o que eu deveria checar na fonte da verdade (no meu caso, o Guia PMBOK 8).

2) RESPOSTA CONSOLIDADA: comece numa linha NOVA com o rótulo entre colchetes (o MESMO da
   pergunta, ex.: [1.2]) e escreva a resposta final EXATAMENTE no mesmo formato das
   respostas recebidas — mesmos campos, mesmos rótulos internos. Um único bloco por rótulo.

Escreva TODA a comparação primeiro e, só depois, os blocos consolidados com [rótulo]:
é nesse formato que o meu curso lê a resposta.

════════════════════════════════════════════════════════════
"""

_CABECALHO_EN = """CONSOLIDATE ANSWERS FROM DIFFERENT AIs

For one and the same question about my project I received MORE THAN ONE answer — each of
them from a different AI. I want ONE consolidated answer: the best of each, inventing
nothing that none of them said.

The golden rule of my course is "the AI proposes, I decide". So what matters most to me
is NOT just the finished answer — it is seeing WHERE the AIs disagree, because that is
where I have to think and decide.

For EACH question below (identified by a label in square brackets, e.g. [1.2]), give me
TWO things, in this order:

1) COMPARISON (short, free text — do NOT use square brackets [ ] here):
   - They agree: what the answers say in the same way (I can trust it).
   - They disagree: where they contradict each other — and which one you recommend, and why.
   - To check: what I should verify against the source of truth (in my case, the PMBOK
     Guide, 8th Edition).

2) CONSOLIDATED ANSWER: start on a NEW line with the label in square brackets (the SAME
   one as the question, e.g. [1.2]) and write the final answer EXACTLY in the same format
   as the answers you received — same fields, same internal labels. One single block per
   label.

Write the WHOLE comparison first and only then the consolidated blocks with [label]:
that is the format in which my course reads the answer.

════════════════════════════════════════════════════════════
"""

_CABECALHO = escolher(_CABECALHO_PT, _CABECALHO_EN)


def _bloco_pergunta(rotulo, variantes):
    linhas = [Tf("PERGUNTA [{0}] — {1} respostas para comparar:", rotulo, len(variantes)), ""]
    for i, v in enumerate(variantes):
        letra = chr(65 + i)                          # A, B, C...
        linhas.append(Tf("--- Resposta {0} ---", letra))
        linhas.append((v or "").strip())
        linhas.append("")
    return "\n".join(linhas)


def _quais(contestados):
    """'[1.2] (2 respostas), [2.1] (3 respostas)' — o que a tela mostra antes de copiar.
    Funcao propria (e nao um f-string dentro do main) para o teste de idioma poder olhar
    o que o aluno le: foi por aqui, e pelo cabecalho, que o portugues vazou no pacote EN."""
    return ", ".join(Tf("[{0}] ({1} respostas)", r, len(v)) for r, v in contestados.items())


def montar_prompt(contestados):
    partes = [_CABECALHO]
    for rotulo, variantes in contestados.items():
        partes.append(_bloco_pergunta(rotulo, variantes))
        partes.append("════════════════════════════════════════════════════════════")
    return "\n".join(partes).strip() + "\n"


def _salvar_arquivo(prompt):
    os.makedirs(_SAIDA, exist_ok=True)
    caminho = os.path.join(_SAIDA, "prompt-consolidar.txt")
    # Cabecalho de UMA linha: o arquivo inteiro e' o prompt (Ctrl+A, Ctrl+C).
    cabecalho = T("=== PROMPT DE CONSOLIDAÇÃO ===\n")
    with open(caminho, "w", encoding="utf-8") as f:
        f.write(cabecalho + prompt)
    return caminho


def main():
    header(T("Consolidar respostas de IAs diferentes"))
    ids = _ids()
    if not ids.get("INPUTS"):
        warn(T("ainda não encontrei o seu quadro (a lista INPUTS)."))
        print(T("  A Caixa de entrada mora no seu quadro. Rode o Passo 1 uma vez para o"))
        print(T("  quadro nascer e depois volte aqui."))
        return

    contestados, presentes = _contestados(ids)

    # Caso 1: a caixa está vazia (ou ainda no texto-guia).
    if not presentes:
        done(T("A sua Caixa de entrada está vazia."))
        print(T("  Para consolidar, primeiro cole DUAS respostas nela — a mesma pergunta"))
        print(T("  respondida por duas IAs. Cada resposta já vem com rótulos ([1.2], [2.1]...);"))
        print(T("  o mesmo rótulo aparecendo duas vezes é o que eu comparo.\n"))
        print(T("  Passo a passo:"))
        print(T("    1. rode um passo (ex.: Passo 1) e pegue o prompt pronto;"))
        print(T("    2. cole o MESMO prompt em duas IAs diferentes;"))
        print(T("    3. cole as DUAS respostas no cartão \"0. Caixa de entrada\";"))
        print(T("    4. rode esta opção (C) de novo."))
        return

    # Caso 2: tem respostas, mas nenhum rótulo se repete — nada para consolidar (ainda).
    if not contestados:
        rotulos = ", ".join(f"[{r}]" for r in presentes)
        done(T("Encontrei respostas na caixa, mas nenhuma para COMPARAR ainda."))
        print(Tf("  Rótulos presentes: {0}.", rotulos))
        print(T("  Cada um aparece uma vez só — então não há duas respostas concorrentes.\n"))
        print(T("  Para comparar duas IAs, cole a MESMA pergunta respondida por AMBAS: as duas"))
        print(T("  vão trazer o mesmo rótulo (ex.: duas vezes [1.2]) — e é isso que eu procuro."))
        print(T("  Dica: cole uma resposta embaixo da outra, sem apagar os rótulos."))
        return

    # Caso 3: há rótulo(s) repetido(s) — monta o prompt de consolidação.
    quais = _quais(contestados)
    ok(Tf("encontrei pergunta(s) com mais de uma resposta: {0}", quais))
    prompt = montar_prompt(contestados)
    caminho = _salvar_arquivo(prompt)

    print()
    if copiar(prompt):
        done(T("✅ O prompt de consolidação JÁ ESTÁ na sua área de transferência."))
        print(T("  Cole numa IA (Ctrl+V) — pode ser qualquer uma, até uma terceira, para"))
        print(T("  dar um voto de desempate."))
    else:
        done(T("O prompt de consolidação está pronto."))
        print(Tf("  Abra o arquivo e copie TUDO (Ctrl+A, Ctrl+C): {0}", caminho))

    print(T("\n  Quando a IA responder:"))
    print(T("    1. leia a COMPARAÇÃO (onde concordam · divergem · o que conferir) — é o"))
    print(T("       ponto onde VOCÊ decide;"))
    print(T("    2. copie a resposta INTEIRA dela;"))
    print(T("    3. cole no cartão \"0. Caixa de entrada\" do quadro, no lugar das duas"))
    print(T("       respostas de antes (é só selecionar tudo e colar por cima);"))
    print(T("    4. rode o passo normal (ex.: Passo 1) — ele lê a versão consolidada e segue."))
    print(Tf('\n  (Cópia de segurança do prompt em: {0})', caminho))


if __name__ == "__main__":
    try:
        main()
    except (KeyboardInterrupt, EOFError):
        print(T("\n(consolidação cancelada — nada foi alterado no seu quadro.)"))
