"""
Agile Together — Capitulo 6: extrair dados para a Apresentacao Final.

Faz, em uma rodada:
  1. Calcula resultado final dos 4 KRs agregando TODAS as Sprints concluidas
     (N = TOTAL_SPRINTS do .env; padrao 3, mas pode ser 2, 4, 6, 12, etc.)
  2. Extrai todos os cards Concluidos e Pendentes
  3. Gera um arquivo apresentacao_dados.txt com TUDO que voce precisa
     para montar a apresentacao final (10-15 min)
  4. Cria card final "RESUMO DO PROJETO" em Eventos Scrum

Token, Board ID, IDs de listas e TOTAL_SPRINTS vem do .env.

Rode pelo menu do curso (Iniciar).
"""
import os
from agile_together import (cfg, get_cards, compute_krs, create_card,
                            ensure_sprint_start_date)
from idioma import T, Tf

c = cfg()
HERE = os.path.dirname(os.path.abspath(__file__))
OUT = os.path.join(HERE, 'apresentacao_dados.txt')

N = c.get('TOTAL_SPRINTS', 3)
K = c.get('DAILIES_POR_SPRINT', 4)
EVENTOS_POR_SPRINT = K + 3   # 1 Planning + K Dailies + Review + Retro
META_KR3 = N * EVENTOS_POR_SPRINT   # eventos esperados no curso inteiro
META_KR4 = N * 5          # cards [IA] esperados no curso inteiro

print(Tf("Extraindo dados do projeto para a apresentacao final ({0} Sprint{1})...", N, 's' if N > 1 else ''))
print("=" * 55)

# 0. Toda Sprint que TEM card de Planning precisa de data de inicio; sem ela
#    seria contada como "nao iniciada" e os totais sairiam errados. Pergunta a
#    data ao aluno para cada Sprint iniciada sem data (Sprints sem card de
#    Planning sao realmente "nao iniciadas" e ficam de fora, sem perguntar).
for i in range(1, N + 1):
    ensure_sprint_start_date(i)

# 1. KRs por Sprint (agregamos para "totais do curso") + KRs da ultima Sprint.
#    Algumas Sprints podem nao ter Sprint Planning ainda (curso interrompido,
#    classe que so fechou 2 de 3, etc.) — neste caso compute_krs(i) levanta
#    SystemExit; tratamos como Sprint nao iniciada.
def _safe_compute(i):
    try:
        return compute_krs(i)
    except SystemExit:
        return None

por_sprint = []
for i in range(1, N + 1):
    r = _safe_compute(i)
    por_sprint.append((i, r))

sprints_concluidas = [(i, r) for i, r in por_sprint if r is not None]
N_DONE = len(sprints_concluidas)

# Totais agregados do curso
total_eventos_ok = sum(r['kr3']['valor'] for _, r in sprints_concluidas)
total_ia_entregues = sum(r['kr4']['valor'] for _, r in sprints_concluidas)
ultima_sprint_kr2 = sprints_concluidas[-1][1]['kr2']['valor'] if sprints_concluidas else 0

# KR1 do curso = soma de entregas / soma de planejados (das Sprints concluidas)
ent_total = 0
plan_total = 0
import re
for _, r in sprints_concluidas:
    m = re.match(r'^(\d+)\s+entregues\s+de\s+(\d+)', r['kr1']['detalhe'] or '')
    if m:
        ent_total += int(m.group(1))
        plan_total += int(m.group(2))
kr1_curso = round(ent_total / plan_total * 100) if plan_total else 0

# 2. Cards do board (uma vez)
concluido = get_cards('concluido')
sb = get_cards('sprint_backlog')
pb = get_cards('product_backlog')

def eh_evento(card):
    titulo = card.get('titulo', '')
    return any(kw in titulo for kw in
               ['Sprint Planning', 'Daily', 'Sprint Review',
                'Retrospectiva', 'RESUMO Sprint', 'RETROSPECTIVE Sprint',
                'CHECK-IN Sprint', 'RESUMO DO PROJETO', 'LICOES APRENDIDAS'])

# entregas = cards de PRODUTO (nao-evento) na lista Concluido. Para o
# total de EVENTOS, usamos total_eventos_ok que vem da soma das KR3 por
# Sprint (compute_krs ja checa status concluido=true e janela de datas)
# — antes contavamos por estar na lista Concluido, o que inflava o numero
# quando havia eventos movidos sem o flag concluido (ex.: dailies movidos
# manualmente).
entregas = [c_ for c_ in concluido if not eh_evento(c_)]
pendentes_sb = [c_ for c_ in sb
                if not c_.get('titulo', '').startswith('META DA SPRINT')]

