Player Management API

// Guild balance checking for raid eligibility
class GuildManager {
  constructor(sdkKey) {
    this.apiClient = new PlayerAPIClient(sdkKey);
  }
  
  async checkRaidEligibility(guildMembers, minimumBalance = 1000) {
    // Use batch API for guild member lookup
    const memberEmails = guildMembers.map(member => member.email);
    
    try {
      const batchResult = await this.apiClient.request('/batch', {
        method: 'POST',
        body: JSON.stringify({ player_emails: memberEmails })
      });
      
      const eligibleMembers = [];
      const ineligibleMembers = [];
      
      batchResult.results.forEach(result => {
        if (result.error) {
          ineligibleMembers.push({
            email: result.player.player_email,
            reason: 'Player not found'
          });
          return;
        }
        
        const totalValue = parseFloat(result.total_value);
        if (totalValue >= minimumBalance) {
          eligibleMembers.push({
            ...result.player,
            totalValue
          });
        } else {
          ineligibleMembers.push({
            ...result.player,
            totalValue,
            reason: `Insufficient funds (needs ${minimumBalance}, has ${totalValue})`
          });
        }
      });
      
      return {
        eligible: eligibleMembers,
        ineligible: ineligibleMembers,
        eligibilityRate: (eligibleMembers.length / memberEmails.length) * 100
      };
      
    } catch (error) {
      console.error('Guild eligibility check failed:', error);
      throw error;
    }
  }
}

// Generate wealth leaderboards from streaming data
class LeaderboardGenerator {
  constructor(sdkKey) {
    this.apiClient = new PlayerAPIClient(sdkKey);
  }
  
  async generateWealthLeaderboard(topN = 100) {
    const leaderboard = [];
    let processedCount = 0;
    
    console.log('Starting wealth leaderboard generation...');
    
    try {
      // Stream all players and track top performers
      const response = await fetch('https://invo.network/api/player-balances/stream-all?include_zero_balances=false', {
        headers: {
          'X-Game-Secret-Key': this.apiClient.sdkKey
        }
      });
      
      const reader = response.body.getReader();
      const decoder = new TextDecoder();
      
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        
        const chunk = decoder.decode(value);
        const players = this.parseStreamChunk(chunk);
        
        players.forEach(player => {
          const totalValue = parseFloat(player.total_value);
          
          if (totalValue > 0) {
            leaderboard.push({
              playerId: player.player_id,
              playerName: player.player_name,
              totalValue: totalValue
            });
            
            // Keep only top N + buffer for efficiency
            if (leaderboard.length > topN * 2) {
              leaderboard.sort((a, b) => b.totalValue - a.totalValue);
              leaderboard.splice(topN);
            }
          }
          
          processedCount++;
          if (processedCount % 50000 === 0) {
            console.log(`Processed ${processedCount.toLocaleString()} players...`);
          }
        });
      }
      
      // Final sort and trim
      leaderboard.sort((a, b) => b.totalValue - a.totalValue);
      const finalLeaderboard = leaderboard.slice(0, topN).map((player, index) => ({
        rank: index + 1,
        ...player
      }));
      
      console.log(`Leaderboard generated from ${processedCount.toLocaleString()} players`);
      return finalLeaderboard;
      
    } catch (error) {
      console.error('Leaderboard generation failed:', error);
      throw error;
    }
  }
  
  parseStreamChunk(chunk) {
    // Parse streaming JSON data (simplified)
    try {
      return JSON.parse(chunk).data || [];
    } catch {
      return [];
    }
  }
}

// Customer support player lookup with comprehensive info
class CustomerSupportAPI {
  constructor(sdkKey) {
    this.apiClient = new PlayerAPIClient(sdkKey);
  }
  
  async getPlayerSupportInfo(playerEmail) {
    try {
      // Get current balance
      const balanceData = await this.apiClient.request(
        `/player/by-email/${encodeURIComponent(playerEmail)}`
      );
      
      if (!balanceData.player) {
        return {
          found: false,
          message: 'Player not found in system'
        };
      }
      
      // Get game-wide context for comparison
      const gameSummary = await this.apiClient.request('/game-summary');
      
      // Calculate player percentiles
      const playerTotalValue = parseFloat(balanceData.summary.total_value);
      const avgBalance = parseFloat(gameSummary.economy[0]?.average_balance || 0);
      
      return {
        found: true,
        player: {
          ...balanceData.player,
          accountAge: this.calculateAccountAge(balanceData.player.date_joined),
          balances: balanceData.balances,
          totalValue: playerTotalValue,
          comparedToAverage: playerTotalValue / avgBalance,
          hasActiveBalances: balanceData.summary.has_funds,
          currencyCount: balanceData.summary.currency_count
        },
        gameContext: {
          totalPlayers: gameSummary.players.total_players,
          averageBalance: avgBalance,
          newPlayersToday: gameSummary.players.new_players_24h
        },
        supportNotes: this.generateSupportNotes(balanceData, gameSummary)
      };
      
    } catch (error) {
      if (error instanceof PlayerNotFoundError) {
        return {
          found: false,
          message: 'Player not found'
        };
      }
      throw error;
    }
  }
  
  calculateAccountAge(dateJoined) {
    if (!dateJoined) return 'Unknown';
    
    const joinDate = new Date(dateJoined);
    const now = new Date();
    const diffMs = now - joinDate;
    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
    
    if (diffDays < 1) return 'Less than 1 day';
    if (diffDays < 30) return `${diffDays} days`;
    if (diffDays < 365) return `${Math.floor(diffDays / 30)} months`;
    return `${Math.floor(diffDays / 365)} years`;
  }
  
  generateSupportNotes(balanceData, gameSummary) {
    const notes = [];
    const totalValue = parseFloat(balanceData.summary.total_value);
    const avgBalance = parseFloat(gameSummary.economy[0]?.average_balance || 0);
    
    if (totalValue === 0) {
      notes.push('⚠️ Player has zero balance across all currencies');
    } else if (totalValue > avgBalance * 10) {
      notes.push('💎 High-value player (10x+ average balance)');
    } else if (totalValue < avgBalance * 0.1) {
      notes.push('📊 Below-average balance (less than 10% of average)');
    }
    
    if (balanceData.summary.currency_count > 1) {
      notes.push(`🪙 Uses ${balanceData.summary.currency_count} different currencies`);
    }
    
    return notes;
  }
}