# -*- coding: utf-8 -*-
"""
Agile Together — os prompts que cada passo entrega ao aluno.

O QUE MUDOU EM 30/08/2026
  A biblioteca antiga (`_prompts.py`) falava com uma IA que EDITAVA o arquivo:
  "Tenho criar_backlog.py aberto", "edite SOMENTE entre os marcadores ZONA DE
  EDICAO", "vou revisar o diff e rodar com Ctrl+F5". Isso amarrava o curso a um
  tipo de IA (e a um editor). Aqui a IA so' precisa saber escrever texto — e o
  texto vai para o cartao "0. Caixa de entrada" do quadro.

REGRA DE OURO DO FORMATO
  Todo prompt termina dizendo, em uma linha, EXATAMENTE os cabecalhos que a
  resposta deve trazer. Sao esses mesmos rotulos que o passo procura (caixa.ler).
  Se um prompt mudar de rotulo, o passo correspondente muda junto — os dois vivem
  em pares e sao testados juntos.

  Os itens vem sempre em "• ", com campos depois de "|":
      • Correr 3x por semana | prioridade: Alta | pontos: 3
"""

_CABECALHO = (
    "Voce esta me ajudando num projeto real conduzido com Scrum e OKR "
    "(metodo Agile Together). Voce NAO executa codigo e NAO le arquivos meus: "
    "responda em TEXTO, que eu levo para o meu quadro."
)

_FORMATO = (
    "FORMATO DA RESPOSTA (obrigatorio)\n"
    "- Escreva os cabecalhos em MAIUSCULAS, cada um em sua linha, exatamente como pedidos.\n"
    "- Cada item comeca com \"• \" e os campos vem depois de \"|\", assim:\n"
    "    • Titulo do item | prioridade: Alta | pontos: 3\n"
    "- Nada de markdown (**, ##, tabelas), nada de codigo, nada de comentario fora dos blocos."
)


def _montar(*blocos):
    return "\n\n".join(b.strip() for b in blocos if b and b.strip())


# ─────────────────────────────────────────────────────────────────────────────
# Passo: Meta do Produto + Product Backlog
# ─────────────────────────────────────────────────────────────────────────────
def backlog(objetivo, total_sprints, quantos=9, software=False):
    dominio = (
        "Este projeto E' de desenvolvimento de software: os itens sao "
        "funcionalidades entregaveis, com valor visivel para quem usa."
        if software else
        "Este projeto NAO e' de software: os itens sao MACRO-ATIVIDADES PRATICAS "
        "que EU vou executar de verdade (habitos, compromissos, entregas do dia a "
        "dia). Use verbos de acao no infinitivo (Correr, Preparar, Registrar). "
        "NAO use o formato \"Como X, quero Y\" — isso e' de software."
    )
    return _montar(
        _CABECALHO,
        f"MEU OBJETIVO (OKR): {objetivo}",
        dominio,
        f"Preciso de duas coisas:\n"
        f"1. A META DO PRODUTO: uma frase inspiradora, concreta e verificavel, "
        f"alcancavel em {total_sprints} Sprints. E' o compromisso do Product Backlog "
        f"(Guia do Scrum): e' contra ela que o backlog e' ordenado.\n"
        f"2. O PRODUCT BACKLOG: {quantos} itens ordenados por prioridade, com pontos "
        f"de historia (escala 1, 2, 3, 5, 8). Distribua entre Alta (as alavancas "
        f"principais do objetivo), Media (consistencia) e Baixa (ajuste fino).",
        _FORMATO,
        "Responda com estes dois cabecalhos:\n"
        "META DO PRODUTO: <a frase>\n"
        "HISTORIAS:\n"
        "• <item> | prioridade: Alta | pontos: 3",
    )


def atualizar_backlog(objetivo, titulos):
    lista = "\n".join(f"  - {t}" for t in titulos) or "  (o backlog esta vazio)"
    return _montar(
        _CABECALHO,
        f"MEU OBJETIVO (OKR): {objetivo}",
        f"Este e' o meu Product Backlog HOJE, titulo por titulo:\n{lista}",
        "Reveja este backlog contra o objetivo. Voce pode (a) reescrever titulos que "
        "estao vagos ou que nao ajudam o objetivo e (b) propor itens que faltam. "
        "Ao reescrever, repita um TRECHO do titulo atual para eu saber qual e'.",
        _FORMATO,
        "Responda com estes dois cabecalhos (qualquer um pode vir vazio):\n"
        "RENOMEAR:\n"
        "• <trecho do titulo atual> | novo: <titulo novo> | prioridade: Alta | pontos: 2\n"
        "ADICIONAR:\n"
        "• <titulo novo> | prioridade: Media | pontos: 3",
    )