# 3. Escrever arquivo
linhas = []
linhas.append("=" * 55)
linhas.append(T("AGILE TOGETHER — DADOS PARA APRESENTACAO FINAL"))
linhas.append("=" * 55)
linhas.append("")
linhas.append(Tf("OBJETIVO: {0}", c.get('OBJETIVO', T("(nao preenchido em .env)"))))
linhas.append(Tf("DURACAO DO CURSO: {0} Sprint{1} (concluidas: {2})", N, 's' if N > 1 else '', N_DONE))
linhas.append("")
linhas.append(Tf("RESULTADO FINAL DOS 4 KRs (agregado das {0} Sprint{1} concluida{2}):", N_DONE, 's' if N_DONE != 1 else '', 's' if N_DONE != 1 else ''))
linhas.append(Tf("  KR1 — Taxa de Conclusao: {0}% ({1}/{2} cards · meta 80%)", kr1_curso, ent_total, plan_total))
linhas.append(Tf("  KR2 — Velocidade (ultima Sprint): {0} cards", ultima_sprint_kr2))
linhas.append(Tf("  KR3 — Consistencia: {0}/{1} eventos documentados ({2} Sprints x {3})", total_eventos_ok, META_KR3, N, EVENTOS_POR_SPRINT))
linhas.append(Tf("  KR4 — Alavancagem IA: {0}/{1} tarefas com [IA] entregues ({2} Sprints x 5)", total_ia_entregues, META_KR4, N))
linhas.append("")
linhas.append(T("EVOLUCAO POR SPRINT:"))
for i, r in por_sprint:
    if r is None:
        linhas.append(Tf("  Sprint {0}: (nao iniciada)", i))
    else:
        linhas.append(Tf("  Sprint {0}: KR1 {1}%  KR2 {2} cards  KR3 {3}/{4}  KR4 {5}/5", i, r['kr1']['valor'], r['kr2']['valor'], r['kr3']['valor'], EVENTOS_POR_SPRINT, r['kr4']['valor']))
linhas.append("")
linhas.append(Tf("ENTREGAS DO PRODUTO ({0} cards concluidos):", len(entregas)))
for card in entregas:
    linhas.append(f"  - {card.get('titulo', '')[:80]}")
linhas.append("")
linhas.append(Tf("EVENTOS SCRUM REALIZADOS: {0} de {1}", total_eventos_ok, META_KR3))
linhas.append("")
linhas.append(Tf("ITENS NAO CONCLUIDOS ({0} no Sprint Backlog):", len(pendentes_sb)))
for card in pendentes_sb:
    linhas.append(f"  - {card.get('titulo', '')[:80]}")
linhas.append("")
linhas.append(Tf("BACKLOG NAO INICIADO ({0} cards no Product Backlog):", len(pb)))
for card in pb:
    linhas.append(f"  - {card.get('titulo', '')[:80]}")
linhas.append("")
linhas.append("=" * 55)
linhas.append(T("USE ESTES DADOS NA APRESENTACAO (estrutura sugerida):"))
linhas.append(T("  1. Contexto (2 min)"))
linhas.append(T("  2. Objetivo e KRs (2 min)"))
linhas.append(T("  3. Demo do Produto (5 min)"))
linhas.append(Tf("  4. Jornada das {0} Sprints (3 min)", N_DONE))
linhas.append(T("  5. Resultado dos OKRs (2 min) — use os numeros acima"))
linhas.append(T("  6. Licoes Aprendidas (3 min)"))
linhas.append(T("  7. Proximos Passos (1 min)"))
linhas.append(T("  8. Agradecimentos (1 min)"))
linhas.append("=" * 55)

with open(OUT, 'w', encoding='utf-8') as f:
    f.write('\n'.join(linhas))

print(Tf('\n  [OK] arquivo gerado: {0}', OUT))
print(Tf("  KR1 curso: {0}%  |  Entregas: {1}", kr1_curso, len(entregas)))
print(Tf("  Eventos: {0}/{1}  |  IA: {2}/{3}", total_eventos_ok, META_KR3, total_ia_entregues, META_KR4))

# 4. Card de resumo final
print(Tf('\n  Criando card RESUMO DO PROJETO em Eventos Scrum...'))
# O cartao RESUMO DO PROJETO e' o artefato final do curso: vai para o quadro do
# aluno e e' o que ele mostra na apresentacao. Um template SO', com posicoes
# numeradas — em pedacos ele sairia metade em ingles, metade em portugues.
descricao_card = Tf(
    "OBJETIVO: {0}\n\n"
    "DURACAO: {1} Sprints (concluidas: {2})\n\n"
    "RESULTADO FINAL\n"
    "  KR1: {3}% ({4}/{5} cards · meta 80%)\n"
    "  KR2: {6} cards na ultima Sprint\n"
    "  KR3: {7}/{8} eventos ({9} x {10})\n"
    "  KR4: {11}/{12} tarefas [IA] entregues ({13} x 5)\n\n"
    "ENTREGAS: {14} cards concluidos.",
    c.get('OBJETIVO', ''), N, N_DONE,
    kr1_curso, ent_total, plan_total,
    ultima_sprint_kr2,
    total_eventos_ok, META_KR3, N, EVENTOS_POR_SPRINT,
    total_ia_entregues, META_KR4, N,
    len(entregas))
create_card('eventos', T("RESUMO DO PROJETO — Agile Together"), descricao_card)
print(Tf("  [OK] Card criado"))

print("\n" + "=" * 55)
print(T("Pronto! Abra apresentacao_dados.txt e prepare seus slides."))
print("=" * 55)
