// app/api/admin/events/[id]/route.ts

import { prisma } from "@/lib/prisma";
import { getAdminUser } from "@/lib/auth";
import { NextResponse } from "next/server";

const UPLOAD_ENDPOINT = "http://167.71.224.75:8501/upload";

async function uploadToExternalServer(
  file: File,
  folder: string = "events"
): Promise<string> {
  try {
    const formData = new FormData();

    formData.append("folder", folder);
    formData.append("file", file);

    const response = await fetch(UPLOAD_ENDPOINT, {
      method: "POST",
      body: formData,
      cache: "no-store",
    });

    const responseText = await response.text();

    if (!response.ok) {
      throw new Error(`Upload failed (${response.status})`);
    }

    let result: {
      success: boolean;
      url?: string;
      error?: string;
      message?: string;
    };

    try {
      result = JSON.parse(responseText);
    } catch {
      throw new Error(
        "Invalid JSON response from upload server"
      );
    }

    if (!result.success) {
      throw new Error(
        result.error ||
          result.message ||
          "Upload failed"
      );
    }

    if (!result.url) {
      throw new Error(
        "Upload server did not return file URL"
      );
    }

    return result.url;
  } catch (error) {
    console.error(
      "External upload error:",
      error
    );
    throw error;
  }
}

/* ==========================================================
   GET SINGLE EVENT
========================================================== */

export async function GET(
  req: Request,
  {
    params,
  }: {
    params: Promise<{
      id: string;
    }>;
  }
) {
  try {
    const admin =
      await getAdminUser();

    if (!admin) {
      return NextResponse.json(
        {
          success: false,
          message: "Unauthorized",
        },
        {
          status: 401,
        }
      );
    }

    const { id } = await params;

    const eventId = Number(id);

    if (isNaN(eventId)) {
      return NextResponse.json(
        {
          success: false,
          message: "Invalid ID",
        },
        {
          status: 400,
        }
      );
    }

    const event =
      await prisma.master_events.findFirst({
        where: {
          id: eventId,
          delete_status: false,
        },
      });

    if (!event) {
      return NextResponse.json(
        {
          success: false,
          message: "Event not found",
        },
        {
          status: 404,
        }
      );
    }

    return NextResponse.json({
      success: true,
      data: event,
    });
  } catch (error) {
    console.error(
      "GET Event Error:",
      error
    );

    return NextResponse.json(
      {
        success: false,
        message:
          error instanceof Error
            ? error.message
            : "Something went wrong",
      },
      {
        status: 500,
      }
    );
  }
}

/* ==========================================================
   UPDATE EVENT
========================================================== */

export async function PUT(
  req: Request,
  {
    params,
  }: {
    params: Promise<{
      id: string;
    }>;
  }
) {
  try {
    const admin =
      await getAdminUser();

    if (!admin) {
      return NextResponse.json(
        {
          success: false,
          message: "Unauthorized",
        },
        {
          status: 401,
        }
      );
    }

    const { id } = await params;

    const eventId = Number(id);

    if (isNaN(eventId)) {
      return NextResponse.json(
        {
          success: false,
          message: "Invalid ID",
        },
        {
          status: 400,
        }
      );
    }

    const existing =
      await prisma.master_events.findFirst({
        where: {
          id: eventId,
          delete_status: false,
        },
      });

    if (!existing) {
      return NextResponse.json(
        {
          success: false,
          message: "Event not found",
        },
        {
          status: 404,
        }
      );
    }

    const formData =
      await req.formData();

    const event_text = (
      formData.get(
        "event_text"
      ) as string
    )?.trim();

    const event_sub_text =
      (
        formData.get(
          "event_sub_text"
        ) as string
      )?.trim() || null;

    const event_start_date =
      (
        formData.get(
          "event_start_date"
        ) as string
      )?.trim();

    const event_end_date =
      (
        formData.get(
          "event_end_date"
        ) as string
      )?.trim();

    const event_location =
      (
        formData.get(
          "event_location"
        ) as string
      )?.trim() || null;

    const event_start_time =
      (
        formData.get(
          "event_start_time"
        ) as string
      )?.trim() || null;

    const event_end_time =
      (
        formData.get(
          "event_end_time"
        ) as string
      )?.trim() || null;

    const is_current_event =
      formData.get(
        "is_current_event"
      ) === "1"
        ? 1
        : 0;

    const active_status =
      formData.get(
        "active_status"
      ) !== "false";

    const imageFile =
      formData.get(
        "event_pic"
      ) as File | null;

    if (!event_text) {
      return NextResponse.json(
        {
          success: false,
          message:
            "Event title is required",
        },
        {
          status: 400,
        }
      );
    }

    if (!event_start_date) {
      return NextResponse.json(
        {
          success: false,
          message:
            "Start date is required",
        },
        {
          status: 400,
        }
      );
    }

    if (!event_end_date) {
      return NextResponse.json(
        {
          success: false,
          message:
            "End date is required",
        },
        {
          status: 400,
        }
      );
    }

    let event_pic =
      existing.event_pic;

    if (
      imageFile &&
      imageFile.size > 0
    ) {
      event_pic =
        await uploadToExternalServer(
          imageFile,
          "events"
        );
    }

    if (is_current_event === 1) {
      await prisma.master_events.updateMany({
        where: {
          is_current_event: 1,
          id: {
            not: eventId,
          },
        },
        data: {
          is_current_event: 0,
        },
      });
    }

    const updated =
      await prisma.master_events.update({
        where: {
          id: eventId,
        },
        data: {
          event_pic,
          event_text,
          event_sub_text,
          event_start_date,
          event_end_date,
          event_location,
          event_start_time,
          event_end_time,
          is_current_event,
          active_status,
          updated_at: new Date(),
        },
      });

    return NextResponse.json({
      success: true,
      message:
        "Event updated successfully",
      data: updated,
    });
  } catch (error) {
    console.error(
      "UPDATE Event Error:",
      error
    );

    return NextResponse.json(
      {
        success: false,
        message:
          error instanceof Error
            ? error.message
            : "Failed to update event",
      },
      {
        status: 500,
      }
    );
  }
}

/* ==========================================================
   DELETE EVENT
========================================================== */

export async function DELETE(
  req: Request,
  {
    params,
  }: {
    params: Promise<{
      id: string;
    }>;
  }
) {
  try {
    const admin =
      await getAdminUser();

    if (!admin) {
      return NextResponse.json(
        {
          success: false,
          message: "Unauthorized",
        },
        {
          status: 401,
        }
      );
    }

    const { id } = await params;

    const eventId = Number(id);

    if (isNaN(eventId)) {
      return NextResponse.json(
        {
          success: false,
          message: "Invalid ID",
        },
        {
          status: 400,
        }
      );
    }

    const existing =
      await prisma.master_events.findFirst({
        where: {
          id: eventId,
          delete_status: false,
        },
      });

    if (!existing) {
      return NextResponse.json(
        {
          success: false,
          message: "Event not found",
        },
        {
          status: 404,
        }
      );
    }

    await prisma.master_events.update({
      where: {
        id: eventId,
      },
      data: {
        delete_status: true,
        deleted_at: new Date(),
      },
    });

    return NextResponse.json({
      success: true,
      message:
        "Event deleted successfully",
    });
  } catch (error) {
    console.error(
      "DELETE Event Error:",
      error
    );

    return NextResponse.json(
      {
        success: false,
        message:
          error instanceof Error
            ? error.message
            : "Failed to delete event",
      },
      {
        status: 500,
      }
    );
  }
}