import type { Response } from "express";
import { prisma } from "../index";
import type { AppRequest } from "../types/context";
import { createProgramSchema, updateProgramSchema } from "../validators/program.validators";

export async function getAll(req: AppRequest, res: Response): Promise<void> {
  const userId = req.user?.id;
  const programs = await prisma.program.findMany({
    where: {
      OR: [
        { isPublic: true },
        { authorId: userId },
      ],
    },
    include: {
      author: { select: { id: true, username: true, avatar: true } },
      exercises: {
        include: { exercise: true },
        orderBy: { order: "asc" },
      },
    },
    orderBy: { createdAt: "desc" },
  });
  res.json(programs);
}

export async function getOne(req: AppRequest, res: Response): Promise<void> {
  const id = req.params.id as string;
  const userId = req.user?.id;
  const program = await prisma.program.findFirst({
    where: {
      id,
      OR: [{ isPublic: true }, { authorId: userId }],
    },
    include: {
      author: { select: { id: true, username: true, avatar: true } },
      exercises: {
        include: { exercise: true },
        orderBy: { order: "asc" },
      },
    },
  });
  if (!program) {
    res.status(404).json({ message: "Programme introuvable." });
    return;
  }
  res.json(program);
}

export async function create(req: AppRequest, res: Response): Promise<void> {
  const parsed = createProgramSchema.safeParse(req.body);
  if (!parsed.success) {
    res.status(400).json({ message: parsed.error.issues[0].message });
    return;
  }

  const { exercises, ...programData } = parsed.data;

  const program = await prisma.program.create({
    data: {
      ...programData,
      authorId: req.user!.id,
      exercises: {
        create: exercises.map(({ exerciseId, sets, reps, durationSec, order }) => ({
          exerciseId,
          sets,
          reps,
          durationSec,
          order,
        })),
      },
    },
    include: {
      exercises: {
        include: { exercise: true },
        orderBy: { order: "asc" },
      },
    },
  });
  res.status(201).json(program);
}

export async function update(req: AppRequest, res: Response): Promise<void> {
  const id = req.params.id as string;
  const parsed = updateProgramSchema.safeParse(req.body);
  if (!parsed.success) {
    res.status(400).json({ message: parsed.error.issues[0].message });
    return;
  }

  const program = await prisma.program.findFirst({
    where: { id, authorId: req.user!.id },
  });
  if (!program) {
    res.status(404).json({ message: "Programme introuvable." });
    return;
  }

  const updated = await prisma.program.update({
    where: { id },
    data: parsed.data,
    include: {
      exercises: {
        include: { exercise: true },
        orderBy: { order: "asc" },
      },
    },
  });
  res.json(updated);
}

export async function remove(req: AppRequest, res: Response): Promise<void> {
  const id = req.params.id as string;
  const program = await prisma.program.findFirst({
    where: { id, authorId: req.user!.id },
  });
  if (!program) {
    res.status(404).json({ message: "Programme introuvable." });
    return;
  }
  await prisma.program.delete({ where: { id } });
  res.status(204).send();
}