

import { NextRequest, NextResponse } from 'next/server';
import { PrismaClient } from '@prisma/client';
import { z } from 'zod';

export const dynamic = "force-dynamic";

const prisma = new PrismaClient();

const actividadUpdateSchema = z.object({
  nombre: z.string().min(2, "El nombre debe tener al menos 2 caracteres").optional(),
  descripcion: z.string().optional(),
  diasSemana: z.array(z.string()).optional(),
  horaInicio: z.string().optional(),
  horaFin: z.string().optional(),
  grupoEtario: z.string().optional(),
  nivelExperiencia: z.string().optional(),
  cuposMaximos: z.number().int().positive().optional(),
  cuposDisponibles: z.number().int().nonnegative().optional(),
  precio: z.number().nonnegative().optional(),
  duracion: z.number().int().positive().optional(),
  modalidad: z.string().optional(),
  fechaInicio: z.string().optional(),
  fechaFin: z.string().optional(),
  activa: z.boolean().optional(),
  publico: z.boolean().optional(),
});

// Obtener una actividad específica
export async function GET(
  request: NextRequest,
  { params }: { params: { id: string } }
) {
  try {
    const actividad = await prisma.actividad.findUnique({
      where: { id: params.id },
      include: {
        deporte: true,
        escuela: {
          select: {
            id: true,
            nombre: true,
          }
        },
        instructor: {
          select: {
            id: true,
            nombre: true,
            apellido: true,
          }
        },
        sede: {
          select: {
            id: true,
            nombre: true,
            direccion: true,
            provincia: {
              select: {
                nombre: true,
              }
            },
            comuna: {
              select: {
                nombre: true,
              }
            },
          }
        },
        ubicacionInstructor: {
          select: {
            id: true,
            nombre: true,
            direccion: true,
            provincia: {
              select: {
                nombre: true,
              }
            },
            comuna: {
              select: {
                nombre: true,
              }
            },
          }
        },
      }
    });

    if (!actividad) {
      return NextResponse.json(
        { error: 'Actividad no encontrada' },
        { status: 404 }
      );
    }

    return NextResponse.json({ actividad });

  } catch (error) {
    console.error('Error al obtener actividad:', error);
    
    return NextResponse.json(
      { error: 'Error interno del servidor' },
      { status: 500 }
    );
  } finally {
    await prisma.$disconnect();
  }
}

// Actualizar una actividad
export async function PUT(
  request: NextRequest,
  { params }: { params: { id: string } }
) {
  try {
    const body = await request.json();
    const validatedData = actividadUpdateSchema.parse(body);

    const updateData: any = {};

    if (validatedData.nombre !== undefined) updateData.nombre = validatedData.nombre;
    if (validatedData.descripcion !== undefined) updateData.descripcion = validatedData.descripcion;
    if (validatedData.diasSemana !== undefined) updateData.diasSemana = validatedData.diasSemana;
    if (validatedData.horaInicio !== undefined) updateData.horaInicio = validatedData.horaInicio;
    if (validatedData.horaFin !== undefined) updateData.horaFin = validatedData.horaFin;
    if (validatedData.grupoEtario !== undefined) updateData.grupoEtario = validatedData.grupoEtario;
    if (validatedData.nivelExperiencia !== undefined) updateData.nivelExperiencia = validatedData.nivelExperiencia;
    if (validatedData.cuposMaximos !== undefined) updateData.cuposMaximos = validatedData.cuposMaximos;
    if (validatedData.cuposDisponibles !== undefined) updateData.cuposDisponibles = validatedData.cuposDisponibles;
    if (validatedData.precio !== undefined) updateData.precio = validatedData.precio;
    if (validatedData.duracion !== undefined) updateData.duracion = validatedData.duracion;
    if (validatedData.modalidad !== undefined) updateData.modalidad = validatedData.modalidad;
    if (validatedData.activa !== undefined) updateData.activa = validatedData.activa;
    if (validatedData.publico !== undefined) updateData.publico = validatedData.publico;
    
    if (validatedData.fechaInicio !== undefined) {
      updateData.fechaInicio = validatedData.fechaInicio ? new Date(validatedData.fechaInicio) : null;
    }
    if (validatedData.fechaFin !== undefined) {
      updateData.fechaFin = validatedData.fechaFin ? new Date(validatedData.fechaFin) : null;
    }

    const actividad = await prisma.actividad.update({
      where: { id: params.id },
      data: updateData,
      include: {
        deporte: true,
        escuela: {
          select: {
            id: true,
            nombre: true,
          }
        },
        instructor: {
          select: {
            id: true,
            nombre: true,
            apellido: true,
          }
        },
      }
    });

    return NextResponse.json({
      message: 'Actividad actualizada exitosamente',
      actividad,
    });

  } catch (error) {
    console.error('Error al actualizar actividad:', error);
    
    if (error instanceof z.ZodError) {
      return NextResponse.json(
        { error: 'Datos inválidos', details: error.errors },
        { status: 400 }
      );
    }

    return NextResponse.json(
      { error: 'Error interno del servidor' },
      { status: 500 }
    );
  } finally {
    await prisma.$disconnect();
  }
}

// Eliminar una actividad
export async function DELETE(
  request: NextRequest,
  { params }: { params: { id: string } }
) {
  try {
    await prisma.actividad.delete({
      where: { id: params.id },
    });

    return NextResponse.json({
      message: 'Actividad eliminada exitosamente',
    });

  } catch (error) {
    console.error('Error al eliminar actividad:', error);
    
    return NextResponse.json(
      { error: 'Error interno del servidor' },
      { status: 500 }
    );
  } finally {
    await prisma.$disconnect();
  }
}
