
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 sedeSchema = z.object({
  nombre: z.string().min(2, "El nombre de la sede debe tener al menos 2 caracteres"),
  direccion: z.string().min(5, "La dirección es requerida"),
  provinciaId: z.string().min(1, "Provincia requerida"),
  comunaId: z.string().min(1, "Comuna requerida"),
  telefono: z.string().optional(),
  esPrincipal: z.boolean().default(false),
  infraestructura: z.string().optional(),
  latitud: z.number().optional(),
  longitud: z.number().optional(),
});

const escuelaSchema = z.object({
  nombre: z.string().min(2, "El nombre debe tener al menos 2 caracteres"),
  descripcion: z.string().optional(),
  telefono: z.string().optional(),
  email: z.string().email("Email inválido").optional(),
  sitioWeb: z.string().url("URL inválida").optional().or(z.literal('')),
  tipoInstitucion: z.string().optional(),
  infraestructura: z.string().optional(),
  certificaciones: z.string().optional(),
  sedes: z.array(sedeSchema).min(1, "Debe agregar al menos una sede"),
});

export async function POST(request: NextRequest) {
  try {
    const body = await request.json();
    const validatedData = escuelaSchema.parse(body);

    // Asegurar que solo una sede esté marcada como principal
    const sedesData = validatedData.sedes;
    let tienePrincipal = sedesData.some(s => s.esPrincipal);
    
    if (!tienePrincipal && sedesData.length > 0) {
      // Si no hay ninguna marcada como principal, marcar la primera
      sedesData[0].esPrincipal = true;
    } else if (tienePrincipal) {
      // Si hay múltiples marcadas como principal, mantener solo la primera
      let yaEncontroPrincipal = false;
      sedesData.forEach(sede => {
        if (sede.esPrincipal && yaEncontroPrincipal) {
          sede.esPrincipal = false;
        }
        if (sede.esPrincipal) {
          yaEncontroPrincipal = true;
        }
      });
    }

    const escuelaData: any = {
      nombre: validatedData.nombre,
      descripcion: validatedData.descripcion || null,
      telefono: validatedData.telefono || null,
      email: validatedData.email || null,
      sitioWeb: validatedData.sitioWeb || null,
      tipoInstitucion: validatedData.tipoInstitucion || null,
      infraestructura: validatedData.infraestructura || null,
      certificaciones: validatedData.certificaciones ? [validatedData.certificaciones] : [],
      verificada: false,
      activa: true,
      cuposDisponibles: true,
      sedes: {
        create: sedesData.map(sede => ({
          nombre: sede.nombre,
          direccion: sede.direccion,
          provinciaId: sede.provinciaId,
          comunaId: sede.comunaId,
          telefono: sede.telefono || null,
          esPrincipal: sede.esPrincipal,
          infraestructura: sede.infraestructura || null,
          latitud: sede.latitud || null,
          longitud: sede.longitud || null,
          activa: true,
        }))
      }
    };

    const escuela = await prisma.escuela.create({
      data: escuelaData,
      include: {
        sedes: true,
      }
    });

    return NextResponse.json({
      message: 'Institución registrada exitosamente con sus sedes',
      escuela: {
        id: escuela.id,
        nombre: escuela.nombre,
        sedes: escuela.sedes.length,
      },
    });

  } catch (error) {
    console.error('Error en registro de escuela:', 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();
  }
}
