"""
Project Together — powered by AI: Passo 1 (COMO) — escolher a abordagem de desenvolvimento.

O QUE E UMA ABORDAGEM DE DESENVOLVIMENTO
  "O meio usado para criar e evoluir um produto, servico ou resultado durante o
  ciclo de vida do projeto" (Guia PMBOK 8a ed.). Nao e "o jeito que a empresa
  trabalha" nem "a moda do mercado": e uma DECISAO do gerente de projetos com o
  time, tomada a partir do projeto que ele tem na mao. Ela vive num espectro:

      PREDITIVA  <-------------  hibrida  ------------->  ADAPTATIVA (agil)
      planeja tudo antes,                             entrega em incrementos curtos,
      controla contra a baseline                      aprende e reprioriza

  Este curso ensina as duas pontas — PREDITIVA e AGIL (a familia adaptativa; o
  Scrum e o metodo mais usado dela). O hibrido nao e um terceiro caminho que se
  escolhe no comeco: ele NASCE na pratica, quando voce conduz uma abordagem e
  toma emprestado o que funciona da outra. Por isso este script te devolve UMA
  escolha — e tambem o que observar para saber quando pegar emprestado.

O QUE ESTE SCRIPT FAZ
  Faz 5 perguntas. Cada resposta e uma nota de 1 a 5 entre dois polos. No fim ele
  mostra a sua regua, recomenda uma abordagem e explica POR QUE.

  POR QUE SO 5 (e nao os 19 fatores do Guia)
    O Guia PMBOK 8 (secao 4.3, "Consideracoes para a selecao de uma abordagem de
    desenvolvimento") lista 19 variaveis em 3 categorias: entrega, projeto e
    organizacao. Mas muitas delas apontam para a MESMA direcao e respondem a mesma
    coisa — "certeza dos requisitos" e "estabilidade do escopo" sao dois nomes para
    o mesmo eixo; "regulacao" e "requisitos de seguranca" tambem.
    Perguntar 19 vezes (ou 12) nao te faz decidir melhor: te faz responder no
    automatico. Aqui ficaram os 5 eixos que REALMENTE mudam a decisao — cada um
    junta as variaveis do Guia que dizem a mesma coisa (estao citadas em FATORES).
    E a regra de bolso do proprio Guia: requisitos claros e estaveis -> preditiva;
    requisitos incertos e feedback frequente valioso -> adaptativa (agil).

  Voce decide. O script grava a sua decisao em ABORDAGEM (no .env) — e e essa
  variavel que vai montar o seu quadro e mudar os proximos passos do curso.

  Ele tambem gera _saida/abordagem.md: a sua justificativa (para colar no cartao
  "COMO" do termo de abertura) e o prompt para pedir uma segunda opiniao a IA.

Pre-requisito: nenhum (rode antes mesmo de ter o quadro). Execute: Ctrl+F5.
"""
import os

from env import cfg, save_cfg
from runner import header, ok, done, copiar
# `nome_abordagem` e' o nome NA TELA ("PREDICTIVE"/"AGILE" no pacote EN); o valor gravado
# no .env continua sendo PREDITIVA/AGIL — identificador de codigo, que o curso inteiro
# compara (`abordagem == "AGIL"`). `normalizar_abordagem` faz o caminho de volta e ja'
# aceita o que o aluno digitar nos dois idiomas (predictive, agile, scrum, waterfall...).
from prompts import montar_prompt, nome_abordagem, normalizar_abordagem
from idioma import T, Tf

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

# OS 5 EIXOS QUE DECIDEM  (fator, polo 1 = PREDITIVA, polo 5 = AGIL, variaveis do Guia)
# Cada eixo agrupa as variaveis do Guia PMBOK 8 (secao 4.3) que apontam para a MESMA
# direcao — o nome delas esta na quarta coluna, para o aluno (e nos) sabermos de onde
# a pergunta veio. Nota 1 puxa para a preditiva; nota 5, para a agil.
FATORES = [
    (T("Requisitos"),
     T("estão claros e estáveis; já fizemos algo parecido"),
     T("são vagos ou vão mudar muito; vamos descobrir fazendo"),
     T("Requirements certainty · Degree of scope stability · Degree of innovation")),
    (T("Custo da mudança"),
     T("mudar depois é caro, difícil ou perigoso"),
     T("mudar depois é barato e rápido"),
     T("Ease of change")),
    (T("Forma de entrega"),
     T("só tem valor quando estiver inteiro, no fim"),
     T("dá para entregar pedaços úteis e aprender com cada um"),
     T("Delivery options · Feedback")),
    (T("Regulação e segurança"),
     T("exige norma, auditoria, aprovação formal — ou põe vidas em risco"),
     T("não há exigência regulatória nem risco à segurança"),
     T("Regulations · Safety requirements")),
    (T("Pessoas e cultura"),
     T("partes interessadas só aparecem em marcos; organização hierárquica; "
     "time grande ou espalhado"),
     T("partes interessadas disponíveis o tempo todo; cultura colaborativa; "
     "time pequeno e próximo"),
     T("Stakeholders · Culture · Organizational structure · Team size and location")),
]

