import type { Express, Request, Response } from "express";
import fs from "fs";
import { db } from "../db.ts";
import { casinoGames } from "../../drizzle/schema.ts";

export function registerGamesImportEndpoint(app: Express) {
  // Admin endpoint to trigger games import
  app.post("/api/admin/import-games", async (req: Request, res: Response) => {
    try {
      // Check if user is admin (basic check - in production, verify JWT)
      const authHeader = req.headers.authorization;
      if (!authHeader || !authHeader.includes("Bearer")) {
        res.status(401).json({ error: "Unauthorized" });
        return;
      }

      const filePath = "/home/ubuntu/coinkrazy/games-import.json";

      if (!fs.existsSync(filePath)) {
        res.status(404).json({ error: "Games import file not found" });
        return;
      }

      const gamesData = JSON.parse(fs.readFileSync(filePath, "utf-8"));
      console.log(`[Games Import] Starting import of ${gamesData.length} games...`);

      // Transform games to match casinoGames schema
      const transformedGames = gamesData.map((game: any) => ({
        slug: game.gameId.toLowerCase().replace(/\//g, "-"),
        title: game.gameName,
        provider: game.provider,
        category: "slots",
        tags: JSON.stringify([game.gameType, game.volatility]),
        thumbnailUrl: game.iconUrl,
        bannerUrl: game.iconUrl,
        rtp: game.rtp * 100, // Convert to percentage
        volatility: game.volatility || "medium",
        minBetGc: 1.0,
        maxBetGc: 1000.0,
        minBetSc: 0.01,
        maxBetSc: 100.0,
        isActive: game.isActive ? 1 : 0,
        isFeatured: game.isFeatured ? 1 : 0,
        isNew: 0,
        playCount: 0,
        description: game.description,
        features: JSON.stringify({
          paylines: game.paylines,
          reels: game.reels,
          gameType: game.gameType,
        }),
        paylines: game.paylines,
        reels: game.reels,
      }));

      // Batch insert games (insert in chunks of 100)
      let importedCount = 0;
      const chunkSize = 100;
      const errors: string[] = [];

      for (let i = 0; i < transformedGames.length; i += chunkSize) {
        const chunk = transformedGames.slice(i, i + chunkSize);

        try {
          await db.insert(casinoGames).values(chunk as any);
          importedCount += chunk.length;
          console.log(`[Games Import] Imported ${importedCount}/${transformedGames.length} games...`);
        } catch (error) {
          const errorMsg = error instanceof Error ? error.message : String(error);
          console.error(`[Games Import] Error importing chunk ${i}-${i + chunkSize}:`, errorMsg);
          errors.push(`Chunk ${i}-${i + chunkSize}: ${errorMsg}`);
        }
      }

      console.log(`[Games Import] ✅ Successfully imported ${importedCount} games`);

      res.json({
        success: true,
        importedCount,
        totalGames: transformedGames.length,
        errors: errors.length > 0 ? errors : undefined,
      });
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      console.error("[Games Import] Error:", errorMessage);
      res.status(500).json({ error: "Games import failed", details: errorMessage });
    }
  });

  // Get import stats
  app.get("/api/admin/games-stats", async (req: Request, res: Response) => {
    try {
      const games = await db.query.casinoGames.findMany();

      const providerCounts: Record<string, number> = {};
      const volatilityCounts: Record<string, number> = {};

      games.forEach((game: any) => {
        providerCounts[game.provider] = (providerCounts[game.provider] || 0) + 1;
        volatilityCounts[game.volatility] = (volatilityCounts[game.volatility] || 0) + 1;
      });

      res.json({
        totalGames: games.length,
        uniqueProviders: Object.keys(providerCounts).length,
        providerCounts,
        volatilityCounts,
      });
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      res.status(500).json({ error: "Failed to get stats", details: errorMessage });
    }
  });
}