import { router, publicProcedure, protectedProcedure, adminProcedure } from "../_core/trpc.ts";
import { z } from 'zod';
import { getDb } from "../db.ts";
import { sql } from 'drizzle-orm';

export const slotSettingsRouter = router({
  // Get max win cap (public - needed by slot engine)
  getMaxWinCap: publicProcedure.query(async () => {
    try {
      const db = await getDb();
      const result = await db.execute(
        sql`SELECT setting_value FROM slot_game_settings WHERE setting_key = 'max_win_per_spin_sc' LIMIT 1`
      );
      
      let maxWinCapSC = 10;
      if (result && result.length > 0) {
        const value = parseFloat(String(result[0].setting_value));
        if (!isNaN(value)) {
          maxWinCapSC = value;
        }
      }
      
      return {
        maxWinCapSC,
        success: true,
      };
    } catch (error) {
      console.error('[Slot Settings] Error fetching max win cap:', error);
      return {
        maxWinCapSC: 10,
        success: false,
      };
    }
  }),

  // Get all slot settings (admin only)
  getAll: adminProcedure.query(async () => {
    try {
      const db = await getDb();
      const settings = await db.execute(
        sql`SELECT id, setting_key, setting_value, description, updated_at FROM slot_game_settings ORDER BY setting_key`
      );
      
      return {
        settings,
        success: true,
      };
    } catch (error) {
      console.error('[Slot Settings] Error fetching all settings:', error);
      return {
        settings: [],
        success: false,
        error: error instanceof Error ? error.message : 'Unknown error',
      };
    }
  }),

  // Update a slot setting (admin only)
  update: adminProcedure
    .input(
      z.object({
        settingKey: z.string().min(1),
        settingValue: z.string(),
        description: z.string().optional(),
      })
    )
    .mutation(async ({ input }) => {
      try {
        const db = await getDb();
        
        // Validate max win cap is a valid number
        if (input.settingKey === 'max_win_per_spin_sc') {
          const value = parseFloat(input.settingValue);
          if (isNaN(value) || value < 0) {
            return {
              success: false,
              error: 'Max win cap must be a valid positive number or 0 for unlimited',
            };
          }
        }
        
        await db.execute(
          sql`
            INSERT INTO slot_game_settings (setting_key, setting_value, description)
            VALUES (${input.settingKey}, ${input.settingValue}, ${input.description || null})
            ON DUPLICATE KEY UPDATE
              setting_value = VALUES(setting_value),
              description = VALUES(description),
              updated_at = CURRENT_TIMESTAMP
          `
        );
        
        return {
          success: true,
          message: `Setting "${input.settingKey}" updated successfully`,
        };
      } catch (error) {
        console.error('[Slot Settings] Error updating setting:', error);
        return {
          success: false,
          error: error instanceof Error ? error.message : 'Unknown error',
        };
      }
    }),

  // Reset to defaults (admin only)
  resetToDefaults: adminProcedure.mutation(async () => {
    try {
      const db = await getDb();
      
      await db.execute(
        sql`UPDATE slot_game_settings SET setting_value = '10' WHERE setting_key = 'max_win_per_spin_sc'`
      );
      
      return {
        success: true,
        message: 'All slot settings reset to defaults',
      };
    } catch (error) {
      console.error('[Slot Settings] Error resetting settings:', error);
      return {
        success: false,
        error: error instanceof Error ? error.message : 'Unknown error',
      };
    }
  }),
});