brackt/app/routes/leagues/__tests__/settings-update.test.ts

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { updateLeague } from '~/models/league';
import { findCurrentSeasonWithSports, updateSeason } from '~/models/season';

// Mock all models used in the settings update intent
vi.mock('~/models/league', () => ({
  findLeagueById: vi.fn(),
  updateLeague: vi.fn(),
  deleteLeague: vi.fn(),
}));

vi.mock('~/models/commissioner', () => ({
  isCommissioner: vi.fn(),
  findCommissionersByLeagueId: vi.fn(),
  createCommissioner: vi.fn(),
  countCommissionersByLeagueId: vi.fn(),
  removeCommissionerByLeagueAndUser: vi.fn(),
}));

vi.mock('~/models/season', () => ({
  findCurrentSeasonWithSports: vi.fn(),
  updateSeason: vi.fn(),
}));

vi.mock('~/models/team', () => ({
  findTeamsBySeasonId: vi.fn(),
  createManyTeams: vi.fn(),
  deleteTeam: vi.fn(),
  removeTeamOwner: vi.fn(),
  assignTeamOwner: vi.fn(),
}));

const mockLeague = {
  id: 'league-1',
  name: 'Test League',
  createdBy: 'user-1',
  currentSeasonId: 'season-1',
  isPublicDraftBoard: false,
  discordWebhookUrl: null,
  createdAt: new Date('2025-01-01'),
  updatedAt: new Date('2025-01-01'),
};

const mockSeason = {
  id: 'season-1',
  leagueId: 'league-1',
  year: 2025,
  status: 'pre_draft' as const,
  templateId: null,
  draftRounds: 20,
  flexSpots: 0,
  draftDateTime: null,
  draftInitialTime: 120,
  draftIncrementTime: 15,
  draftTimerMode: 'chess_clock' as const,
  currentPickNumber: null,
  draftStartedAt: null,
  draftPaused: false,
  inviteCode: 'TEST123',
  pointsFor1st: 100,
  pointsFor2nd: 70,
  pointsFor3rd: 50,
  pointsFor4th: 40,
  pointsFor5th: 25,
  pointsFor6th: 25,
  pointsFor7th: 15,
  pointsFor8th: 15,
  seasonSports: [],
  createdAt: new Date('2025-01-01'),
  updatedAt: new Date('2025-01-01'),
};

// ---------------------------------------------------------------------------
// Name validation
// ---------------------------------------------------------------------------

describe('Settings Update - Name Validation', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('should reject an empty league name', () => {
    const name = '';
    const isInvalid = typeof name !== 'string' || !name.trim();
    expect(isInvalid).toBe(true);
    expect(updateLeague).not.toHaveBeenCalled();
  });

  it('should reject a whitespace-only league name', () => {
    const name = '   ';
    const isInvalid = typeof name !== 'string' || !name.trim();
    expect(isInvalid).toBe(true);
  });

  it('should reject a name shorter than 3 characters', () => {
    const name = 'AB';
    const trimmed = name.trim();
    const tooShort = trimmed.length < 3;
    const tooLong = trimmed.length > 50;
    expect(tooShort || tooLong).toBe(true);
  });

  it('should reject a name longer than 50 characters', () => {
    const name = 'A'.repeat(51);
    const trimmed = name.trim();
    const tooLong = trimmed.length > 50;
    expect(tooLong).toBe(true);
  });

  it('should accept a name that is exactly 3 characters', () => {
    const name = 'ABC';
    const trimmed = name.trim();
    expect(trimmed.length >= 3 && trimmed.length <= 50).toBe(true);
  });

  it('should accept a name that is exactly 50 characters', () => {
    const name = 'A'.repeat(50);
    const trimmed = name.trim();
    expect(trimmed.length >= 3 && trimmed.length <= 50).toBe(true);
  });

  it('should trim whitespace from the name before saving', async () => {
    vi.mocked(updateLeague).mockResolvedValue({
      ...mockLeague,
      name: 'Trimmed Name',
    });

    await updateLeague('league-1', { name: '  Trimmed Name  '.trim(), isPublicDraftBoard: false });

    expect(updateLeague).toHaveBeenCalledWith('league-1', {
      name: 'Trimmed Name',
      isPublicDraftBoard: false,
    });
  });
});

// ---------------------------------------------------------------------------
// League-level save (first update block)
// ---------------------------------------------------------------------------