# Regra de bolso do Guia PMBOK 8: requisitos claros e estaveis desde o inicio ->
# preditiva; requisitos incertos/complexos e feedback frequente valioso -> agil.
LIMITE_PREDITIVA = 2.6      # media <= 2.6  -> preditiva
LIMITE_AGIL = 3.4           # media >= 3.4  -> agil
                            # entre os dois -> meio da regua (hibrido na pratica)


def _perguntar(i, fator, polo1, polo5):
    print(f"\n{i}/5  {fator}")
    print(f"     1 = {polo1}")
    print(f"     5 = {polo5}")
    while True:
        r = input(T("       sua nota (1 a 5, ou 3 se for meio a meio): ")).strip()
        if r.isdigit() and 1 <= int(r) <= 5:
            return int(r)
        print(T("       (digite um número de 1 a 5)"))


def _media(notas):
    return sum(notas) / len(notas) if notas else 0


def _regua(m):
    """Desenha a posicao na regua preditiva <-> agil."""
    pos = int(round((m - 1) / 4 * 40))
    barra = ["-"] * 41
    barra[max(0, min(40, pos))] = "O"
    return f"{nome_abordagem('PREDITIVA')} |" + "".join(barra) + f"| {nome_abordagem('AGIL')}"


c = cfg()
projeto = (c.get("PROJECT") or "").strip()

header(T("Passo 1 — COMO: escolher a abordagem de desenvolvimento"))
print(T("A abordagem de desenvolvimento é o MEIO usado para criar e evoluir o produto"))
print(T("ao longo do ciclo de vida (Guia PMBOK 8). Ela não é um gosto pessoal: sai dos"))
print(T("fatores do SEU projeto. São 5 perguntas — os eixos que realmente mudam a"))
print(T("decisão. Responda pensando no projeto que você acabou de justificar."))
if projeto:
    print(Tf('\nSeu projeto: {0}', projeto))
print(T("\nEm cada pergunta, 1 puxa para a PREDITIVA e 5 puxa para a ÁGIL."))

notas = []
for i, (fator, p1, p5, _fonte) in enumerate(FATORES, 1):
    notas.append(_perguntar(i, fator, p1, p5))

media = _media(notas)
print("\n" + "=" * 62)
print(T("  O seu diagnóstico"))
print("=" * 62)
for (fator, _p1, _p5, _f), n in zip(FATORES, notas):
    print(f"  {n}  {fator}")
print(Tf("\n  MÉDIA: {0}\n", f"{media:.1f}"))
print("  " + _regua(media) + "\n")

if media <= LIMITE_PREDITIVA:
    rec, porque = "PREDITIVA", T(
        "os seus fatores dizem que dá para planejar antes de executar: o escopo é\n"
        "  conhecido o bastante e mudar depois custa caro. A previsibilidade vale\n"
        "  mais do que a flexibilidade aqui.")
elif media >= LIMITE_AGIL:
    rec, porque = "AGIL", T(
        "os seus fatores dizem que você vai DESCOBRIR o produto fazendo: os\n"
        "  requisitos ainda não estão claros e o feedback frequente vale mais do que\n"
        "  um plano detalhado que vai mudar de qualquer jeito.")
else:
    # Meio da regua: e exatamente o territorio do hibrido. O curso nao tem um
    # terceiro caminho — o aluno escolhe o lado mais forte e toma emprestado da outra.
    lado = "PREDITIVA" if media < 3 else "AGIL"
    rec, porque = lado, Tf(
        "você caiu no MEIO da régua ({0}) — é onde vive a abordagem híbrida.\n"
        "  O Guia PMBOK 8 diz que 'a maioria dos projetos pode se beneficiar muito de\n"
        "  uma abordagem híbrida'. No curso você conduz o projeto pelo lado mais forte\n"
        "  ({1}) e toma emprestado da outra o que fizer falta — veja abaixo o que\n"
        "  observar. Híbrido não se escolhe no começo: ele nasce quando você percebe\n"
        "  o que está faltando.", f"{media:.1f}", nome_abordagem(lado))

