import { generateImage } from "./_core/imageGeneration.ts";
import { storagePut } from "../storage.ts";

/**
 * Game asset types to generate
 */
export interface GameAssetRequest {
  gameId: string;
  gameName: string;
  theme: string;
  symbols: string[];
  bonusFeatures: string[];
  style: "modern" | "classic" | "fantasy" | "neon" | "luxury";
}

/**
 * Generated game assets
 */
export interface GeneratedGameAssets {
  gameId: string;
  gameName: string;
  thumbnail: string; // CDN URL
  symbolAssets: Record<string, string>; // symbol name -> CDN URL
  bonusAssets: Record<string, string>; // bonus feature -> CDN URL
  backgroundAsset: string; // CDN URL
  uiElements: Record<string, string>; // button, spinner, etc -> CDN URL
  createdAt: string;
}

/**
 * Generate branded thumbnail for game
 */
async function generateGameThumbnail(
  gameName: string,
  theme: string,
  style: string
): Promise<string> {
  try {
    const prompt = `
Create a professional branded game thumbnail for CoinKrazy Casino.
Game Name: ${gameName}
Theme: ${theme}
Style: ${style}
Requirements:
- Include "CoinKrazy" branding in the corner
- Include "AI Games" badge
- Vibrant, eye-catching design
- 300x300px square format
- Show game theme and symbols
- Professional casino aesthetic
- Include game name prominently
    `;

    const { url } = await generateImage({ prompt });
    console.log(`[GameAssetPipeline] Generated thumbnail for ${gameName}: ${url}`);
    return url;
  } catch (error) {
    console.error(`[GameAssetPipeline] Failed to generate thumbnail for ${gameName}:`, error);
    throw error;
  }
}

/**
 * Generate symbol assets for game
 */
async function generateSymbolAssets(
  gameName: string,
  symbols: string[],
  theme: string
): Promise<Record<string, string>> {
  const symbolAssets: Record<string, string> = {};

  for (const symbol of symbols) {
    try {
      const prompt = `
Create a slot machine symbol for CoinKrazy Casino.
Game: ${gameName}
Symbol: ${symbol}
Theme: ${theme}
Requirements:
- Professional casino-quality design
- 100x100px square format
- Transparent background
- High contrast and visibility
- Consistent with ${theme} theme
- Include subtle CoinKrazy branding if possible
      `;

      const { url } = await generateImage({ prompt });
      symbolAssets[symbol] = url;
      console.log(`[GameAssetPipeline] Generated symbol asset for ${symbol}: ${url}`);
    } catch (error) {
      console.error(`[GameAssetPipeline] Failed to generate symbol ${symbol}:`, error);
      // Continue with other symbols even if one fails
    }
  }

  return symbolAssets;
}

/**
 * Generate bonus feature assets
 */
async function generateBonusAssets(
  gameName: string,
  bonusFeatures: string[],
  theme: string
): Promise<Record<string, string>> {
  const bonusAssets: Record<string, string> = {};

  for (const bonus of bonusFeatures) {
    try {
      const prompt = `
Create a bonus feature icon for CoinKrazy Casino slot game.
Game: ${gameName}
Bonus Feature: ${bonus}
Theme: ${theme}
Requirements:
- Professional casino-quality design
- 120x120px square format
- Transparent background
- Represents the bonus feature visually
- Consistent with ${theme} theme
- Include subtle CoinKrazy branding
      `;

      const { url } = await generateImage({ prompt });
      bonusAssets[bonus] = url;
      console.log(`[GameAssetPipeline] Generated bonus asset for ${bonus}: ${url}`);
    } catch (error) {
      console.error(`[GameAssetPipeline] Failed to generate bonus asset ${bonus}:`, error);
    }
  }

  return bonusAssets;
}

/**
 * Generate game background
 */