def refinar_backlog(objetivo, titulos):
    lista = "\n".join(f"  - {t}" for t in titulos) or "  (o backlog esta vazio)"
    return _montar(
        _CABECALHO,
        f"MEU OBJETIVO (OKR): {objetivo}",
        f"Meu Product Backlog:\n{lista}",
        "Refine cada item: confirme prioridade e pontos e escreva CRITERIOS DE "
        "ACEITACAO verificaveis (no formato \"Dado ... Quando ... Entao ...\"). "
        "Criterio de aceitacao e' o que me deixa dizer 'isto esta pronto' sem discussao.",
        _FORMATO,
        "Responda com este cabecalho:\n"
        "REFINAMENTO:\n"
        "• <trecho do titulo atual> | prioridade: Alta | pontos: 3 | "
        "aceitacao: Dado X, Quando Y, Entao Z; Dado A, Quando B, Entao C",
    )


# ─────────────────────────────────────────────────────────────────────────────
# Passo: refinar um item em tarefas
# ─────────────────────────────────────────────────────────────────────────────
def tarefas(titulo_do_item, descricao=""):
    ctx = f"\nDescricao do item: {descricao}" if descricao else ""
    return _montar(
        _CABECALHO,
        f"Quero decompor este item do meu Sprint Backlog em tarefas:\n"
        f"  {titulo_do_item}{ctx}",
        "De 3 a 7 tarefas, cada uma cabendo em UM DIA ou menos, com verbo no "
        "infinitivo. Cubra tambem o que costuma ser esquecido (preparacao, "
        "verificacao, o caso que da' errado).",
        _FORMATO,
        "Responda com este cabecalho:\nTAREFAS:\n• <tarefa>",
    )


# ─────────────────────────────────────────────────────────────────────────────
# Passo: Sprint Planning
# ─────────────────────────────────────────────────────────────────────────────
def planning(sprint, meta_produto, titulos, pontos_sugeridos=None):
    lista = "\n".join(f"  - {t}" for t in titulos) or "  (o Product Backlog esta vazio)"
    capacidade = (f"\nNa Sprint passada eu conclui cerca de {pontos_sugeridos} pontos — "
                  f"use isso como capacidade." if pontos_sugeridos else "")
    return _montar(
        _CABECALHO,
        f"Vamos planejar a SPRINT {sprint}." +
        (f"\nMETA DO PRODUTO: {meta_produto}" if meta_produto else ""),
        f"Estes sao os itens que EXISTEM no meu Product Backlog — use SOMENTE estes "
        f"titulos, copiados exatamente como estao:\n{lista}{capacidade}",
        "Escolha os itens que cabem nesta Sprint e escreva a META DA SPRINT: uma "
        "frase unica que diz o valor que a Sprint entrega (o compromisso do Sprint "
        "Backlog, pelo Guia do Scrum). A meta nao e' a lista de itens — e' o porque "
        "deles. Nao invente item que nao esta na lista acima.",
        _FORMATO,
        "Responda com estes dois cabecalhos:\n"
        "META DA SPRINT: <a frase>\n"
        "SELECIONADOS:\n• <titulo copiado da lista acima>",
    )


# ─────────────────────────────────────────────────────────────────────────────
# Passo: Daily Scrum
# ─────────────────────────────────────────────────────────────────────────────
def daily(sprint, meta_sprint, no_sprint_backlog, concluidos):
    def _bloco(titulo, itens):
        corpo = "\n".join(f"  - {t}" for t in itens) or "  (nenhum)"
        return f"{titulo}\n{corpo}"
    return _montar(
        _CABECALHO,
        f"DAILY SCRUM da Sprint {sprint}." +
        (f"\nMETA DA SPRINT: {meta_sprint}" if meta_sprint else ""),
        _bloco("Em andamento no Sprint Backlog:", no_sprint_backlog),
        _bloco("Ja' concluido nesta Sprint:", concluidos),
        "A Daily inspeciona o progresso rumo a META DA SPRINT e replaneja o dia. "
        "Diga em que eu devo focar HOJE — escolhendo entre os itens em andamento — "
        "e, se fizer falta, proponha tarefas novas curtas para hoje. Se algo esta "
        "travando a meta, escreva no bloco IMPEDIMENTO.",
        _FORMATO,
        "Responda com estes cabecalhos (IMPEDIMENTO pode vir vazio):\n"
        "FOCO DE HOJE:\n• <titulo copiado da lista de em andamento>\n"
        "NOVAS TAREFAS:\n• <titulo curto> | detalhe: <uma linha>\n"
        "  (o curso marca estas com [IA] no quadro — e o que o KR4 mede)\n"
        "IMPEDIMENTO: <uma linha, ou 'nenhum'>",
    )


# ─────────────────────────────────────────────────────────────────────────────
# Passo: Sprint Review
# ─────────────────────────────────────────────────────────────────────────────
def review(sprint, meta_sprint, entregues, pendentes):
    def _bloco(titulo, itens):
        corpo = "\n".join(f"  - {t}" for t in itens) or "  (nenhum)"
        return f"{titulo}\n{corpo}"
    return _montar(
        _CABECALHO,
        f"SPRINT REVIEW da Sprint {sprint}." +
        (f"\nMETA DA SPRINT: {meta_sprint}" if meta_sprint else ""),
        _bloco("Entregue (concluido):", entregues),
        _bloco("Nao concluido:", pendentes),
        "A Sprint Review inspeciona o INCREMENTO com as partes interessadas e adapta "
        "o Product Backlog — nao e' uma apresentacao de status. Escreva um resumo "
        "executivo de 3 a 5 linhas (o que mudou de verdade para quem usa o "
        "resultado, e o que ficou de fora e por que) e, se houver, o feedback que "
        "eu deveria levar para o Product Backlog.",
        _FORMATO,
        "Responda com estes dois cabecalhos:\n"
        "RESUMO: <3 a 5 linhas>\n"
        "FEEDBACK: <1 a 3 linhas, ou 'nenhum'>",
    )


