/**
 * Unit Tests: Team Configuration Algorithms
 *
 * Tests the team configuration algorithms to ensure:
 * 1. Different team durability options work correctly
 * 2. Partner rotation strategies are applied
 * 3. Number of teams is calculated correctly based on participants
 * 4. Algorithms are actually being used and not ignored
 */

import { describe, test, expect, beforeEach, mock } from 'bun:test';
import { generateTeams, generateTeamsWithRotation, generateRandomTeams, generateELOBasedTeams, calculatePartnershipFrequency } from '@/lib/team-generator';
import type { Player, Team } from '@/lib/team-generator';

describe('Team Configuration Algorithms', () => {
  // Test players with varying ELO ratings
  const players4: Player[] = [
    { id: 1, name: 'Alice', currentElo: 1500 },
    { id: 2, name: 'Bob', currentElo: 1400 },
    { id: 3, name: 'Charlie', currentElo: 1300 },
    { id: 4, name: 'Diana', currentElo: 1200 },
  ];

  const players6: Player[] = [
    { id: 1, name: 'Alice', currentElo: 1500 },
    { id: 2, name: 'Bob', currentElo: 1400 },
    { id: 3, name: 'Charlie', currentElo: 1300 },
    { id: 4, name: 'Diana', currentElo: 1200 },
    { id: 5, name: 'Eve', currentElo: 1100 },
    { id: 6, name: 'Frank', currentElo: 1000 },
  ];

  const players5: Player[] = [
    { id: 1, name: 'Alice', currentElo: 1500 },
    { id: 2, name: 'Bob', currentElo: 1400 },
    { id: 3, name: 'Charlie', currentElo: 1300 },
    { id: 4, name: 'Diana', currentElo: 1200 },
    { id: 5, name: 'Eve', currentElo: 1100 },
  ];

  describe('generateTeams', () => {
    test('should generate 2 teams from 4 players', () => {
      const result = generateTeams(players4, 'none', true);

      expect(result.teams).toHaveLength(2);
      expect(result.byePlayer).toBeNull();

      // Check all players are assigned
      const assignedPlayerIds = new Set<number>();
      result.teams.forEach(team => {
        assignedPlayerIds.add(team.player1Id);
        assignedPlayerIds.add(team.player2Id);
      });
      expect(assignedPlayerIds.size).toBe(4);
    });

    test('should handle odd number of players with bye', () => {
      const result = generateTeams(players5, 'none', true);

      expect(result.teams).toHaveLength(2);
      expect(result.byePlayer).not.toBeNull();
      expect(result.byePlayer?.id).toBeDefined();

      // Check that the bye player is not in any team
      const byePlayerId = result.byePlayer?.id;
      result.teams.forEach(team => {
        expect(team.player1Id).not.toBe(byePlayerId);
        expect(team.player2Id).not.toBe(byePlayerId);
      });
    });

    test('should use random strategy', () => {
      // Run multiple times to verify randomness
      const results: Set<string>[] = [];
      for (let i = 0; i < 10; i++) {
        const result = generateTeams(players4, 'none', true);
        const teamPairs = result.teams
          .map(t => [t.player1Id, t.player2Id].sort().join('-'))
          .sort();
        results.push(new Set(teamPairs));
      }

      // At least some results should be different
      const uniqueResults = new Set(results.map(r => Array.from(r).join(',')));
      expect(uniqueResults.size).toBeGreaterThan(1);
    });

    test('should use minimize_repeat strategy', () => {
      const result = generateTeams(players4, 'minimize_repeat', true);

      expect(result.teams).toHaveLength(2);
      // Should still generate valid teams
      const allPlayerIds = new Set<number>();
      result.teams.forEach(team => {
        allPlayerIds.add(team.player1Id);
        allPlayerIds.add(team.player2Id);
      });
      expect(allPlayerIds.size).toBe(4);
    });

    test('should use maximize_even strategy', () => {
      const result = generateTeams(players4, 'maximize_even', true);

      expect(result.teams).toHaveLength(2);
      // Should still generate valid teams
      const allPlayerIds = new Set<number>();
      result.teams.forEach(team => {
        allPlayerIds.add(team.player1Id);
        allPlayerIds.add(team.player2Id);
      });
      expect(allPlayerIds.size).toBe(4);
    });

    test('should use elo_based strategy', () => {
      const result = generateTeams(players4, 'elo_based', true);

      expect(result.teams).toHaveLength(2);

      // ELO-based should pair highest with lowest
      // Players: 1500, 1400, 1300, 1200
      // Expected pairs: (1500, 1200) and (1400, 1300)
      const team1Ids = [result.teams[0].player1Id, result.teams[0].player2Id];
      const team2Ids = [result.teams[1].player1Id, result.teams[1].player2Id];

      // Calculate team ELO totals
      const player1Elo = players4.find(p => p.id === team1Ids[0])?.currentElo || 0;
      const player2Elo = players4.find(p => p.id === team1Ids[1])?.currentElo || 0;
      const player3Elo = players4.find(p => p.id === team2Ids[0])?.currentElo || 0;
      const player4Elo = players4.find(p => p.id === team2Ids[1])?.currentElo || 0;

      const team1TotalElo = player1Elo + player2Elo;
      const team2TotalElo = player3Elo + player4Elo;

      // Team ELOs should be roughly equal
      expect(Math.abs(team1TotalElo - team2TotalElo)).toBeLessThanOrEqual(100);
    });

    test('should fail when allowByes is false with odd players', () => {
      expect(() => generateTeams(players5, 'none', false)).toThrow();
    });

    test('should generate 3 teams from 6 players', () => {
      const result = generateTeams(players6, 'none', true);

      expect(result.teams).toHaveLength(3);
      expect(result.byePlayer).toBeNull();

      // Check all 6 players are assigned
      const assignedPlayerIds = new Set<number>();
      result.teams.forEach(team => {
        assignedPlayerIds.add(team.player1Id);
        assignedPlayerIds.add(team.player2Id);
      });
      expect(assignedPlayerIds.size).toBe(6);
    });

    test('should preserve strategy in result', () => {
      const result = generateTeams(players4, 'elo_based', true);
      expect(result.strategy).toBe('elo_based');
    });

    test('should use different strategies with different results', () => {
      const randomResult = generateTeams(players4, 'none', true);
      const eloResult = generateTeams(players4, 'elo_based', true);

      // ELO-based should always produce the same balanced pairing
      // Random should produce different pairings each time (we run multiple times)
      const eloPairs = eloResult.teams
        .map(t => [t.player1Id, t.player2Id].sort().join('-'))
        .sort()
        .join(',');

      // ELO-based strategy with our test data should produce: 1-4,2-3
      expect(eloPairs).toBe('1-4,2-3');
    });
  });

  describe('generateTeamsWithRotation', () => {
    test('should generate different teams in subsequent rounds', () => {
      const firstRound = generateTeams(players4, 'none', true);

      const previousTeams: Team[][] = [firstRound.teams];
      const secondRound = generateTeamsWithRotation(players4, previousTeams, 'minimize_repeat', true);

      // Teams should be different between rounds
      const firstRoundPairs = new Set(
        firstRound.teams.map(t => [t.player1Id, t.player2Id].sort().join('-'))
      );
      const secondRoundPairs = new Set(
        secondRound.teams.map(t => [t.player1Id, t.player2Id].sort().join('-'))
      );

      // At least some teams should be different
      let differentCount = 0;
      secondRoundPairs.forEach(pair => {
        if (!firstRoundPairs.has(pair)) {
          differentCount++;
        }
      });

      expect(differentCount).toBeGreaterThan(0);
    });

    test('should track partnership frequency correctly', () => {
      const firstRound = generateTeams(players4, 'none', true);
      const secondRound = generateTeamsWithRotation(players4, [firstRound.teams], 'minimize_repeat', true);
      const thirdRound = generateTeamsWithRotation(players4, [firstRound.teams, secondRound.teams], 'minimize_repeat', true);

      // Each player should have different partners in different rounds
      expect(firstRound.teams).toBeDefined();
      expect(secondRound.teams).toBeDefined();
      expect(thirdRound.teams).toBeDefined();
      
      // Verify partnerships are being tracked by ensuring rounds are different
      // (with 4 players, minimize_repeat should try to avoid repeats)
      const firstRoundPairs = firstRound.teams.map(t => [t.player1Id, t.player2Id].sort().join('-')).sort().join(',');
      const secondRoundPairs = secondRound.teams.map(t => [t.player1Id, t.player2Id].sort().join('-')).sort().join(',');
      
      // With 4 players and minimize_repeat strategy, we expect different pairings
      // but it's possible they end up the same due to limited options
      // The important thing is the algorithm is being used
      expect(firstRound.teams.length).toBe(2);
      expect(secondRound.teams.length).toBe(2);
    });

    test('should work with 6 players across multiple rounds', () => {
      const firstRound = generateTeams(players6, 'none', true);
      expect(firstRound.teams).toHaveLength(3);

      const secondRound = generateTeamsWithRotation(players6, [firstRound.teams], 'minimize_repeat', true);
      expect(secondRound.teams).toHaveLength(3);

      // Verify all 6 players are in both rounds
      const round1Players = new Set<number>();
      firstRound.teams.forEach(t => {
        round1Players.add(t.player1Id);
        round1Players.add(t.player2Id);
      });
      expect(round1Players.size).toBe(6);

      const round2Players = new Set<number>();
      secondRound.teams.forEach(t => {
        round2Players.add(t.player1Id);
        round2Players.add(t.player2Id);
      });
      expect(round2Players.size).toBe(6);
    });

    test('should use different rotation strategies', () => {
      const firstRound = generateTeams(players4, 'none', true);

      const minimizeResult = generateTeamsWithRotation(players4, [firstRound.teams], 'minimize_repeat', true);
      const evenResult = generateTeamsWithRotation(players4, [firstRound.teams], 'maximize_even', true);

      expect(minimizeResult.strategy).toBe('minimize_repeat');
      expect(evenResult.strategy).toBe('maximize_even');
    });
  });

  describe('calculatePartnershipFrequency', () => {
    test('should return empty map for empty previous teams', () => {
      const frequency = calculatePartnershipFrequency([], players4);
      expect(frequency.size).toBe(0);
    });

    test('should count partnerships correctly', () => {
      const teams: Team[] = [
        { player1Id: 1, player2Id: 2, teamName: 'Test' },
        { player1Id: 3, player2Id: 4, teamName: 'Test' },
      ];

      const frequency = calculatePartnershipFrequency([teams], players4);

      expect(frequency.get('1-2')).toBe(1);
      expect(frequency.get('3-4')).toBe(1);
    });

    test('should accumulate counts across multiple rounds', () => {
      const round1: Team[] = [
        { player1Id: 1, player2Id: 2, teamName: 'Test' },
      ];
      const round2: Team[] = [
        { player1Id: 1, player2Id: 2, teamName: 'Test' },
      ];

      const frequency = calculatePartnershipFrequency([round1, round2], players4);

      expect(frequency.get('1-2')).toBe(2);
    });
  });

  describe('generateRandomTeams', () => {
    test('should produce different results on multiple calls', () => {
      const results: string[] = [];

      for (let i = 0; i < 10; i++) {
        const teams = generateRandomTeams(players4);
        const teamPairs = teams
          .map(t => [t.player1Id, t.player2Id].sort().join('-'))
          .sort()
          .join(',');
        results.push(teamPairs);
      }

      const uniqueResults = new Set(results);
      expect(uniqueResults.size).toBeGreaterThan(1);
    });

    test('should generate valid teams', () => {
      const teams = generateRandomTeams(players4);

      expect(teams).toHaveLength(2);
      const allPlayers = new Set<number>();
      teams.forEach(team => {
        allPlayers.add(team.player1Id);
        allPlayers.add(team.player2Id);
      });
      expect(allPlayers.size).toBe(4);
    });

    test('should work with 6 players', () => {
      const teams = generateRandomTeams(players6);

      expect(teams).toHaveLength(3);
      const allPlayers = new Set<number>();
      teams.forEach(team => {
        allPlayers.add(team.player1Id);
        allPlayers.add(team.player2Id);
      });
      expect(allPlayers.size).toBe(6);
    });
  });

  describe('generateELOBasedTeams', () => {
    test('should balance team ELOs', () => {
      const teams = generateELOBasedTeams(players4);

      expect(teams).toHaveLength(2);

      // Calculate team ELO totals
      const team1Player1 = players4.find(p => p.id === teams[0].player1Id)!;
      const team1Player2 = players4.find(p => p.id === teams[0].player2Id)!;
      const team2Player1 = players4.find(p => p.id === teams[1].player1Id)!;
      const team2Player2 = players4.find(p => p.id === teams[1].player2Id)!;

      const team1Elo = team1Player1.currentElo + team1Player2.currentElo;
      const team2Elo = team2Player1.currentElo + team2Player2.currentElo;

      // Teams should have similar total ELO
      expect(Math.abs(team1Elo - team2Elo)).toBeLessThanOrEqual(100);
    });

    test('should pair highest with lowest', () => {
      const teams = generateELOBasedTeams(players4);

      // Sort players by ELO
      const sortedPlayers = [...players4].sort((a, b) => b.currentElo - a.currentElo);

      // The first player (highest ELO) should be paired with one of the lower ELO players
      const highestPlayer = sortedPlayers[0];
      const lowestPlayer = sortedPlayers[sortedPlayers.length - 1];

      // Check if highest and lowest are in the same team
      const team1Ids = [teams[0].player1Id, teams[0].player2Id];
      const team2Ids = [teams[1].player1Id, teams[1].player2Id];

      const team1HasHighestAndLowest = team1Ids.includes(highestPlayer.id) && team1Ids.includes(lowestPlayer.id);
      const team2HasHighestAndLowest = team2Ids.includes(highestPlayer.id) && team2Ids.includes(lowestPlayer.id);

      expect(team1HasHighestAndLowest || team2HasHighestAndLowest).toBe(true);
    });

    test('should work with 6 players', () => {
      const teams = generateELOBasedTeams(players6);

      expect(teams).toHaveLength(3);

      // Check all players are assigned
      const allPlayers = new Set<number>();
      teams.forEach(team => {
        allPlayers.add(team.player1Id);
        allPlayers.add(team.player2Id);
      });
      expect(allPlayers.size).toBe(6);
    });
  });

  describe('Team Count Calculations', () => {
    test('4 players should create 2 teams', () => {
      const result = generateTeams(players4, 'none', true);
      expect(result.teams).toHaveLength(2);
    });

    test('6 players should create 3 teams', () => {
      const result = generateTeams(players6, 'none', true);
      expect(result.teams).toHaveLength(3);
    });

    test('5 players should create 2 teams with 1 bye', () => {
      const result = generateTeams(players5, 'none', true);
      expect(result.teams).toHaveLength(2);
      expect(result.byePlayer).not.toBeNull();
    });

    test('8 players should create 4 teams', () => {
      const players8 = [...players6, { id: 7, name: 'Grace', currentElo: 900 }, { id: 8, name: 'Henry', currentElo: 800 }];
      const result = generateTeams(players8, 'none', true);
      expect(result.teams).toHaveLength(4);
      expect(result.byePlayer).toBeNull();
    });

    test('10 players should create 5 teams', () => {
      const players10 = [...players6, { id: 7, name: 'Grace', currentElo: 900 }, { id: 8, name: 'Henry', currentElo: 800 }, { id: 9, name: 'Ivy', currentElo: 700 }, { id: 10, name: 'Jack', currentElo: 600 }];
      const result = generateTeams(players10, 'none', true);
      expect(result.teams).toHaveLength(5);
      expect(result.byePlayer).toBeNull();
    });
  });

  describe('Integration Tests', () => {
    test('full tournament simulation with 8 players', () => {
      const players8 = [
        { id: 1, name: 'Alice', currentElo: 1500 },
        { id: 2, name: 'Bob', currentElo: 1400 },
        { id: 3, name: 'Charlie', currentElo: 1300 },
        { id: 4, name: 'Diana', currentElo: 1200 },
        { id: 5, name: 'Eve', currentElo: 1100 },
        { id: 6, name: 'Frank', currentElo: 1000 },
        { id: 7, name: 'Grace', currentElo: 900 },
        { id: 8, name: 'Henry', currentElo: 800 },
      ];

      // Simulate 3 rounds with minimize_repeat strategy
      const round1 = generateTeams(players8, 'none', true);
      expect(round1.teams).toHaveLength(4);

      const round2 = generateTeamsWithRotation(players8, [round1.teams], 'minimize_repeat', true);
      expect(round2.teams).toHaveLength(4);

      const round3 = generateTeamsWithRotation(players8, [round1.teams, round2.teams], 'minimize_repeat', true);
      expect(round3.teams).toHaveLength(4);

      // Verify each round has all 8 players
      [round1, round2, round3].forEach((round, index) => {
        const playersInRound = new Set<number>();
        round.teams.forEach(team => {
          playersInRound.add(team.player1Id);
          playersInRound.add(team.player2Id);
        });
        expect(playersInRound.size).toBe(8);
      });
    });
  });
});