import type { VercelRequest, VercelResponse } from "@vercel/node";
import { createClient } from "@supabase/supabase-js";

// Initialize Supabase with service role
let supabase: any = null;

try {
  supabase = createClient(
    process.env.SUPABASE_URL || "",
    process.env.SUPABASE_SERVICE_ROLE || ""
  );
} catch (e) {
  console.error("Failed to initialize Supabase client:", e);
}

interface RoleMapping {
  id: string;
  arm: string;
  user_type?: string;
  discord_role: string;
  server_id?: string;
  created_at: string;
}

export default async function handler(
  req: VercelRequest,
  res: VercelResponse
) {
  // Set CORS headers
  res.setHeader("Access-Control-Allow-Credentials", "true");
  res.setHeader("Access-Control-Allow-Origin", "*");
  res.setHeader(
    "Access-Control-Allow-Methods",
    "GET,OPTIONS,PATCH,DELETE,POST,PUT"
  );
  res.setHeader(
    "Access-Control-Allow-Headers",
    "X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version"
  );

  if (req.method === "OPTIONS") {
    res.status(200).end();
    return;
  }

  try {
    // Validate Supabase is initialized
    if (!supabase) {
      console.error("Supabase client not initialized");
      return res.status(500).json({
        error: "Server configuration error: Missing Supabase credentials",
      });
    }

    // GET - Fetch all role mappings
    if (req.method === "GET") {
      try {
        const { data, error } = await supabase
          .from("discord_role_mappings")
          .select("*")
          .order("created_at", { ascending: false });

        if (error) {
          console.error("Supabase error:", error);
          return res.status(500).json({
            error: `Failed to fetch role mappings: ${error.message}`,
          });
        }

        return res.status(200).json(data || []);
      } catch (queryErr: any) {
        console.error("Query error:", queryErr);
        return res.status(500).json({
          error: `Database query error: ${queryErr?.message || "Unknown error"}`,
        });
      }
    }

    // POST - Create new role mapping
    if (req.method === "POST") {
      try {
        const { arm, discord_role, server_id, user_type } = req.body;

        if (!arm || !discord_role) {
          return res.status(400).json({
            error: "arm and discord_role are required",
          });
        }

        const { data, error } = await supabase
          .from("discord_role_mappings")
          .insert({
            arm,
            user_type: user_type || "community_member",
            discord_role,
            server_id: server_id || null,
          })
          .select()
          .single();

        if (error) {
          console.error("Supabase error:", error);
          return res.status(500).json({
            error: `Failed to create mapping: ${error.message}`,
          });
        }

        return res.status(201).json(data);
      } catch (insertErr: any) {
        console.error("Insert error:", insertErr);
        return res.status(500).json({
          error: `Insert error: ${insertErr?.message || "Unknown error"}`,
        });
      }
    }

    // PUT - Update role mapping
    if (req.method === "PUT") {
      const { id, arm, discord_role, server_id, user_type } = req.body;

      if (!id) {
        return res.status(400).json({ error: "id is required" });
      }

      const updateData: any = {};
      if (arm) updateData.arm = arm;
      if (discord_role) updateData.discord_role = discord_role;
      if (server_id !== undefined) updateData.server_id = server_id;
      if (user_type) updateData.user_type = user_type;

      const { data, error } = await supabase
        .from("discord_role_mappings")
        .update(updateData)
        .eq("id", id)
        .select()
        .single();

      if (error) {
        console.error("Supabase error:", error);
        return res.status(500).json({ error: "Failed to update mapping" });
      }

      return res.status(200).json(data);
    }

    // DELETE - Delete role mapping
    if (req.method === "DELETE") {
      const { id } = req.query;

      if (!id) {
        return res.status(400).json({ error: "id query parameter is required" });
      }

      const { error } = await supabase
        .from("discord_role_mappings")
        .delete()
        .eq("id", id);

      if (error) {
        console.error("Supabase error:", error);
        return res.status(500).json({ error: "Failed to delete mapping" });
      }

      return res.status(200).json({ success: true });
    }

    return res.status(405).json({ error: "Method not allowed" });
  } catch (error: any) {
    console.error("API error:", error);
    return res.status(500).json({
      error: error?.message || "Internal server error",
    });
  }
}