import "@supabase/functions-js/edge-runtime.d.ts";
import { corsHeaders } from "../_shared/cors.ts";
import { HttpError, sendError, sendSuccess } from "../_shared/utils.ts";
import { createClient } from "@supabase/supabase-js";
import type { Database, Json } from "../_shared/database.types.ts";
import { z } from "zod";
import {
  OpenAIService,
  type StructuredResponseOptions,
} from "../_shared/openai-service.ts";

Deno.serve(async (req: Request): Promise<Response> => {
  const url = new URL(req.url);
  const functionName = url.pathname.split("/").pop();
  console.log(
    `[${new Date().toISOString()}][${functionName}]: Request received`,
  );

  if (req.method === "OPTIONS") {
    return new Response(null, { status: 204, headers: corsHeaders });
  }

  try {
    const method = req.method;
    if (method !== "POST") {
      console.error(
        `[${
          new Date().toISOString()
        }][${functionName}]: Invalid method: ${method}`,
      );
      throw new HttpError(
        405,
        "Método no permitido.",
        "METHOD_NOT_ALLOWED",
        { method },
      );
    }

    const authHeaderRaw = req.headers.get("Authorization") ??
      req.headers.get("authorization");
    if (!authHeaderRaw) {
      console.error(
        `[${
          new Date().toISOString()
        }][${functionName}]: Missing Authorization header`,
      );
      throw new HttpError(
        401,
        "No autorizado.",
        "UNAUTHORIZED",
        { reason: "missing_authorization_header" },
      );
    }

    const contentType = (req.headers.get("content-type") || "").toLowerCase();
    if (!contentType.startsWith("multipart/form-data")) {
      console.error(
        `[${
          new Date().toISOString()
        }][${functionName}]: Unsupported content type: ${contentType}`,
      );
      throw new HttpError(
        415,
        "Content-Type no soportado.",
        "UNSUPPORTED_MEDIA_TYPE",
        { contentType },
      );
    }

    const SUPABASE_URL = Deno.env.get("SUPABASE_URL");
    const SUPABASE_ANON_KEY = Deno.env.get("SUPABASE_ANON_KEY");
    if (!SUPABASE_URL || !SUPABASE_ANON_KEY) {
      throw new HttpError(
        500,
        "Configuración del servidor incompleta.",
        "MISSING_ENV",
        {
          missing: [
            !SUPABASE_URL ? "SUPABASE_URL" : null,
            !SUPABASE_ANON_KEY ? "SUPABASE_ANON_KEY" : null,
          ].filter(Boolean),
        },
      );
    }

    // If needed for RLS-protected reads, create an anon client with user's JWT
    // Currently not used; kept here for future expansion.
    // const supabaseAnon = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
    //   global: {
    //     headers: {
    //       Authorization: authHeaderRaw,
    //     },
    //   },
    // });

    const SERVICE_ROLE_KEY = Deno.env.get("SUPABASE_SERVICE_ROLE_KEY");
    if (!SERVICE_ROLE_KEY) {
      throw new HttpError(
        500,
        "Configuración del servidor incompleta.",
        "MISSING_ENV",
        { missing: ["SUPABASE_SERVICE_ROLE_KEY"] },
      );
    }

    const supabaseService = createClient<Database>(
      SUPABASE_URL,
      SERVICE_ROLE_KEY,
    );

    const formData = await req.formData();
    const validation = parseAndValidate(formData);
    if (!validation.success) {
      console.error(
        `[${new Date().toISOString()}][${functionName}]: Validation errors:`,
        validation.errors,
      );
      const message = validation.errors
        .map((e, i) => `${i + 1}. ${e}`)
        .join("\n");
      throw new HttpError(
        422,
        message,
        "VALIDATION_ERROR",
        { errors: validation.errors },
      );
    }

    const payload = validation.data;

    const { data: estructura, error: estructuraError } = await supabaseService
      .from("estructuras_asignatura")
      .select("id,nombre,definicion,version")
      .eq("id", payload.datosBasicos.estructuraId)
      .single();
    if (estructuraError) {
      const maybeCode = (estructuraError as { code?: string }).code;
      if (maybeCode === "PGRST116") {
        throw new HttpError(
          404,
          "No se encontró la estructura de la asignatura.",
          "NOT_FOUND",
          {
            table: "estructuras_asignatura",
            id: payload.datosBasicos.estructuraId,
          },
        );
      }
      throw new HttpError(
        500,
        "No se pudo obtener la estructura de la asignatura.",
        "SUPABASE_QUERY_FAILED",
        estructuraError,
      );
    }

    const systemPrompt =
      "Eres un asistente experto en diseño curricular. Responde únicamente con JSON válido que cumpla estrictamente el JSON Schema proporcionado.";

    const userPrompt =
      `Genera un borrador completo completo de una ASIGNATURA con base en lo siguiente:\n` +
      `- Nombre de la asignatura: ${payload.datosBasicos.nombre}\n` +
      `- Código (clave de la asignatura): ${
        payload.datosBasicos.codigo ?? "(no especificado)"
      }\n` +
      `- Tipo: ${payload.datosBasicos.tipo ?? "(no especificado)"}\n` +
      `- Número de créditos: ${payload.datosBasicos.creditos}\n` +
      `- Horas académicas: ${
        payload.datosBasicos.horasAcademicas ?? "(no especificado)"
      }\n` +
      `- Horas independientes: ${
        payload.datosBasicos.horasIndependientes ?? "(no especificado)"
      }\n` +
      `- Descripción del enfoque académico (sobre el contenido de la respuesta generada): ${
        payload.iaConfig?.descripcionEnfoqueAcademico ?? "(ninguna)"
      }\n` +
      `- Instrucciones adicionales (sobre el formato de la respuesta generada): ${
        payload.iaConfig?.instruccionesAdicionalesIA ?? "(ninguna)"
      }`;

    const schemaDef: Record<string, unknown> =
      typeof estructura?.definicion === "object" &&
        estructura?.definicion !== null
        ? (estructura.definicion as Record<string, unknown>)
        : {};

    const aiStructuredPayload: StructuredResponseOptions = {
      model: "gpt-5-nano",
      input: [
        { role: "system", content: systemPrompt },
        { role: "user", content: userPrompt },
      ],
      text: {
        format: {
          type: "json_schema",
          name: "asignatura_contenido_tematico",
          schema: schemaDef,
          strict: true,
        },
      },
    };

    const svc = OpenAIService.fromEnv();
    if (!(svc instanceof OpenAIService)) {
      throw new HttpError(
        500,
        "Configuración del servidor incompleta.",
        "OPENAI_MISCONFIGURED",
        svc,
      );
    }

    const aiResult = await svc.createStructuredResponse(
      aiStructuredPayload,
      payload.archivosAdjuntos,
    );
    if (!aiResult.ok) {
      const status = aiResult.code === "MissingEnv" ? 500 : 502;
      throw new HttpError(
        status,
        "No se pudo generar la asignatura con IA.",
        "OPENAI_REQUEST_FAILED",
        aiResult,
      );
    }

    let aiOutput = aiResult.output ?? null;
    if (aiOutput == null && aiResult.outputText) {
      try {
        aiOutput = JSON.parse(aiResult.outputText);
      } catch {
        throw new HttpError(
          502,
          "La respuesta de la IA no es JSON válido.",
          "OPENAI_INVALID_JSON",
          { outputText: aiResult.outputText },
        );
      }
    }
    if (!aiOutput) {
      throw new HttpError(
        502,
        "La respuesta de la IA no contiene salida estructurada.",
        "OPENAI_MISSING_STRUCTURED_OUTPUT",
        { outputText: aiResult.outputText ?? null },
      );
    }

    const aiOutputJson: Json = aiOutput as unknown as Json;

    const asignaturaInsert:
      Database["public"]["Tables"]["asignaturas"]["Insert"] = {
        plan_estudio_id: payload.plan_estudio_id,
        estructura_id: payload.datosBasicos.estructuraId,
        nombre: payload.datosBasicos.nombre,
        codigo: payload.datosBasicos.codigo ?? null,
        creditos: payload.datosBasicos.creditos,
        horas_academicas: payload.datosBasicos.horasAcademicas ?? null,
        horas_independientes: payload.datosBasicos.horasIndependientes ?? null,
        tipo: (payload.datosBasicos.tipo ?? undefined) as Database["public"][
          "Tables"
        ]["asignaturas"]["Insert"]["tipo"],
        tipo_origen: "IA",
        datos: aiOutputJson,
        meta_origen: {
          generado_por: "ai_generate_subject",
          ai: {
            responseId: aiResult.responseId ?? null,
            conversationId: aiResult.conversationId ?? null,
            model: aiResult.model,
            usage: aiResult.usage ?? null,
          },
          referencias: {
            archivosReferenciaIds: payload.iaConfig?.archivosReferencia ?? null,
            repositoriosReferencia: payload.iaConfig?.repositoriosReferencia ??
              null,
          },
          iaConfig: {
            descripcionEnfoqueAcademico:
              payload.iaConfig?.descripcionEnfoqueAcademico ?? null,
            instruccionesAdicionalesIA:
              payload.iaConfig?.instruccionesAdicionalesIA ?? null,
          },
        } as unknown as Json,
      };

    const { data: asignatura, error: asignaturaError } = await supabaseService
      .from("asignaturas")
      .insert(asignaturaInsert)
      .select(
        "id,nombre,codigo,tipo,creditos,horas_academicas,horas_independientes,estructura_id,plan_estudio_id,contenido_tematico,meta_origen,creado_en,actualizado_en",
      )
      .single();

    if (asignaturaError) {
      const maybeCode = (asignaturaError as { code?: string }).code;
      const status = maybeCode ? 409 : 500;
      throw new HttpError(
        status,
        "No se pudo guardar la asignatura.",
        "SUPABASE_INSERT_FAILED",
        { ...asignaturaError, code: maybeCode },
      );
    }

    console.log(
      `[${
        new Date().toISOString()
      }][${functionName}]: Request processed successfully`,
    );
    return sendSuccess(asignatura);
  } catch (error) {
    if (error instanceof HttpError) {
      console.error(
        `[${new Date().toISOString()}][${functionName}] ⚠️ Handled Error:`,
        {
          message: error.message,
          code: error.code,
          internalDetails: error.internalDetails || "N/A",
        },
      );

      return sendError(error.status, error.message, error.code);
    }

    const unexpectedError = error instanceof Error
      ? error
      : new Error(String(error));

    console.error(
      `[${
        new Date().toISOString()
      }][${functionName}] 💥 CRITICAL UNHANDLED ERROR:`,
      unexpectedError.stack || unexpectedError.message,
    );

    return sendError(
      500,
      "Ocurrió un error inesperado en el servidor.",
      "INTERNAL_SERVER_ERROR",
    );
  }
});

