personalvirtual/
├── apps/
│   └── web/                      # Next.js (Painel Personal + Área do Aluno)
│       ├── app/
│       │   ├── (landing)/        # Landing page pública
│       │   ├── (auth)/           # Login/Registro do Personal
│       │   ├── painel/           # Área Desktop do Personal (autenticada)
│       │   └── a/[token]/        # Área Mobile do Aluno (hash, pública)
│       └── src/
│           ├── components/
│           ├── lib/              # prisma, stripe, auth
│           └── server/           # services (domínio)
├── packages/
│   ├── db/                       # Prisma schema + migrations
│   └── shared/                   # Tipos e utilidades compartilhadas
└── docs/

Personal  -> sessão autenticada (Auth.js)   -> acesso ao /painel
Aluno     -> hash token (NONCE de 32+ chars) -> acesso a /a/:token
Assinatura do Personal deve estar "active" para o sistema liberar recursos.

personals 1───* alunos
alunos    1───* treinos
treinos   1───* treino_exercicios
treino_exercicios 1───* execucoes
exercicios (catálogo, 1─* treino_exercicios)
personals 1───* recomendacoes_produtos
personals 1───* assinaturas
recomendacoes_produtos 1───* cliques_afiliados

// packages/db/schema.prisma

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

enum StatusAssinatura {
  TRIAL          // trial 7 dias
  ACTIVE         // ativa
  PAST_DUE       // cartão com falha
  CANCELED       // cancelada
  INCOMPLETE     // checkout não finalizado
}

enum DiaDaSemana {
  SEGUNDA
  TERCA
  QUARTA
  QUINTA
  SEXTA
  SABADO
  DOMINGO
}

model Personal {
  id            String   @id @default(cuid())
  nome          String
  email         String   @unique
  senhaHash     String   // Argon2id
  cref          String?
  avatarUrl     String?
  createdAt     DateTime @default(now())
  updatedAt     DateTime @updatedAt

  alunos             Aluno[]
  assinaturaAtualId  String? @unique
  assinaturaAtual    Assinatura? @relation("AssinaturaAtual", fields: [assinaturaAtualId], references: [id])
  assinaturas        Assinatura[] @relation("HistoricoAssinaturas")
  recomendacoes      RecomendacaoProduto[]
}

model Aluno {
  id              String  @id @default(cuid())
  personalId      String
  personal        Personal @relation(fields: [personalId], references: [id])
  nome            String
  apelido         String?  // usado na URL amigável
  email           String?
  telefone        String?
  dataNascimento  DateTime?
  hashToken       String  @unique // NONCE: crypto.randomBytes(32).toString('hex')
  ativo           Boolean @default(true)
  observacoes     String?
  createdAt       DateTime @default(now())
  updatedAt       DateTime @updatedAt

  treinos Treino[]

  @@index([personalId])
}

model Exercicio {
  id          String  @id @default(cuid())
  nome        String
  grupo       String? // Peito, Costas, Pernas...
  imagemUrl   String?
  videoUrl    String?
  criadoPor   String? @db.Uuid // personal que cadastrou (null = catálogo global)

  treinoExercicios TreinoExercicio[]
}

model Treino {
  id             String       @id @default(cuid())
  personalId     String
  alunoId        String
  titulo         String       // "Treino A — Peito e Tríceps"
  diaSemana      DiaDaSemana?
  dataAgendada   DateTime?    // treino avulso/datado
  ordem          Int          @default(0) // ordenação da semana
  ativo          Boolean      @default(true)
  createdAt      DateTime     @default(now())
  updatedAt      DateTime     @updatedAt

  personal Personal @relation(fields: [personalId], references: [id])
  aluno   Aluno    @relation(fields: [alunoId], references: [id])

  exercicios TreinoExercicio[]

  @@index([alunoId, dataAgendada])
  @@index([personalId])
}

model TreinoExercicio {
  id              String @id @default(cuid())
  treinoId        String
  exercicioId     String
  ordem           Int    // ordem de execução
  seriesPlanejadas Int   // ex.: 4
  repeticoes      Int?   // ex.: 10 (ou null p/ falha)
  cargaSugeridaKg Decimal? @db.Decimal(6,2)
  descansoSeg     Int?   @default(90)
  anotacoes       String?

  treino   Treino    @relation(fields: [treinoId], references: [id])
  exercicio Exercicio @relation(fields: [exercicioId], references: [id])
  execucoes Execucao[]

  @@unique([treinoId, exercicioId, ordem])
}

model Execucao {
  id                 String   @id @default(cuid())
  treinoExercicioId  String
  serieNumero        Int      // 1..seriesPlanejadas
  concluida          Boolean  @default(false)
  cargaExecutadaKg   Decimal? @db.Decimal(6,2)
  repsExecutadas     Int?
  duracaoSeg         Int?
  observacao         String?
  realizadaEm        DateTime @default(now())

  treinoExercicio TreinoExercicio @relation(fields: [treinoExercicioId], references: [id])

  @@unique([treinoExercicioId, serieNumero])
  @@index([treinoExercicioId, realizadaEm])
}