print(Tf("  RECOMENDAÇÃO: {0}", nome_abordagem(rec)))
print(Tf("  Por quê: {0}\n", porque))

# Os fatores que mais puxaram para cada lado — a materia-prima da justificativa
# que vai para o cartao "COMO" do termo de abertura.
ordenados = sorted(zip(FATORES, notas), key=lambda x: x[1])
puxam_preditiva = [(f[0], n) for f, n in ordenados if n <= 2]
puxam_agil = [(f[0], n) for f, n in reversed(ordenados) if n >= 4]
if puxam_preditiva:
    print(Tf("  Puxam para a PREDITIVA: {0}",
             ", ".join(f"{f} ({n})" for f, n in puxam_preditiva)))
if puxam_agil:
    print(Tf("  Puxam para a ÁGIL:      {0}",
             ", ".join(f"{f} ({n})" for f, n in puxam_agil)))

print("\n" + "-" * 62)
print(T("A decisão é SUA (o script apenas mostra o que os seus fatores dizem)."))
digitado = input(Tf("Qual abordagem você escolhe? [{0}/{1}] (Enter = {2}): ",
                    nome_abordagem("PREDITIVA"), nome_abordagem("AGIL"),
                    nome_abordagem(rec))).strip()
# Enter = a recomendacao. Qualquer outra coisa passa pelo normalizador, que entende os
# dois idiomas (PREDICTIVE/AGILE tanto quanto PREDITIVA/AGIL) — o aluno ingles digita o
# que ele acabou de LER na tela, e nao o valor interno.
escolha = normalizar_abordagem(digitado) if digitado else rec

save_cfg({"APPROACH": escolha})
ok(Tf("APPROACH={0} gravada no .env.", escolha))

# ── Só no ÁGIL: como você quer ESCREVER cada item do Product Backlog ──────────
# A história de usuário NÃO é obrigatória (o Guia Scrum não exige formato fixo) e
# dá para fazer um projeto ágil inteiro sem nenhuma. Por isso o PADRÃO é RESULTADO
# — o jeito mais simples, que serve a qualquer projeto (não só software). O aluno
# decide; a escolha vai para BACKLOG_FORMATO e molda o prompt do Passo 2.
if escolha == "AGIL":
    print("\n" + "-" * 62)
    print(T("No ÁGIL, o Product Backlog é uma lista priorizada de itens de VALOR. Como"))
    print(T("você quer ESCREVER cada item? (a história de usuário é opcional — dá para"))
    print(T("fazer um backlog inteiro sem nenhuma)"))
    print(T("  1 = RESULTADO de valor  — um resultado que passa a existir"))
    print(T("        ex.: 'Rotina de força 2x/semana em prática'   (o mais simples)"))
    print(T("  2 = HISTÓRIA de usuário — 'Como <quem>, quero <o quê>, para <valor>'"))
    print(T("        ex.: 'Como quem quer autonomia, quero treinar força, para...'"))
    print(T("  3 = A IA me ajuda (misto) — resultado por padrão, história quando"))
    print(T("        houver uma parte interessada distinta que se beneficia"))
    r = input(T("       sua escolha (1/2/3, Enter = 1 RESULTADO): ")).strip()
    formato = {"1": "RESULTADO", "2": "HISTORIA", "3": "MISTO"}.get(r, "RESULTADO")
    save_cfg({"BACKLOG_FORMATO": formato})
    _rotulo = {"RESULTADO": T("resultado de valor"), "HISTORIA": T("história de usuário"),
               "MISTO": T("misto (a IA ajuda a decidir por item)")}[formato]
    ok(Tf("BACKLOG_FORMATO={0} — seus itens serão escritos como {1}.", formato, _rotulo))
    print(T("       (mudou de ideia? é só rodar o Passo 1 (01a) de novo.)"))

# ── Saida: a justificativa (cartao COMO) + o prompt de segunda opiniao ────────
os.makedirs(SAIDA, exist_ok=True)
linhas = [Tf("# COMO — abordagem de desenvolvimento: {0}", nome_abordagem(escolha)), ""]
if projeto:
    linhas.append(Tf("Projeto: {0}", projeto))
linhas += [Tf("Média do diagnóstico: {0} (1 = preditiva pura, 5 = ágil pura)",
              f"{media:.1f}"), "",
           T("## Os 5 eixos (Guia PMBOK 8, seção 4.3)"), "",
           T("| Eixo | Nota | Variáveis do Guia |"), "|---|---|---|"]
