/**
 * Unit Tests: Player Profile Enhancements
 * 
 * Tests for player profile page enhancements including:
 * - Tournaments participated in
 * - Recent games
 * - Partnership performance
 */

import { describe, test, expect, vi } from 'vitest';
import { prisma } from '@/lib/prisma';
import type { Player, Event, Match, PartnershipStat } from '@prisma/client';

// Mock the prisma module
vi.mock('@/lib/prisma', () => ({
  prisma: {
    player: {
      findUnique: vi.fn(),
    },
    event: {
      findMany: vi.fn(),
    },
    match: {
      findMany: vi.fn(),
    },
    partnershipStat: {
      findMany: vi.fn(),
    },
  },
}));

// Helper to create mock player
const createMockPlayer = (id: number, name: string): Player => ({
  id,
  name,
  normalizedName: name.toLowerCase(),
  rating: 0,
  currentElo: 1000,
  gamesPlayed: 10,
  wins: 6,
  losses: 4,
  createdAt: new Date(),
  updatedAt: new Date(),
});

// Helper to create mock tournament
const createMockTournament = (id: number, name: string): Event => ({
  id,
  name,
  description: null,
  eventDate: new Date(),
  eventType: 'tournament',
  format: 'round_robin',
  status: 'completed',
  maxParticipants: null,
  ownerId: null,
  createdAt: new Date(),
  updatedAt: new Date(),
});

// Helper to create mock match
const createMockMatch = (
  id: number,
  team1P1Id: number,
  team1P2Id: number,
  team2P1Id: number,
  team2P2Id: number,
  team1Score: number,
  team2Score: number,
  eventId?: number
): Match => ({
  id,
  eventId: eventId || null,
  playedAt: new Date(),
  team1P1Id,
  team1P2Id,
  team2P1Id,
  team2P2Id,
  team1Score,
  team2Score,
  status: 'completed',
  createdById: null,
  createdAt: new Date(),
  updatedAt: new Date(),
});

// Helper to create mock partnership stat
const createMockPartnershipStat = (
  id: number,
  player1Id: number,
  player2Id: number,
  gamesPlayed: number,
  wins: number,
  losses: number
): PartnershipStat => ({
  id,
  player1Id,
  player2Id,
  gamesPlayed,
  wins,
  losses,
  totalEloChange: 0,
  lastPlayed: new Date(),
  createdAt: new Date(),
  updatedAt: new Date(),
});