# ─────────────────────────────────────────────────────────────────────────────
# Passo: Sprint Retrospective
# ─────────────────────────────────────────────────────────────────────────────
def retro(sprint, krs_texto=""):
    return _montar(
        _CABECALHO,
        f"SPRINT RETROSPECTIVE da Sprint {sprint}.",
        (f"Meus indicadores nesta Sprint:\n{krs_texto}" if krs_texto else ""),
        "A Retrospectiva olha para o PROCESSO (pessoas, interacoes, ferramentas, "
        "Definicao de Pronto), nao para o produto. Me ajude a fechar a Sprint com "
        "honestidade: o que funcionou, o que atrapalhou e — a parte que vale — no "
        "maximo 3 acoes concretas para a proxima Sprint. Acao vaga (\"melhorar a "
        "comunicacao\") nao serve: cada uma tem de caber num cartao.",
        _FORMATO,
        "Responda com estes tres cabecalhos:\n"
        "DEU CERTO:\n• <item>\n"
        "PROBLEMAS:\n• <item>\n"
        "ACOES:\n• <acao concreta para a proxima Sprint>",
    )


# ─────────────────────────────────────────────────────────────────────────────
# Passo: check-in dos KRs e encerramento
# ─────────────────────────────────────────────────────────────────────────────
def checkin(objetivo, relatorio_krs):
    return _montar(
        _CABECALHO,
        f"MEU OBJETIVO (OKR): {objetivo}",
        f"Este e' o relatorio dos meus 4 Key Results, lido do meu quadro:\n\n{relatorio_krs}",
        "Faca o check-in semanal comigo: para cada KR, diga a confianca de eu chegar "
        "na meta (verde >=70%, amarelo 40-69%, vermelho <40%) e por que. Depois "
        "escolha de 1 a 3 acoes concretas para a semana — nao dez. Onde o numero nao "
        "sustenta uma conclusao, diga que nao sustenta.",
        _FORMATO,
        "Responda com estes dois cabecalhos:\n"
        "LEITURA:\n• KR1 | confianca: verde | porque: <uma linha>\n"
        "ACOES:\n• <acao para esta semana>",
    )


def encerramento(objetivo, dados):
    return _montar(
        _CABECALHO,
        f"MEU OBJETIVO (OKR): {objetivo}",
        f"Estes sao os dados do meu quadro ao fim das Sprints:\n\n{dados}",
        "Me ajude a fechar o ciclo: o atingimento de cada KR (com o numero), os "
        "padroes que aparecem nas tres Sprints e as 3 licoes que valem levar para o "
        "proximo projeto. A curadoria final e' minha — nao invente numero que nao "
        "esta nos dados acima.",
        _FORMATO,
        "Responda com estes tres cabecalhos:\n"
        "ATINGIMENTO:\n• KR1 | resultado: <numero> | leitura: <uma linha>\n"
        "PADROES:\n• <padrao observado>\n"
        "LICOES:\n• <licao aprendida>",
    )


# ─────────────────────────────────────────────────────────────────────────────
# O IDIOMA DO PACOTE
#
# Um prompt nao e' frase solta: e' um documento estruturado que termina nomeando
# os cabecalhos exatos que a resposta deve trazer. Por isso ele NAO vai pelo
# catalogo de frases (T()) — vai por um MODULO PARALELO, que da' para ler lado a
# lado com este.
#
# A troca e' funcao a funcao e DEGRADA: prompt que ainda nao tem versao em ingles
# continua saindo em portugues, e o curso roda inteiro enquanto a traducao anda.
# E' a mesma promessa do T() — nunca quebrar, nunca sumir.
#
# ⛔ Os cabecalhos de prompts_en.py TEM alias em _together_kit/vocabulario.py.
#    Mudar um cabecalho la' sem acrescentar o alias aqui faz a IA responder certo
#    e o passo nao achar nada — sem erro, com o texto todo dentro do cartao.
# ─────────────────────────────────────────────────────────────────────────────
def _usar_ingles():
    try:
        from idioma import lang
        return lang() == "EN"
    except Exception:
        return False


if _usar_ingles():
    try:
        import prompts_en as _en
        for _nome in ("backlog", "atualizar_backlog", "refinar_backlog", "tarefas",
                      "planning", "daily", "review", "retro", "checkin", "encerramento"):
            _f = getattr(_en, _nome, None)
            if callable(_f):
                globals()[_nome] = _f
    except ImportError:
        pass          # sem o modulo EN, segue em portugues
