

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 actividadSchema = z.object({
  nombre: z.string().min(2, "El nombre debe tener al menos 2 caracteres"),
  descripcion: z.string().optional(),
  deporteId: z.string().min(1, "Deporte requerido"),
  escuelaId: z.string().optional(),
  instructorId: z.string().optional(),
  sedeId: z.string().optional(),
  ubicacionInstructorId: z.string().optional(),
  diasSemana: z.array(z.string()).min(1, "Debe seleccionar al menos un día"),
  horaInicio: z.string().min(1, "Hora de inicio requerida"),
  horaFin: z.string().min(1, "Hora de fin requerida"),
  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(),
});

// Crear nueva actividad
export async function POST(request: NextRequest) {
  try {
    const body = await request.json();
    const validatedData = actividadSchema.parse(body);

    // Validar que tenga al menos escuela o instructor
    if (!validatedData.escuelaId && !validatedData.instructorId) {
      return NextResponse.json(
        { error: 'Debe especificar una escuela o un instructor' },
        { status: 400 }
      );
    }

    const actividadData: any = {
      nombre: validatedData.nombre,
      descripcion: validatedData.descripcion || null,
      deporteId: validatedData.deporteId,
      escuelaId: validatedData.escuelaId || null,
      instructorId: validatedData.instructorId || null,
      sedeId: validatedData.sedeId || null,
      ubicacionInstructorId: validatedData.ubicacionInstructorId || null,
      diasSemana: validatedData.diasSemana,
      horaInicio: validatedData.horaInicio,
      horaFin: validatedData.horaFin,
      grupoEtario: validatedData.grupoEtario || null,
      nivelExperiencia: validatedData.nivelExperiencia || null,
      cuposMaximos: validatedData.cuposMaximos || null,
      cuposDisponibles: validatedData.cuposDisponibles || validatedData.cuposMaximos || null,
      precio: validatedData.precio || null,
      duracion: validatedData.duracion || null,
      modalidad: validatedData.modalidad || "Presencial",
      fechaInicio: validatedData.fechaInicio ? new Date(validatedData.fechaInicio) : null,
      fechaFin: validatedData.fechaFin ? new Date(validatedData.fechaFin) : null,
      activa: true,
      publico: true,
    };

    const actividad = await prisma.actividad.create({
      data: actividadData,
      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,
          }
        },
        ubicacionInstructor: {
          select: {
            id: true,
            nombre: true,
            direccion: true,
          }
        },
      }
    });

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

  } catch (error) {
    console.error('Error al crear 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();
  }
}

// Obtener actividades con filtros
export async function GET(request: NextRequest) {
  try {
    const { searchParams } = new URL(request.url);
    const deporteId = searchParams.get('deporteId');
    const escuelaId = searchParams.get('escuelaId');
    const instructorId = searchParams.get('instructorId');
    const provincia = searchParams.get('provincia');
    const comuna = searchParams.get('comuna');
    const activa = searchParams.get('activa');

    const where: any = {};

    if (deporteId) {
      where.deporteId = deporteId;
    }

    if (escuelaId) {
      where.escuelaId = escuelaId;
    }

    if (instructorId) {
      where.instructorId = instructorId;
    }

    if (activa !== null) {
      where.activa = activa === 'true';
      where.publico = true;
    }

    // Filtrar por provincia/comuna a través de sede o ubicacionInstructor
    if (provincia || comuna) {
      where.OR = [];
      
      const ubicacionFilter: any = {};
      if (provincia) ubicacionFilter.provinciaId = provincia;
      if (comuna) ubicacionFilter.comunaId = comuna;

      if (Object.keys(ubicacionFilter).length > 0) {
        where.OR.push({ sede: ubicacionFilter });
        where.OR.push({ ubicacionInstructor: ubicacionFilter });
      }
    }

    const actividades = await prisma.actividad.findMany({
      where,
      include: {
        deporte: {
          select: {
            id: true,
            nombre: 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,
              }
            },
          }
        },
      },
      orderBy: {
        createdAt: 'desc',
      }
    });

    return NextResponse.json({ actividades });

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