const jsonFromString = <T extends z.ZodTypeAny>(schema: T) =>
  z.string().transform((str, ctx) => {
    try {
      return JSON.parse(str);
    } catch {
      ctx.addIssue({
        code: z.ZodIssueCode.custom,
        message: "El formato no es un JSON válido",
      });
      return z.NEVER;
    }
  }).pipe(schema);

const jsonFromStringOptional = <T extends z.ZodTypeAny>(schema: T) =>
  z.string().optional().default("{}").transform((str, ctx) => {
    try {
      return JSON.parse(str);
    } catch {
      ctx.addIssue({
        code: z.ZodIssueCode.custom,
        message: "El formato no es un JSON válido",
      });
      return z.NEVER;
    }
  }).pipe(schema);

const DatosBasicosSchema = z.object({
  nombre: z.string().min(1, "El nombre es requerido"),
  codigo: z.string().min(1).optional().nullable(),
  tipo: z.union([z.string().min(1), z.null()]).optional().transform((v) =>
    v ?? null
  ),
  creditos: z.number({ invalid_type_error: "Créditos debe ser numérico" })
    .positive("Créditos debe ser >= 0"),
  horasAcademicas: z.number().int().nonnegative().optional().nullable(),
  horasIndependientes: z.number().int().nonnegative().optional().nullable(),
  estructuraId: z.string().uuid("estructuraId debe ser un UUID"),
});