for (fator, _p1, _p5, fonte), n in zip(FATORES, notas):
    linhas.append(f"| {fator} | {n} | {fonte} |")
linhas += ["", T("## Por que esta escolha"), "", porque.replace("\n  ", " "), ""]
if escolha == "PREDITIVA":
    linhas += [T("## O que observar (quando pegar emprestado do ágil)"), "",
               T("- O escopo mudou mais de 2 ou 3 vezes antes mesmo de começar a executar."),
               T("- As partes interessadas só entendem o que querem quando VEEM algo pronto."),
               T("- O plano detalhado está sempre desatualizado — ninguém olha mais para ele."),
               T("→ Comece a entregar em incrementos curtos e a mostrar cedo, mesmo mantendo"),
               T("  a baseline e o controle formal de mudanças.")]
else:
    linhas += [T("## O que observar (quando pegar emprestado do preditivo)"), "",
               T("- Alguém precisa saber a data e o custo do TODO (contrato, edital, "
                 "orçamento anual)."),
               T("- Há dependências externas com prazo travado (obra, fornecedor, norma)."),
               T("- O time perdeu a noção do quanto falta — ninguém sabe responder "
                 "'quando acaba?'."),
               T("→ Traga um roadmap com marcos e um orçamento por Sprint, mesmo mantendo o"),
               T("  backlog e a entrega incremental.")]

diagnostico = (Tf("Projeto: {0}\n", projeto or T("[o Passo 1 pergunta o nome]")) +
               Tf("Média do diagnóstico: {0}\n", f"{media:.1f}") +
               "\n".join(f"- {fator}: {n}/5  (1={p1} | 5={p5})"
                         for (fator, p1, p5, _fonte), n in zip(FATORES, notas)))

# O prompt da abordagem come [INPUT 1.1] [INPUT 1.2] [INPUT 2.1] (do QUADRO) e
# [INPUT DIAGNOSTICO] (estas 5 notas, que so' existem aqui). Se o quadro ainda nao
# existe, o resolver diz o que falta e o prompt sai assim mesmo — a decisao ja foi
# tomada; a IA e' segunda opiniao, nao pre-requisito.
try:
    import quadro
    ids = {k[5:]: v for k, v in c.items() if k.startswith("LIST_")}
    prompt, _faltando = quadro.resolver_inputs(
        montar_prompt("abordagem"), ids, extras={"DIAGNOSTICO": diagnostico})
except Exception:
    from prompts import preencher_inputs
    prompt = preencher_inputs(montar_prompt("abordagem"),
                              {"DIAGNOSTICO": diagnostico})

with open(os.path.join(SAIDA, "abordagem.md"), "w", encoding="utf-8") as f:
    f.write("\n".join(linhas) + "\n")
with open(os.path.join(SAIDA, "prompt-abordagem.txt"), "w", encoding="utf-8") as f:
    # Cabecalho de UMA linha: o arquivo inteiro e' o prompt (Ctrl+A, Ctrl+C). O convite
    # a discordar e' recado para o ALUNO — mora no terminal, logo abaixo, nao no arquivo.
    f.write(T("=== SEGUNDA OPINIÃO DA IA — abordagem de desenvolvimento ===\n")
            + prompt + "\n")

done(T("Abordagem escolhida."))
if copiar(prompt):
    print(T("  ✅ A SEGUNDA OPINIÃO está na sua área de transferência: cole na sua IA e"))
    print(T("     deixe ela discordar de você. É assim que se decide bem."))
else:
    print(T("  _saida/prompt-abordagem.txt  peça a segunda opinião à IA (ela pode discordar)"))
print(T("  _saida/abordagem.md          a sua justificativa (vai para o cartão 4.1)"))
print(T("\nAGORA RODE O PASSO 1 DE NOVO (01_iniciar_projeto.py)."))
print(T("Ele destranca o bloco COMO (cartões 4.1 a 4.6 — o ONDE é parte do como) e"))
print(T("também o QUANDO (5) e o QUANTO (6): é a abordagem que define como se calcula"))
print(Tf("cada um deles. E monta o RESTO do seu quadro na abordagem {0}:", escolha))
if escolha == "PREDITIVA":
    print(T("   EAP → Cronograma · Em execução · Entregue"))
else:
    print(T("   Product Backlog · Sprint Backlog · Incremento (Pronto)"))