model Assinatura {
  id              String          @id @default(cuid())
  personalId      String
  stripeCustomerId String?
  stripeSubscriptionId String?     @unique
  plano           String          @default("MENSAL") // MENSAL, ANUAL
  status          StatusAssinatura @default(TRIAL)
  precoEmCentavos Int
  moeda           String          @default("brl")
  dataInicio      DateTime        @default(now())
  dataFim         DateTime?
  canceladoEm     DateTime?
  dataProximaCobranca DateTime?

  personal Personal @relation("HistoricoAssinaturas", fields: [personalId], references: [id])
  atualDe  Personal? @relation("AssinaturaAtual")

  @@index([personalId])
}

model RecomendacaoProduto {
  id          String  @id @default(cuid())
  personalId  String
  titulo      String      // "Whey da Growth"
  descricao   String?
  linkAfiliado String    // link com tag de afiliado (amzn.to/?tag=..., growth.ref=...)
  imagemUrl   String?
  categoria   String?     // suplementos, acessorios, roupas
  ordenacao   Int         @default(0)
  ativo       Boolean     @default(true)
  createdAt   DateTime    @default(now())
  updatedAt   DateTime    @updatedAt

  personal Personal @relation(fields: [personalId], references: [id])
  cliques  CliqueAfiliado[]

  @@index([personalId, ativo])
}

model CliqueAfiliado {
  id        String   @id @default(cuid())
  recomendacaoId String
  alunoId   String?  // anônimo se null
  ipHash    String?  // hash para contagem anônima
  createdAt DateTime @default(now())

  recomendacao RecomendacaoProduto @relation(fields: [recomendacaoId], references: [id])

  @@index([recomendacaoId, createdAt])
}

// middleware.ts — proteção do /painel
export async function middleware(req: NextRequest) {
  const { pathname } = req.nextUrl;

  if (pathname.startsWith('/painel')) {
    const session = await getToken({ req, secret: process.env.AUTH_SECRET });
    if (!session) return NextResponse.redirect(new URL('/login', req.url));

    const status = await getAssinaturaStatus(session.sub);
    if (status !== 'ACTIVE' && status !== 'TRIAL') {
      return NextResponse.redirect(new URL('/assinatura/vencida', req.url));
    }
  }
  return NextResponse.next();
}

export const config = {
  matcher: ['/painel/:path*'],
};

app/painel/
├── layout.tsx                    # Sidebar + topbar (Desktop)
├── page.tsx                      # Dashboard (indicadores de aderência)
├── alunos/
│   ├── page.tsx                  # Lista de alunos
│   ├── novo/page.tsx
│   └── [alunoId]/
│       ├── page.tsx              # Detalhe + treinos
│       └── treinos/[treinoId]/edit/page.tsx
└── recomendacoes/
    ├── page.tsx                  # CRUD de links (lista + form)
    └── [id]/analytics/page.tsx   # Cliques por período

src/components/personal/
├── AlunoTable.tsx
├── TreinoEditor.tsx              # Drag & drop de exercícios
├── ExercicioPicker.tsx
├── FichaPreview.tsx              # Prévia da ficha p/ PDF
├── AderenciaChart.tsx
└── LinkForm.tsx

app/a/[token]/
├── layout.tsx                    # Tema escuro, header com modo escuro + ícone "Extras"
├── page.tsx                      # Hoje (treino do dia)
├── treinos/[treinoId]/page.tsx   # Execução (checklist de séries)
└── extras/page.tsx               # Aba de Recomendações ("Dicas do seu Personal")

src/components/aluno/
├── TreinoCard.tsx                # Resumo do dia
├── ExercicioChecklist.tsx        # Séries em checklist com botões grandes
├── SerieRow.tsx                  # Linha de série (marca concluída / pula)
├── ProgressRing.tsx / ProgressBar.tsx
├── ExtrasDrawer.tsx              # Acesso secundário às recomendações
└── RecommendationCard.tsx

┌─────────────────────────────┐
│ [Logo]  [Treino]  [Extras 🔧]│  <- ícone secundário, pequeno
├─────────────────────────────┤
│  TREINO DO DIA              │
│  [barra de progresso]       │
│  ▸ Peito                    │
│     Supino: ▢▢▢▢           │
│     Crucifixo: ▢▢▢         │
│  [Concluir Treino]          │
└─────────────────────────────┘

Personal                         Next.js/API                        Stripe
   |  1. POST /api/assinatura/checkout  |                              |
   |----------------------------------->| 2. createCheckoutSession     |
   |                                    |----------------------------->|
   |                                    | 3. session (client_reference_id) |
   |  4. redirect para checkout         |<-----------------------------|
   |<-----------------------------------|                              |
   |  5. Usuário paga                   |                              |
   |                                    | 6. webhook checkout.session.completed |
   |                                    |<-----------------------------|
   |                                    | 7. atualiza Assinatura=ACTIVE + stripeSubscriptionId
   |  8. GET /api/assinatura/status     |                              |
   |----------------------------------->| 9. retorna ACTIVE            |