describe('Settings Update - League Save', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('should save name and isPublicDraftBoard=false when checkbox is off', async () => {
    vi.mocked(updateLeague).mockResolvedValue({ ...mockLeague, name: 'New Name', isPublicDraftBoard: false });

    await updateLeague('league-1', { name: 'New Name', isPublicDraftBoard: false });

    expect(updateLeague).toHaveBeenCalledWith('league-1', {
      name: 'New Name',
      isPublicDraftBoard: false,
    });
  });

  it('should save isPublicDraftBoard=true when checkbox is on', async () => {
    vi.mocked(updateLeague).mockResolvedValue({ ...mockLeague, isPublicDraftBoard: true });

    await updateLeague('league-1', { name: 'Test League', isPublicDraftBoard: true });

    expect(updateLeague).toHaveBeenCalledWith('league-1', {
      name: 'Test League',
      isPublicDraftBoard: true,
    });
  });

  it('should return an error when updateLeague throws', async () => {
    const error = new Error('Database connection failed');
    vi.mocked(updateLeague).mockRejectedValue(error);

    // Simulate the try-catch around updateLeague in the action
    let result: { error: string } | undefined;
    try {
      await updateLeague('league-1', { name: 'Test League', isPublicDraftBoard: false });
    } catch {
      result = { error: 'Failed to update league. Please try again.' };
    }

    expect(result).toEqual({ error: 'Failed to update league. Please try again.' });
  });

  it('should not reach season update when updateLeague throws', async () => {
    vi.mocked(updateLeague).mockRejectedValue(new Error('DB error'));
    vi.mocked(findCurrentSeasonWithSports).mockResolvedValue(mockSeason);

    // Action returns early on league save error; season functions should not run
    try {
      await updateLeague('league-1', { name: 'Test', isPublicDraftBoard: false });
    } catch {
      // early return would happen here
    }

    expect(findCurrentSeasonWithSports).not.toHaveBeenCalled();
    expect(updateSeason).not.toHaveBeenCalled();
  });

  it('should redirect when league saves successfully but no season exists', async () => {
    vi.mocked(updateLeague).mockResolvedValue(mockLeague);
    vi.mocked(findCurrentSeasonWithSports).mockResolvedValue(undefined);

    await updateLeague('league-1', { name: 'Test League', isPublicDraftBoard: false });
    const season = await findCurrentSeasonWithSports('league-1');

    expect(season).toBeUndefined();
    // In the real action this triggers redirect(`/leagues/league-1?updated=true`)
  });
});

// ---------------------------------------------------------------------------
// Season-level save (second update block)
// ---------------------------------------------------------------------------

