/**
 * Adaptive Difficulty Manager
 * Adjusts challenge difficulty based on player performance
 */

export class DifficultyManager {
  store: any;
  
  constructor(gameStore: any) {
    this.store = gameStore;
  }

  /**
   * Track challenge completion
   * @param {string} genreId - Genre of challenge
   * @param {boolean} success - Whether player succeeded
   * @param {number} timeSpent - Time spent in seconds
   */
  trackChallengePerformance(genreId, success, timeSpent) {
    // Store performance data in statistics
    // This would be expanded with more sophisticated tracking
    const { player } = this.store.getState();
    
    // Calculate success rate
    const genreStats = player.statistics.genresExplored[genreId] || 0;
    
    // Update statistics
    this.store.getState().recordChallengeCompleted();
  }

  /**
   * Get recommended difficulty for a genre
   * @param {string} genreId - Genre identifier
   * @returns {number} - Difficulty level (1-5)
   */
  getRecommendedDifficulty(genreId) {
    const { player } = this.store.getState();
    const mastery = player.genreMastery[genreId];

    // Base difficulty on genre mastery level
    if (!mastery) return 1; // Beginner
    
    if (mastery.level >= 8) return 4; // Expert
    if (mastery.level >= 5) return 3; // Advanced
    if (mastery.level >= 3) return 2; // Intermediate
    
    return 1; // Beginner
  }

  /**
   * Calculate adaptive XP reward
   * @param {number} baseDifficulty - Base challenge difficulty
   * @param {string} genreId - Genre
   * @returns {number} - Adjusted XP amount
   */
  calculateAdaptiveXP(baseDifficulty, genreId) {
    const { player } = this.store.getState();
    const mastery = player.genreMastery[genreId] || { level: 1 };
    
    // Less XP if over-leveled, more if challenging yourself
    const levelDiff = baseDifficulty - mastery.level;
    let multiplier = 1.0;

    if (levelDiff >= 3) multiplier = 1.5; // Very challenging
    else if (levelDiff >= 1) multiplier = 1.2; // Challenging
    else if (levelDiff === 0) multiplier = 1.0; // Appropriate
    else if (levelDiff === -1) multiplier = 0.8; // Slightly easy
    else multiplier = 0.5; // Too easy

    const baseXP = baseDifficulty * 25;
    return Math.floor(baseXP * multiplier);
  }

  /**
   * Get difficulty label
   * @param {number} difficulty - Difficulty level (1-5)
   * @returns {string} - Label
   */
  getDifficultyLabel(difficulty) {
    switch (difficulty) {
      case 1: return 'Beginner';
      case 2: return 'Intermediate';
      case 3: return 'Advanced';
      case 4: return 'Expert';
      case 5: return 'Master';
      default: return 'Unknown';
    }
  }

  /**
   * Get difficulty color
   * @param {number} difficulty - Difficulty level
   * @returns {string} - Color code
   */
  getDifficultyColor(difficulty) {
    switch (difficulty) {
      case 1: return '#27ae60'; // Green
      case 2: return '#3498db'; // Blue
      case 3: return '#f39c12'; // Orange
      case 4: return '#e67e22'; // Dark orange
      case 5: return '#e74c3c'; // Red
      default: return '#95a5a6'; // Grey
    }
  }

  /**
   * Suggest next challenge based on player data
   * @returns {Object} - Recommendation
   */
  suggestNextChallenge() {
    const { player } = this.store.getState();
    
    // Find genre with lowest mastery
    const masteredGenres = Object.entries(player.genreMastery)
      .sort((a, b) => (a[1] as any).level - (b[1] as any).level);

    if (masteredGenres.length === 0) {
      return {
        genre: 'rock',
        difficulty: 1,
        reason: 'Start with the basics!'
      };
    }

    const [lowestGenre, lowestData] = masteredGenres[0];
    
    return {
      genre: lowestGenre,
      difficulty: Math.min((lowestData as any).level + 1, 5),
      reason: `Continue improving your ${lowestGenre} skills`
    };
  }
}