/**
 * Unit tests for tournament update functionality
 * Tests the allowTies field is properly saved when updating tournaments
 */

import { describe, it, expect, mock, beforeEach,} from 'bun:test';
import { prisma } from '@/lib/prisma';

// Create mock functions at module level
const eventFindUniqueMock = mock(() => {});
const eventUpdateMock = mock(() => {});
const canManageTournamentMock = mock(() => {});
const canDeleteTournamentMock = mock(() => {});

// Store default implementations
const defaultCanManageTournament = canManageTournamentMock.mockResolvedValue({ allowed: true });
const defaultCanDeleteTournament = canDeleteTournamentMock.mockResolvedValue({ allowed: true });

// Mock the prisma client
mock.module('@/lib/prisma', () => ({
  prisma: {
    event: {
      findUnique: eventFindUniqueMock,
      update: eventUpdateMock,
    },
  },
}));

// Mock the permissions module
mock.module('@/lib/permissions', () => ({
  canManageTournament: defaultCanManageTournament,
  canDeleteTournament: defaultCanDeleteTournament,
}));

// Import the route handler after mocking
import { PUT } from '@/app/api/tournaments/[id]/route';

describe('Tournament Update API', () => {
  beforeEach(() => {
    // Clear all mock history before each test
    eventFindUniqueMock.mockClear();
    eventUpdateMock.mockClear();
    canManageTournamentMock.mockClear();
    canDeleteTournamentMock.mockClear();
  });

  it('should update allowTies field when provided', async () => {
    // Mock existing tournament
    eventFindUniqueMock.mockImplementation(async () => ({
      id: 1,
      name: 'Test Tournament',
      allowTies: false,
      targetScore: 5,
      eventType: 'tournament',
      format: 'round_robin',
      status: 'planned',
      eventDate: null,
      description: null,
      maxParticipants: null,
      ownerId: null,
      createdAt: new Date(),
      updatedAt: new Date(),
      } as any));

    // Mock successful update
    eventUpdateMock.mockImplementation(async () => ({
      id: 1,
      name: 'Test Tournament',
      allowTies: true,
      targetScore: 5,
      eventType: 'tournament',
      format: 'round_robin',
      status: 'planned',
      eventDate: null,
      description: null,
      maxParticipants: null,
      ownerId: null,
      createdAt: new Date(),
      updatedAt: new Date(),
      } as any));

    const request = new Request('http://localhost/api/tournaments/1', {
      method: 'PUT',
      body: JSON.stringify({
        name: 'Test Tournament',
        allowTies: true,
        targetScore: 5,
      }),
    });

    const params = Promise.resolve({ id: '1' });
    const response = await PUT(request, { params });

    expect(response.status).toBe(200);
    expect(prisma.event.update).toHaveBeenCalledWith(
      expect.objectContaining({
        data: expect.objectContaining({
          allowTies: true,
        }),
      })
    );
  });

  it('should default allowTies to false when not provided', async () => {
    // Mock existing tournament
    eventFindUniqueMock.mockImplementation(async () => ({
      id: 1,
      name: 'Test Tournament',
      allowTies: true,
      targetScore: 5,
      eventType: 'tournament',
      format: 'round_robin',
      status: 'planned',
      eventDate: null,
      description: null,
      maxParticipants: null,
      ownerId: null,
      createdAt: new Date(),
      updatedAt: new Date(),
      } as any));

    // Mock successful update
    eventUpdateMock.mockImplementation(async () => ({
      id: 1,
      name: 'Test Tournament',
      allowTies: false,
      targetScore: 5,
      eventType: 'tournament',
      format: 'round_robin',
      status: 'planned',
      eventDate: null,
      description: null,
      maxParticipants: null,
      ownerId: null,
      createdAt: new Date(),
      updatedAt: new Date(),
      } as any));

    const request = new Request('http://localhost/api/tournaments/1', {
      method: 'PUT',
      body: JSON.stringify({
        name: 'Test Tournament',
        targetScore: 5,
        // allowTies not provided
      }),
    });

    const params = Promise.resolve({ id: '1' });
    const response = await PUT(request, { params });

    expect(response.status).toBe(200);
    expect(prisma.event.update).toHaveBeenCalledWith(
      expect.objectContaining({
        data: expect.objectContaining({
          allowTies: false, // Should default to false
        }),
      })
    );
  });

  it('should preserve allowTies value when updating other fields', async () => {
    // Mock existing tournament with allowTies = true
    eventFindUniqueMock.mockImplementation(async () => ({
      id: 1,
      name: 'Test Tournament',
      allowTies: true,
      targetScore: 5,
      eventType: 'tournament',
      format: 'round_robin',
      status: 'planned',
      eventDate: null,
      description: null,
      maxParticipants: null,
      ownerId: null,
      createdAt: new Date(),
      updatedAt: new Date(),
      } as any));

    // Mock successful update
    eventUpdateMock.mockImplementation(async () => ({
      id: 1,
      name: 'Updated Tournament Name',
      allowTies: true,
      targetScore: 10,
      eventType: 'tournament',
      format: 'round_robin',
      status: 'planned',
      eventDate: null,
      description: null,
      maxParticipants: null,
      ownerId: null,
      createdAt: new Date(),
      updatedAt: new Date(),
      } as any));

    const request = new Request('http://localhost/api/tournaments/1', {
      method: 'PUT',
      body: JSON.stringify({
        name: 'Updated Tournament Name',
        allowTies: true,
        targetScore: 10,
      }),
    });

    const params = Promise.resolve({ id: '1' });
    const response = await PUT(request, { params });

    expect(response.status).toBe(200);
    const updateCall = eventUpdateMock.mock.calls[0][0];
    expect(updateCall.data.allowTies).toBe(true);
    expect(updateCall.data.name).toBe('Updated Tournament Name');
    expect(updateCall.data.targetScore).toBe(10);
  });
});