describe('Settings Update - Season Save', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('should update season with valid draft rounds', async () => {
    vi.mocked(updateLeague).mockResolvedValue(mockLeague);
    vi.mocked(findCurrentSeasonWithSports).mockResolvedValue(mockSeason);
    vi.mocked(updateSeason).mockResolvedValue({ ...mockSeason, draftRounds: 15 });

    await updateSeason('season-1', { draftRounds: 15 });

    expect(updateSeason).toHaveBeenCalledWith('season-1', { draftRounds: 15 });
  });

  it('should reject draft rounds below 1', () => {
    const rounds = 0;
    const invalid = rounds < 1 || rounds > 50;
    expect(invalid).toBe(true);
  });

  it('should reject draft rounds above 50', () => {
    const rounds = 51;
    const invalid = rounds < 1 || rounds > 50;
    expect(invalid).toBe(true);
  });

  it('should reject draft rounds less than the number of sports selected', () => {
    const sportsCount = 5;
    const draftRounds = 3;
    const tooFew = draftRounds < sportsCount;
    expect(tooFew).toBe(true);
  });

  it('should map "fast" draft speed to correct timer values', () => {
    const draftSpeed: string = 'fast';
    let initialTime: number;
    let incrementTime: number;

    switch (draftSpeed) {
      case 'fast':
        initialTime = 60;
        incrementTime = 10;
        break;
      case 'standard':
        initialTime = 120;
        incrementTime = 15;
        break;
      case 'slow':
        initialTime = 28800;
        incrementTime = 3600;
        break;
      case 'very-slow':
        initialTime = 43200;
        incrementTime = 3600;
        break;
      default:
        initialTime = 120;
        incrementTime = 15;
    }

    expect(initialTime).toBe(60);
    expect(incrementTime).toBe(10);
  });

  it('should map "standard" draft speed to correct timer values', () => {
    const draftSpeed: string = 'standard';
    let initialTime = 120;
    let incrementTime = 15;

    if (draftSpeed === 'fast') { initialTime = 60; incrementTime = 10; }
    else if (draftSpeed === 'slow') { initialTime = 28800; incrementTime = 3600; }
    else if (draftSpeed === 'very-slow') { initialTime = 43200; incrementTime = 3600; }

    expect(initialTime).toBe(120);
    expect(incrementTime).toBe(15);
  });

  it('should map "slow" draft speed to correct timer values', () => {
    const draftSpeed: string = 'slow';
    let initialTime = 120;
    let incrementTime = 15;

    if (draftSpeed === 'fast') { initialTime = 60; incrementTime = 10; }
    else if (draftSpeed === 'slow') { initialTime = 28800; incrementTime = 3600; }
    else if (draftSpeed === 'very-slow') { initialTime = 43200; incrementTime = 3600; }

    expect(initialTime).toBe(28800);
    expect(incrementTime).toBe(3600);
  });

  it('should map "very-slow" draft speed to correct timer values', () => {
    const draftSpeed: string = 'very-slow';
    let initialTime = 120;
    let incrementTime = 15;

    if (draftSpeed === 'fast') { initialTime = 60; incrementTime = 10; }
    else if (draftSpeed === 'slow') { initialTime = 28800; incrementTime = 3600; }
    else if (draftSpeed === 'very-slow') { initialTime = 43200; incrementTime = 3600; }

    expect(initialTime).toBe(43200);
    expect(incrementTime).toBe(3600);
  });

  it('should fall back to standard speed for an unknown draft speed value', () => {
    const draftSpeed: string = 'turbo-ultra';
    let initialTime = 120;
    let incrementTime = 15;

    if (draftSpeed === 'fast') { initialTime = 60; incrementTime = 10; }
    else if (draftSpeed === 'slow') { initialTime = 28800; incrementTime = 3600; }
    else if (draftSpeed === 'very-slow') { initialTime = 43200; incrementTime = 3600; }

    expect(initialTime).toBe(120);
    expect(incrementTime).toBe(15);
  });

  it('should return a season-specific error message when updateSeason throws', async () => {
    vi.mocked(updateSeason).mockRejectedValue(new Error('Season DB error'));

    let result: { error: string } | undefined;
    try {
      await updateSeason('season-1', { draftRounds: 10 });
    } catch {
      result = { error: 'Failed to update season settings. Please try again.' };
    }

    expect(result).toEqual({ error: 'Failed to update season settings. Please try again.' });
  });

  it('should not say "league" in the season error message', async () => {
    vi.mocked(updateSeason).mockRejectedValue(new Error('DB error'));

    let errorMessage = '';
    try {
      await updateSeason('season-1', { draftRounds: 5 });
    } catch {
      errorMessage = 'Failed to update season settings. Please try again.';
    }

    expect(errorMessage).not.toContain('update league');
  });

  it('should only update scoring fields when season status is pre_draft', () => {
    const preDraftStatus: string = 'pre_draft';
    const draftStatus: string = 'draft';

    // Scoring changes allowed in pre_draft
    const canUpdateScoring = preDraftStatus === 'pre_draft';
    expect(canUpdateScoring).toBe(true);

    // Scoring changes NOT allowed during draft
    const canUpdateScoringDuringDraft = draftStatus === 'pre_draft';
    expect(canUpdateScoringDuringDraft).toBe(false);
  });

  it('should validate scoring points are between 0 and 1000', () => {
    const validPoints = 500;
    const tooLow = -1;
    const tooHigh = 1001;

    expect(validPoints >= 0 && validPoints <= 1000).toBe(true);
    expect(tooLow >= 0 && tooLow <= 1000).toBe(false);
    expect(tooHigh >= 0 && tooHigh <= 1000).toBe(false);
  });
});

// ---------------------------------------------------------------------------
// Team count changes within the update intent
// ---------------------------------------------------------------------------

describe('Settings Update - Team Count Changes', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('should reject team count below 6', () => {
    const newTeamCount = 5;
    const invalid = newTeamCount < 6 || newTeamCount > 16;
    expect(invalid).toBe(true);
  });

  it('should reject team count above 16', () => {
    const newTeamCount = 17;
    const invalid = newTeamCount < 6 || newTeamCount > 16;
    expect(invalid).toBe(true);
  });

  it('should reject team count below the number of teams with owners', () => {
    const teamsWithOwners = 8;
    const newTeamCount = 6;
    const belowOwnerCount = newTeamCount < teamsWithOwners;
    expect(belowOwnerCount).toBe(true);
  });

  it('should allow a valid team count that is >= teams with owners', () => {
    const teamsWithOwners = 6;
    const newTeamCount = 10;
    const valid = newTeamCount >= 6 && newTeamCount <= 16 && newTeamCount >= teamsWithOwners;
    expect(valid).toBe(true);
  });

  it('should create new teams when increasing team count', async () => {
    const { createManyTeams } = await import('~/models/team');
    vi.mocked(createManyTeams).mockResolvedValue([]);

    const currentTeamCount = 8;
    const newTeamCount = 10;
    const teamsToAdd = Array.from(
      { length: newTeamCount - currentTeamCount },
      (_, i) => ({
        seasonId: 'season-1',
        name: `Team ${currentTeamCount + i + 1}`,
        ownerId: null,
      })
    );

    await createManyTeams(teamsToAdd);

    expect(createManyTeams).toHaveBeenCalledWith([
      { seasonId: 'season-1', name: 'Team 9', ownerId: null },
      { seasonId: 'season-1', name: 'Team 10', ownerId: null },
    ]);
  });
});