[requisição no /painel ou rota do sistema]
        │
        ▼
Assinatura.status ∈ { TRIAL, ACTIVE } ?
        │                    │
       Sim                  Não
        │                    │
   PERMITE USO        Redireciona p/ página
                      "Assinatura vencida" +
                      link do Portal de Billing

// src/server/services/assinatura.ts
export async function hasAcessoAtivo(personalId: string): Promise<boolean> {
  const assinatura = await prisma.assinatura.findFirst({
    where: {
      personalId,
      status: { in: ['TRIAL', 'ACTIVE'] },
    },
    orderBy: { dataInicio: 'desc' },
  });
  if (!assinatura) return false;

  // confere com o Stripe para desktops e mudanças fora do webhook
  const sub = await stripe.subscriptions.retrieve(assinatura.stripeSubscriptionId);
  return ['trialing', 'active'].includes(sub.status);
}

// src/server/services/treino.ts
import type { TreinoExercicio, Execucao } from '@personalvirtual/db';

type Item = TreinoExercicio & { execucoes: Execucao[] };

export interface ProgressoTreino {
  treinoId: string;
  totalSeries: number;
  concluidas: number;
  percentual: number;
  exercicios: Array<{
    treinoExercicioId: string;
    concluido: boolean; // todas as séries deste exercício concluídas
    seriesConcluidas: number;
  }>;
  treinoConcluido: boolean; // TODAS as séries de TODOS os exercícios
}

export function calcularProgresso(
  treinoId: string,
  exercicios: Item[],
): ProgressoTreino {
  let totalSeries = 0;
  let concluidas = 0;

  const mapeados = exercicios.map((te) => {
    const feitas = te.execucoes.filter((e) => e.concluida);
    const exercicioConcluido = feitas.length >= te.seriesPlanejadas;

    totalSeries += te.seriesPlanejadas;
    concluidas += Math.min(feitas.length, te.seriesPlanejadas);

    return {
      treinoExercicioId: te.id,
      concluido: exercicioConcluido,
      seriesConcluidas: feitas.length,
    };
  });

  const percentual = totalSeries === 0 ? 0 : Math.round((concluidas / totalSeries) * 100);

  return {
    treinoId,
    totalSeries,
    concluidas,
    percentual,
    exercicios: mapeados,
    treinoConcluido: concluidas >= totalSeries && totalSeries > 0,
  };
}

// src/components/aluno/ExtrasDrawer.tsx
'use client';

import { useEffect, useState } from 'react';
import type { RecomendacaoProduto } from '@personalvirtual/db';

interface Props {
  token: string;
  alunoId: string;
  onClose: () => void;
}

export function ExtrasDrawer({ token, alunoId, onClose }: Props) {
  const [recomendacoes, setRecomendacoes] = useState<RecomendacaoProduto[]>([]);
  const [carregando, setCarregando] = useState(true);

  useEffect(() => {
    fetch(`/api/p/a/${token}/recomendacoes`)
      .then((r) => r.json())
      .then(setRecomendacoes)
      .finally(() => setCarregando(false));
  }, [token]);

  const aoClicar = async (id: string, link: string) => {
    // registra o clique sem bloquear a navegação
    fetch(`/api/p/a/${token}/recomendacoes/${id}/clique`, { method: 'POST' }).catch(() => {});
    window.open(link, '_blank', 'noopener,noreferrer');
  };

  return (
    <aside className="drawer" role="dialog" aria-label="Dicas do seu Personal">
      <header>
        <h2>Dicas do seu Personal</h2>
        <button onClick={onClose} aria-label="Fechar">×</button>
      </header>

      {carregando && <p className="muted">Carregando…</p>}

      <ul className="lista-recomendacoes">
        {recomendacoes.map((r) => (
          <li key={r.id}>
            <button
              className="recommendation-card"
              onClick={() => aoClicar(r.id, r.linkAfiliado)}
            >
              {r.imagemUrl && <img src={r.imagemUrl} alt="" loading="lazy" />}
              <div>
                <strong>{r.titulo}</strong>
                {r.descricao && <p>{r.descricao}</p>}
                <span className="badge">{r.categoria}</span>
              </div>
            </button>
          </li>
        ))}
      </ul>
    </aside>
  );
}

SELECT
  ex.nome AS exercicio,
  COUNT(*) FILTER (WHERE NOT e.concluida) AS series_puladas,
  COUNT(*) AS series_planejadas,
  ROUND(100.0 * COUNT(*) FILTER (WHERE e.concluida) / COUNT(*), 1) AS aderencia_pct
FROM "TreinoExercicio" te
JOIN "Exercicio" ex ON ex.id = te."exercicioId"
LEFT JOIN "Execucao" e ON e."treinoExercicioId" = te.id
  AND e."realizadaEm" >= now() - interval '30 days'
WHERE te."treinoId" = ANY(:treinosDoAluno)
GROUP BY ex.id, ex.nome
ORDER BY series_puladas DESC;