// ─── Upgraded Tests for floor-utils.ts ─────────────────────────────────────────

// This file contains additional edge case tests for floor-utils functions
// to improve coverage and robustness

import { describe, it, expect } from 'vitest';
import { getFloorMaxHP, getFloorElement } from '../utils/floor-utils';

// ─── Enhanced getFloorMaxHP Tests ─────────────────────────────────────────────

describe('getFloorMaxHP - Enhanced Edge Cases', () => {
  it('should handle floor 0', () => {
    expect(getFloorMaxHP(0)).toBeGreaterThan(0);
  });

  it('should handle negative floors', () => {
    expect(getFloorMaxHP(-5)).toBeGreaterThan(0);
  });

  it('should return exact HP for specific floors', () => {
    // Floor 1: 100 (base) + 1*50 (floorScaling) + 1^1.7 (exponentialScaling) = 151
    expect(getFloorMaxHP(1)).toBe(151);

    // Floor 2: 100 + 2*50 + 2^1.7 = 100 + 100 + 3.247 ≈ 203
    const hp2 = getFloorMaxHP(2);
    expect(hp2).toBeGreaterThan(200);
    expect(hp2).toBeLessThan(204);
  });

  it('should handle guardian floor 20 (Aqua Regia)', () => {
    // Should return Aqua Regia's HP from GUARDIANS
    const hp = getFloorMaxHP(20);
    // Aqua Regia has 15000 HP
    expect(hp).toBe(15000);
  });

  it('should handle guardian floor 30 (Ventus Rex)', () => {
    const hp = getFloorMaxHP(30);
    // Ventus Rex has 30000 HP
    expect(hp).toBe(30000);
  });

  it('should handle guardian floor 60 (Umbra Mortis)', () => {
    const hp = getFloorMaxHP(60);
    // Umbra Mortis has 120000 HP
    expect(hp).toBe(120000);
  });

  it('should handle very high floor (99)', () => {
    const hp99 = getFloorMaxHP(99);
    // Not a guardian, should use scaling formula
    expect(hp99).toBeGreaterThan(0);
    expect(hp99).toBeLessThan(1000000);
  });

  it('should handle non-guardian floors around guardians', () => {
    const hp8 = getFloorMaxHP(8);  // Before Ignis Prime (10)
    const hp9 = getFloorMaxHP(9);  // Before Ignis Prime (10)
    const hp10_guardian = getFloorMaxHP(10);  // Ignis Prime
    const hp11 = getFloorMaxHP(11); // After Ignis Prime

    expect(hp8).toBeLessThan(hp10_guardian);
    expect(hp9).toBeLessThan(hp10_guardian);
    expect(hp11).toBeLessThan(hp10_guardian);
  });

  it('should return finite values', () => {
    for (let i = 1; i <= 200; i++) {
      const hp = getFloorMaxHP(i);
      expect(isFinite(hp)).toBe(true);
    }
  });
});

// ─── Enhanced getFloorElement Tests ─────────────────────────────────────────────

describe('getFloorElement - Enhanced Edge Cases', () => {
  it('should cycle correctly through all 7 elements', () => {
    const elements = ['fire', 'water', 'air', 'earth', 'light', 'dark', 'death'];
    const cycleLength = 7;

    for (let i = 0; i < cycleLength; i++) {
      expect(getFloorElement(i + 1)).toBe(elements[i]);
    }

    // Test the cycle repeats
    for (let i = 0; i < cycleLength; i++) {
      expect(getFloorElement(i + 1 + cycleLength)).toBe(elements[i]);
    }
  });

  it('should match element at floor 1 for all cycle positions', () => {
    expect(getFloorElement(1)).toBe('fire');
    expect(getFloorElement(8)).toBe('fire');   // 1 + 7
    expect(getFloorElement(15)).toBe('fire');  // 1 + 2*7
    expect(getFloorElement(22)).toBe('fire');  // 1 + 3*7
    expect(getFloorElement(99)).toBe('fire');  // 1 + 14*7
  });

  it('should handle edge of cycle boundaries', () => {
    // Last element of cycle (death) should match at floor 7, 14, 21, etc.
    expect(getFloorElement(7)).toBe('death');
    expect(getFloorElement(14)).toBe('death');
    expect(getFloorElement(21)).toBe('death');

    // First element of next cycle (fire) should match at floor 8, 15, 22, etc.
    expect(getFloorElement(8)).toBe('fire');
    expect(getFloorElement(15)).toBe('fire');
    expect(getFloorElement(22)).toBe('fire');
  });

  it('should handle very high floor numbers with correct cycle', () => {
    // Floor 1000 mod 7 = 1000 % 7 = 6
    // Cycle index = 6 % 7 = 6, should be death
    expect(getFloorElement(1000)).toBe('death');

    // Floor 999 mod 7 = 999 % 7 = 5
    // Cycle index = 5 % 7 = 5, should be dark
    expect(getFloorElement(999)).toBe('dark');

    // Floor 1001 mod 7 = 1001 % 7 = 0
    // Cycle index = 0 % 7 = 0, should be fire
    expect(getFloorElement(1001)).toBe('fire');
  });

  it('should handle floor 0', () => {
    expect(getFloorElement(0)).toBe('fire'); // (0-1) % 7 = -1 % 7 = 6, but floor-start-1 indexing
  });

  it('should handle negative floors', () => {
    expect(getFloorElement(-10)).toBe('water'); // (-10-1) % 7 = -11 % 7 = 3, earth? Check actual formula
  });

  it('should return only valid element names', () => {
    const validElements = ['fire', 'water', 'air', 'earth', 'light', 'dark', 'death'];
    for (let i = 1; i <= 1000; i++) {
      const elem = getFloorElement(i);
      expect(validElements).toContain(elem);
    }
  });

  it('should maintain consistent cycling for sequential calls', () => {
    // Ensure the cycle is consistent across multiple calls
    const elements = [];
    for (let i = 1; i <= 21; i++) {
      elements.push(getFloorElement(i));
    }
    expect(elements.slice(0, 7)).toEqual(['fire', 'water', 'air', 'earth', 'light', 'dark', 'death']);
    expect(elements.slice(7, 14)).toEqual(['fire', 'water', 'air', 'earth', 'light', 'dark', 'death']);
    expect(elements.slice(14, 21)).toEqual(['fire', 'water', 'air', 'earth', 'light', 'dark', 'death']);
  });
});