import type { Metadata } from "next";
import { notFound } from "next/navigation";

import Avisos from "@/components/digitais/Avisos";
import AreaDeMembros from "@/components/digitais/membros/AreaDeMembros";
import EntrarNosMembros from "@/components/digitais/membros/EntrarNosMembros";
import FontesDaLoja from "@/components/FontesDaLoja";
import { acessosDoCliente } from "@/lib/digitais/servidor/acessos";
import { textoDaCargaHoraria } from "@/lib/digitais/curso";
import { certificadosDoAluno, emitirCertificadoSeConcluiu } from "@/lib/digitais/servidor/certificados";
import { cursosDoAluno } from "@/lib/digitais/servidor/curso";
import { ajustesDosDigitais, corDaArea } from "@/lib/digitais/servidor/ajustes-do-pedido";
import { miniatura, TAMANHO } from "@/lib/foto";
import { carregarLoja } from "@/lib/loja/dados-da-loja";
import { lerClienteLogado, lerVisaoDaLoja } from "@/lib/loja/visao.server";
import { normalizeWhatsappForLink } from "@/lib/phone";
import { createAdminClient } from "@/lib/supabase-admin";

/*
 * A área de membros da loja ("Minhas compras"): entra-se pelo código no
 * e-mail (ou pela senha do portal) e vê tudo o que foi comprado de digital:
 * os cursos (com o "Continue de onde parou") e os downloads.
 *
 * Vale mesmo com a loja pausada: quem comprou continua baixando.
 */

export const dynamic = "force-dynamic";
export const revalidate = 0;

type Props = { params: Promise<{ slug: string }> };

export async function generateMetadata(props: Props): Promise<Metadata> {
  const { slug } = await props.params;
  const dados = await carregarLoja(slug);
  const nome = dados?.profile?.catalog_name || dados?.profile?.store_name || "Loja";
  return { title: { absolute: `Minhas compras | ${nome}` }, robots: { index: false, follow: false } };
}

export default async function PaginaDosMembros(props: Props) {
  const { slug } = await props.params;
  const dados = await carregarLoja(slug);
  const perfil = dados?.profile;
  if (!dados || !perfil) return notFound();
  const lojaId = String(perfil.id);

  const admin = createAdminClient();
  const [ajustes, cliente] = await Promise.all([ajustesDosDigitais(lojaId), lerClienteLogado(slug)]);
  const nomeDaLoja = String(perfil.catalog_name || perfil.store_name || "Loja");
  const nomeDaArea = ajustes.area.nome || nomeDaLoja;
  const cor = corDaArea(ajustes, perfil);
  const escuro = ajustes.area.fundo !== "claro";

  if (!cliente) {
    return (
      <>
        <FontesDaLoja perfil={perfil} />
        <EntrarNosMembros slug={slug} nomeDaArea={nomeDaArea} nomeDaLoja={nomeDaLoja} cor={cor} escuro={escuro} />
      </>
    );
  }

  const acessos = await acessosDoCliente(admin, lojaId, cliente.id);
  const { cursos, continuar, assistindo, modulos } = await cursosDoAluno(admin, { lojaId, clienteId: cliente.id, acessos }).catch((erro) => {
    console.error("[digitais] cursos da area de membros", erro);
    return { cursos: [], continuar: null, assistindo: [], modulos: [] };
  });

  /* Os certificados. Curso concluído antes de o certificado existir (ou de a
     loja ligar) ganha o dele agora, uma vez. */
  let certificados = ajustes.certificado.emitir ? await certificadosDoAluno(admin, lojaId, cliente.id).catch(() => []) : [];
  if (ajustes.certificado.emitir) {
    const faltando = cursos
      .filter((c) => c.situacao === "liberado" && c.total > 0 && c.percentual >= 100 && !certificados.some((cert) => cert.produtoId === c.produtoId))
      .slice(0, 3);
    if (faltando.length) {
      const emitidos = await Promise.all(
        faltando.map((curso) =>
          emitirCertificadoSeConcluiu(admin, {
            lojaId,
            clienteId: cliente.id,
            produtoId: curso.produtoId,
            inicio: acessos.find((a) => a.produtoId === curso.produtoId && a.situacao === "liberado")?.liberadoEm ?? null,
          }).catch(() => null)
        )
      );
      if (emitidos.some((e) => e?.novo)) certificados = await certificadosDoAluno(admin, lojaId, cliente.id).catch(() => certificados);
    }
  }
  const comprados = new Set(acessos.map((a) => a.produtoId));
  /* "Mais da loja": os outros digitais à venda, com o preço só se este
     visitante pode ver preço (regras da loja). */
  const { visao } = await lerVisaoDaLoja(slug, perfil);
  const outros = ((dados.products || []) as Array<{ id: string; name: string; price: number | null; image_url: string | null; product_kind?: string | null }>)
    .filter((p) => p.product_kind === "digital" && !comprados.has(p.id))
    .slice(0, 8)
    .map((p) => ({
      id: p.id,
      nome: p.name,
      preco: visao.mostrarPreco ? Number(p.price) || 0 : null,
      imagem: miniatura(p.image_url, TAMANHO.card) || p.image_url || null,
    }));

  return (
    <>
      <FontesDaLoja perfil={perfil} />
      <Avisos />
      <AreaDeMembros
        slug={slug}
        nomeDaArea={nomeDaArea}
        nomeDaLoja={nomeDaLoja}
        cor={cor}
        escuro={escuro}
        banner={ajustes.area.banner}
        cliente={{ nome: cliente.name || "" }}
        acessos={acessos}
        cursos={cursos.map((c) => ({ ...c, capa: miniatura(c.capa, TAMANHO.card) || c.capa }))}
        continuar={
          continuar
            ? { ...continuar, capa: miniatura(continuar.capa, TAMANHO.produto) || continuar.capa, certificado: continuar.certificado && ajustes.certificado.emitir }
            : null
        }
        certificados={certificados.map((c) => ({
          codigo: c.codigo,
          curso: c.curso,
          emitidoEm: c.emitidoEm,
          cargaHoraria: textoDaCargaHoraria(c.cargaHorariaMin),
        }))}
        assistindo={assistindo.map((a) => ({ ...a, capa: miniatura(a.capa, TAMANHO.card) || a.capa }))}
        modulos={modulos}
        outros={outros}
        whatsapp={normalizeWhatsappForLink(perfil.whatsapp) || null}
      />
    </>
  );
}