/*
 * O progresso do aluno num curso, sem nada do servidor (testável):
 * quantas aulas já foram, e qual aula o botão "Continuar" abre.
 */

export type AulaNaOrdem = { id: string; aberta: boolean };
export type MarcaDaAula = { concluida: boolean; atualizadoEm: string; posicaoS?: number };

export type ContagemDoCurso = { total: number; concluidas: number; percentual: number };

/* Só contam as aulas que existem hoje no curso (aula apagada some da conta). */
export function contarProgresso(aulas: Array<{ id: string }>, marcas: Map<string, MarcaDaAula>): ContagemDoCurso {
  const total = aulas.length;
  const concluidas = aulas.filter((a) => marcas.get(a.id)?.concluida).length;
  return { total, concluidas, percentual: total ? Math.round((concluidas / total) * 100) : 0 };
}

export type Continuar = { id: string; modo: "comecar" | "continuar" | "rever" };

/**
 * A aula do botão "Continuar":
 * - sem nada assistido: a primeira aula aberta ("Começar");
 * - a última aula mexida, se ainda não terminou;
 * - senão, a próxima aula aberta e não concluída depois dela (ou a primeira
 *   que faltar, de qualquer ponto);
 * - tudo o que está aberto já foi: "Rever" a primeira, ou null quando ainda
 *   há aula para abrir (o aluno está em dia).
 */
export function aulaParaContinuar(ordem: AulaNaOrdem[], marcas: Map<string, MarcaDaAula>): Continuar | null {
  const abertas = ordem.filter((a) => a.aberta);
  if (!abertas.length) return null;

  let ultima: { indice: number; quando: number } | null = null;
  ordem.forEach((aula, indice) => {
    const marca = marcas.get(aula.id);
    if (!marca) return;
    const quando = new Date(marca.atualizadoEm).getTime();
    if (!Number.isFinite(quando)) return;
    if (!ultima || quando > ultima.quando) ultima = { indice, quando };
  });
  const faltando = (a: AulaNaOrdem) => a.aberta && !marcas.get(a.id)?.concluida;

  if (!ultima) {
    const primeira = abertas[0];
    return { id: primeira.id, modo: "comecar" };
  }
  const { indice } = ultima as { indice: number; quando: number };
  const mexida = ordem[indice];
  if (faltando(mexida)) return { id: mexida.id, modo: "continuar" };
  const depois = ordem.slice(indice + 1).find(faltando) ?? ordem.find(faltando);
  if (depois) return { id: depois.id, modo: "continuar" };
  if (ordem.some((a) => !a.aberta)) return null;
  return { id: abertas[0].id, modo: "rever" };
}

/* A aula antes e depois desta, entre as que o aluno vê (abertas ou não). */
export function vizinhas(ordem: AulaNaOrdem[], aulaId: string): { anterior: AulaNaOrdem | null; proxima: AulaNaOrdem | null } {
  const indice = ordem.findIndex((a) => a.id === aulaId);
  if (indice < 0) return { anterior: null, proxima: null };
  return { anterior: ordem[indice - 1] ?? null, proxima: ordem[indice + 1] ?? null };
}