async function generateGameBackground(
  gameName: string,
  theme: string,
  style: string
): Promise<string> {
  try {
    const prompt = `
Create a professional slot game background for CoinKrazy Casino.
Game: ${gameName}
Theme: ${theme}
Style: ${style}
Requirements:
- 1920x1080px widescreen format
- High quality background
- Matches ${theme} theme
- Subtle CoinKrazy branding
- Professional casino aesthetic
- Suitable for game backdrop
- Include ${style} design elements
    `;

    const { url } = await generateImage({ prompt });
    console.log(`[GameAssetPipeline] Generated background for ${gameName}: ${url}`);
    return url;
  } catch (error) {
    console.error(`[GameAssetPipeline] Failed to generate background for ${gameName}:`, error);
    throw error;
  }
}

/**
 * Generate UI elements (buttons, spinners, etc)
 */
async function generateUIElements(
  gameName: string,
  theme: string
): Promise<Record<string, string>> {
  const uiElements: Record<string, string> = {};
  const elements = ["spin-button", "bet-up-button", "bet-down-button", "loading-spinner", "win-banner"];

  for (const element of elements) {
    try {
      const prompt = `
Create a UI element for CoinKrazy Casino slot game.
Game: ${gameName}
Element: ${element}
Theme: ${theme}
Requirements:
- Professional casino UI design
- 80x80px square format
- Transparent background
- Matches ${theme} theme
- Include CoinKrazy branding
- High contrast and visibility
      `;

      const { url } = await generateImage({ prompt });
      uiElements[element] = url;
      console.log(`[GameAssetPipeline] Generated UI element ${element}: ${url}`);
    } catch (error) {
      console.error(`[GameAssetPipeline] Failed to generate UI element ${element}:`, error);
    }
  }

  return uiElements;
}

/**
 * Generate all assets for a game
 */
export async function generateGameAssets(request: GameAssetRequest): Promise<GeneratedGameAssets> {
  console.log(`[GameAssetPipeline] Starting asset generation for ${request.gameName}`);

  try {
    // Generate all assets in parallel
    const [thumbnail, symbolAssets, bonusAssets, background, uiElements] = await Promise.all([
      generateGameThumbnail(request.gameName, request.theme, request.style),
      generateSymbolAssets(request.gameName, request.symbols, request.theme),
      generateBonusAssets(request.gameName, request.bonusFeatures, request.theme),
      generateGameBackground(request.gameName, request.theme, request.style),
      generateUIElements(request.gameName, request.theme),
    ]);

    const assets: GeneratedGameAssets = {
      gameId: request.gameId,
      gameName: request.gameName,
      thumbnail,
      symbolAssets,
      bonusAssets,
      backgroundAsset: background,
      uiElements,
      createdAt: new Date().toISOString(),
    };

    console.log(`[GameAssetPipeline] Successfully generated all assets for ${request.gameName}`);
    return assets;
  } catch (error) {
    console.error(`[GameAssetPipeline] Failed to generate assets for ${request.gameName}:`, error);
    throw error;
  }
}

/**
 * Batch generate assets for multiple games
 */
export async function batchGenerateGameAssets(
  requests: GameAssetRequest[]
): Promise<GeneratedGameAssets[]> {
  console.log(`[GameAssetPipeline] Starting batch asset generation for ${requests.length} games`);

  const results: GeneratedGameAssets[] = [];

  for (const request of requests) {
    try {
      const assets = await generateGameAssets(request);
      results.push(assets);
      // Add delay between requests to avoid rate limiting
      await new Promise((resolve) => setTimeout(resolve, 1000));
    } catch (error) {
      console.error(`[GameAssetPipeline] Failed to generate assets for ${request.gameName}:`, error);
      // Continue with other games even if one fails
    }
  }

  console.log(`[GameAssetPipeline] Batch generation complete. Generated ${results.length}/${requests.length} games`);
  return results;
}

/**
 * Get asset generation status
 */
export function getAssetGenerationStatus(): {
  status: "ready" | "generating" | "error";
  message: string;
  estimatedTime: number; // seconds
} {
  return {
    status: "ready",
    message: "Asset generation pipeline is ready",
    estimatedTime: 30, // ~30 seconds per game
  };
}