"use server";

import db from "@/db/db";
import { userCustomData } from "@/db/schema/user-custom-data/userCustomData";
import { eq, and } from "drizzle-orm";
import { Preset, PresetRepository } from "./preset-types";

// Drizzle Implementation of PresetRepository
// This file acts as the concrete repository implementation.
// To swap DBs, you would replace the logic here or create a new implementation file.

export async function getPresets(tableKey: string, userId: number): Promise<{ success: boolean; data?: Preset[]; error?: string }> {
  try {
    const settings = await db
      .select()
      .from(userCustomData)
      .where(
        and(
          eq(userCustomData.tableKey, tableKey),
          eq(userCustomData.userId, userId)
        )
      )
      .orderBy(userCustomData.createdDate);

    // Map DB entity to domain model
    const data: Preset[] = settings.map(s => ({
      id: s.id,
      name: s.customSettingName,
      setting: s.customSetting,
      createdAt: s.createdDate,
      updatedAt: s.updatedDate,
    }));

    return { success: true, data };
  } catch (error) {
    console.error("Failed to fetch presets:", error);
    return { success: false, error: "Failed to fetch presets" };
  }
}

export async function savePreset(
  userId: number,
  tableKey: string,
  name: string,
  setting: any
): Promise<{ success: boolean; error?: string }> {
  try {
    const existing = await db.query.userCustomData.findFirst({
        where: and(
            eq(userCustomData.userId, userId),
            eq(userCustomData.tableKey, tableKey),
            eq(userCustomData.customSettingName, name)
        )
    });

    if (existing) {
        await db.update(userCustomData)
            .set({ 
                customSetting: setting, 
                updatedDate: new Date() 
            })
            .where(eq(userCustomData.id, existing.id));
    } else {
        await db.insert(userCustomData).values({
            userId,
            tableKey,
            customSettingName: name,
            customSetting: setting,
        });
    }

    return { success: true };
  } catch (error) {
    console.error("Failed to save preset:", error);
    return { success: false, error: "Failed to save preset" };
  }
}

export async function deletePreset(id: string): Promise<{ success: boolean; error?: string }> {
  try {
    await db.delete(userCustomData).where(eq(userCustomData.id, id));
    return { success: true };
  } catch (error) {
    console.error("Failed to delete preset:", error);
    return { success: false, error: "Failed to delete preset" };
  }
}