describe('Player Profile Enhancements', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  describe('Tournaments Participated', () => {
    test('should fetch tournaments where player participated', async () => {
      const mockPlayer = createMockPlayer(1, 'Test Player');
      const mockTournaments = [
        createMockTournament(1, 'Tournament A'),
        createMockTournament(2, 'Tournament B'),
      ];

      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
      vi.mocked(prisma.event.findMany).mockResolvedValue(mockTournaments);

      // Simulate the query that would be run
      const tournaments = await prisma.event.findMany({
        where: {
          participants: {
            some: {
              playerId: 1,
            },
          },
        },
        orderBy: { eventDate: 'desc' },
        take: 10,
      });

      expect(tournaments).toEqual(mockTournaments);
      expect(tournaments.length).toBe(2);
    });

    test('should return empty array if player has no tournaments', async () => {
      const mockPlayer = createMockPlayer(1, 'Test Player');

      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
      vi.mocked(prisma.event.findMany).mockResolvedValue([]);

      const tournaments = await prisma.event.findMany({
        where: {
          participants: {
            some: {
              playerId: 1,
            },
          },
        },
        orderBy: { eventDate: 'desc' },
        take: 10,
      });

      expect(tournaments).toEqual([]);
      expect(tournaments.length).toBe(0);
    });
  });

  describe('Recent Games', () => {
    test('should fetch recent matches for a player', async () => {
      const mockPlayer = createMockPlayer(1, 'Test Player');
      const mockMatches = [
        createMockMatch(1, 1, 2, 3, 4, 5, 3),
        createMockMatch(2, 1, 3, 5, 6, 4, 4),
      ];

      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
      vi.mocked(prisma.match.findMany).mockResolvedValue(mockMatches);

      // Simulate the query that would be run
      const matches = await prisma.match.findMany({
        where: {
          OR: [
            { team1P1Id: 1 },
            { team1P2Id: 1 },
            { team2P1Id: 1 },
            { team2P2Id: 1 },
          ],
        },
        include: {
          team1P1: true,
          team1P2: true,
          team2P1: true,
          team2P2: true,
          event: true,
        },
        orderBy: { playedAt: 'desc' },
        take: 10,
      });

      expect(matches).toEqual(mockMatches);
      expect(matches.length).toBe(2);
    });

    test('should return empty array if player has no matches', async () => {
      const mockPlayer = createMockPlayer(1, 'Test Player');

      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
      vi.mocked(prisma.match.findMany).mockResolvedValue([]);

      const matches = await prisma.match.findMany({
        where: {
          OR: [
            { team1P1Id: 1 },
            { team1P2Id: 1 },
            { team2P1Id: 1 },
            { team2P2Id: 1 },
          ],
        },
        include: {
          team1P1: true,
          team1P2: true,
          team2P1: true,
          team2P2: true,
          event: true,
        },
        orderBy: { playedAt: 'desc' },
        take: 10,
      });

      expect(matches).toEqual([]);
      expect(matches.length).toBe(0);
    });
  });

  describe('Partnership Performance', () => {
    test('should fetch partnership stats for a player', async () => {
      const mockPlayer = createMockPlayer(1, 'Test Player');
      const mockPartnershipStats = [
        createMockPartnershipStat(1, 1, 2, 10, 7, 3),
        createMockPartnershipStat(2, 1, 3, 5, 2, 3),
      ];

      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
      vi.mocked(prisma.partnershipStat.findMany).mockResolvedValue(mockPartnershipStats);

      // Simulate the query that would be run
      const partnershipStats = await prisma.partnershipStat.findMany({
        where: {
          OR: [
            { player1Id: 1 },
            { player2Id: 1 },
          ],
        },
        include: {
          player1: true,
          player2: true,
        },
        orderBy: { gamesPlayed: 'desc' },
      });

      expect(partnershipStats).toEqual(mockPartnershipStats);
      expect(partnershipStats.length).toBe(2);
    });

    test('should return empty array if player has no partnership data', async () => {
      const mockPlayer = createMockPlayer(1, 'Test Player');

      vi.mocked(prisma.player.findUnique).mockResolvedValue(mockPlayer);
      vi.mocked(prisma.partnershipStat.findMany).mockResolvedValue([]);

      const partnershipStats = await prisma.partnershipStat.findMany({
        where: {
          OR: [
            { player1Id: 1 },
            { player2Id: 1 },
          ],
        },
        include: {
          player1: true,
          player2: true,
        },
        orderBy: { gamesPlayed: 'desc' },
      });

      expect(partnershipStats).toEqual([]);
      expect(partnershipStats.length).toBe(0);
    });
  });

  describe('Profile Statistics', () => {
    test('should calculate win rate correctly', async () => {
      const mockPlayer = createMockPlayer(1, 'Test Player');
      // wins: 6, gamesPlayed: 10
      const winRate = (mockPlayer.wins / mockPlayer.gamesPlayed) * 100;
      
      expect(winRate).toBe(60.0);
    });

    test('should handle zero games played', async () => {
      const mockPlayer = { ...createMockPlayer(1, 'Test Player'), gamesPlayed: 0, wins: 0 };
      const winRate = mockPlayer.gamesPlayed > 0 
        ? ((mockPlayer.wins / mockPlayer.gamesPlayed) * 100).toFixed(1)
        : "0.0";
      
      expect(winRate).toBe("0.0");
    });
  });
});