const IAConfigSchema = z.object({
  descripcionEnfoqueAcademico: z.string().optional(),
  instruccionesAdicionalesIA: z.string().optional(),
  archivosReferencia: z.array(z.string().uuid()).optional(),
  repositoriosReferencia: z.array(z.string().uuid()).optional(),
}).partial();

const SolicitudSchema = z.object({
  plan_estudio_id: z.string().uuid("plan_estudio_id debe ser un UUID"),
  datosBasicos: jsonFromString(DatosBasicosSchema),
  iaConfig: jsonFromStringOptional(IAConfigSchema),
  archivosAdjuntos: z.array(z.instanceof(File)).optional().default([]),
});

type EdgeAIGenerateSubjectInput = z.infer<typeof SolicitudSchema>;

function parseAndValidate(
  formData: FormData,
): { success: true; data: EdgeAIGenerateSubjectInput } | {
  success: false;
  errors: string[];
} {
  const rawInput = {
    plan_estudio_id: formData.get("plan_estudio_id"),
    datosBasicos: formData.get("datosBasicos"),
    iaConfig: formData.get("iaConfig"),
    archivosAdjuntos: formData.getAll("archivosAdjuntos"),
  };

  const result = SolicitudSchema.safeParse(rawInput);
  if (!result.success) {
    const errors = result.error.errors.map((issue) => {
      const path = issue.path.length ? `${issue.path.join(".")}: ` : "";
      return `${path}${issue.message}`;
    });
    return { success: false, errors };
  }

  return { success: true, data: result.data };
}