import { GamePerformanceAnalytics } from "./gamePerformanceAnalytics.ts";
import GameRemizerBot from "./gameRemizerBotService.ts";
import { PredictiveAnalyticsEngine } from "./predictiveAnalyticsEngine.ts";

export interface RemixTriggerConfig {
  enabled: boolean;
  performanceThreshold: number; // Below this RTP, trigger remix
  minPlays: number; // Minimum plays before triggering
  remixInterval: number; // Hours between remixes
  maxRemixesPerDay: number;
  autoDeployRemixed: boolean;
}

export interface RemixTriggerEvent {
  gameId: string;
  gameName: string;
  currentRTP: number;
  threshold: number;
  triggeredAt: Date;
  remixedGameId?: string;
  status: "pending" | "remixing" | "completed" | "failed";
}

/**
 * Automated Remix Trigger System
 */
export class AutomatedRemixTrigger {
  private static config: RemixTriggerConfig = {
    enabled: true,
    performanceThreshold: 94, // Remix if RTP drops below 94%
    minPlays: 100,
    remixInterval: 24, // Check every 24 hours
    maxRemixesPerDay: 5,
    autoDeployRemixed: true,
  };

  private static triggerEvents: RemixTriggerEvent[] = [];
  private static remixesPerDay: Map<string, number> = new Map();

  /**
   * Initialize automated remix monitoring
   */
  static async initializeMonitoring(): Promise<void> {
    console.log("🚀 Initializing Automated Remix Trigger System");

    // Start monitoring loop
    setInterval(() => {
      this.checkAndTriggerRemixes();
    }, this.config.remixInterval * 60 * 60 * 1000);

    // Reset daily remix counter
    setInterval(() => {
      this.remixesPerDay.clear();
      console.log("📊 Daily remix counter reset");
    }, 24 * 60 * 60 * 1000);

    console.log("✅ Automated Remix Trigger System initialized");
  }

  /**
   * Check game performance and trigger remixes
   */
  static async checkAndTriggerRemixes(): Promise<RemixTriggerEvent[]> {
    if (!this.config.enabled) {
      console.log("⏸️ Remix trigger is disabled");
      return [];
    }

    try {
      const triggeredEvents: RemixTriggerEvent[] = [];
      const comparisons =
        await GamePerformanceAnalytics.compareGamePerformance();

      for (const comparison of comparisons) {
        const metrics = await GamePerformanceAnalytics.getGameMetrics(
          comparison.gameId
        );

        if (!metrics || metrics.totalPlays < this.config.minPlays) {
          continue;
        }

        // Check if performance is below threshold
        if (metrics.avgRTP < this.config.performanceThreshold) {
          const dailyRemixes = this.remixesPerDay.get(comparison.gameId) || 0;

          if (dailyRemixes < this.config.maxRemixesPerDay) {
            const event = await this.triggerRemix(comparison.gameId, metrics);
            if (event) {
              triggeredEvents.push(event);
              this.remixesPerDay.set(
                comparison.gameId,
                dailyRemixes + 1
              );
            }
          }
        }
      }

      if (triggeredEvents.length > 0) {
        console.log(
          `🎮 Triggered ${triggeredEvents.length} game remixes`
        );
      }

      return triggeredEvents;
    } catch (error) {
      console.error("Error checking and triggering remixes:", error);
      return [];
    }
  }

  /**
   * Trigger remix for a specific game
   */
  static async triggerRemix(
    gameId: string,
    metrics: any
  ): Promise<RemixTriggerEvent | null> {
    try {
      const event: RemixTriggerEvent = {
        gameId,
        gameName: metrics.gameName,
        currentRTP: metrics.avgRTP,
        threshold: this.config.performanceThreshold,
        triggeredAt: new Date(),
        status: "pending",
      };

      this.triggerEvents.push(event);

      console.log(
        `🎯 Remix triggered for ${metrics.gameName} (RTP: ${metrics.avgRTP.toFixed(2)}%)`
      );

      // Start remix process
      event.status = "remixing";

      // Get predictions for remix
      const predictions =
        await PredictiveAnalyticsEngine.forecastViralPotential([metrics]);

      if (predictions.length > 0) {
        const prediction = predictions[0];
        console.log(
          `📊 Viral prediction for remix: ${prediction.viralScore}/100`
        );

        // Generate remix with recommended theme
        const remixedGame = await GameRemizerBot.generateRemix(
          gameId,
          `${metrics.theme} - Remix ${new Date().toLocaleDateString()}`
        );

        if (remixedGame) {
          event.remixedGameId = remixedGame.gameId;
          event.status = "completed";

          if (this.config.autoDeployRemixed) {
            console.log(
              `✅ Remixed game auto-deployed: ${remixedGame.gameId}`
            );
          }

          return event;
        }
      }

      event.status = "failed";
      return event;
    } catch (error) {
      console.error("Error triggering remix:", error);
      return null;
    }
  }

  /**
   * Update trigger configuration
   */
  static updateConfig(newConfig: Partial<RemixTriggerConfig>): void {
    this.config = { ...this.config, ...newConfig };
    console.log("⚙️ Remix trigger config updated:", this.config);
  }

  /**
   * Get trigger configuration
   */
  static getConfig(): RemixTriggerConfig {
    return { ...this.config };
  }

  /**
   * Get trigger events
   */
  static getTriggerEvents(limit: number = 50): RemixTriggerEvent[] {
    return this.triggerEvents.slice(-limit);
  }

  /**
   * Get trigger statistics
   */
  static getStats() {
    const completed = this.triggerEvents.filter(
      (e) => e.status === "completed"
    ).length;
    const failed = this.triggerEvents.filter((e) => e.status === "failed")
      .length;
    const pending = this.triggerEvents.filter((e) => e.status === "pending")
      .length;

    return {
      totalTriggered: this.triggerEvents.length,
      completed,
      failed,
      pending,
      successRate: this.triggerEvents.length > 0 ? (completed / this.triggerEvents.length) * 100 : 0,
      remixesPerDay: Object.fromEntries(this.remixesPerDay),
    };
  }

  /**
   * Manually trigger remix for a game
   */
  static async manuallyTriggerRemix(gameId: string): Promise<RemixTriggerEvent | null> {
    try {
      const metrics = await GamePerformanceAnalytics.getGameMetrics(gameId);
      if (!metrics) return null;

      return await this.triggerRemix(gameId, metrics);
    } catch (error) {
      console.error("Error manually triggering remix:", error);
      return null;
    }
  }

  /**
   * Pause/resume trigger system
   */
  static toggleTrigger(enabled: boolean): void {
    this.config.enabled = enabled;
    console.log(`${enabled ? "▶️ Resumed" : "⏸️ Paused"} remix trigger system`);
  }
}

export default AutomatedRemixTrigger;