/**
 * Unit tests for QuotaManager
 *
 * Tests quota reservation, checking, exhaustion, reset, and KV failure handling.
 */

import { describe, it, expect, beforeEach, vi } from 'vitest';
import { QuotaManager, createQuotaManager, getQuotaManager, withQuotaGuard } from '../quota-manager.js';
import type { Logger } from '../../../lib/logger.js';

// Mock KV namespace
class MockKVNamespace {
  private store: Map<string, string> = new Map();
  private shouldFail = false;

  async get<T = unknown>(key: string, type: 'json'): Promise<T | null>;
  async get(key: string): Promise<string | null>;
  async get<T = unknown>(key: string, type?: 'json'): Promise<T | string | null> {
    if (this.shouldFail) {
      throw new Error('KV failure (simulated)');
    }
    const value = this.store.get(key);
    if (value === undefined) return null;
    if (type === 'json') {
      return JSON.parse(value) as T;
    }
    return value;
  }

  async put(key: string, value: string): Promise<void> {
    if (this.shouldFail) {
      throw new Error('KV failure (simulated)');
    }
    this.store.set(key, value);
  }

  clear(): void {
    this.store.clear();
  }

  setShouldFail(fail: boolean): void {
    this.shouldFail = fail;
  }
}

// Mock Logger
const mockLogger: Logger = {
  info: vi.fn(),
  warn: vi.fn(),
  error: vi.fn(),
  debug: vi.fn(),
  perf: vi.fn(),
  query: vi.fn(),
} as unknown as Logger;

describe('QuotaManager', () => {
  let mockKV: MockKVNamespace;
  let quotaManager: QuotaManager;

  beforeEach(() => {
    mockKV = new MockKVNamespace();
    quotaManager = new QuotaManager(mockKV as unknown as KVNamespace, mockLogger);

    // Reset failure state
    mockKV.setShouldFail(false);

    // Mock console methods to reduce test output noise
    vi.spyOn(console, 'error').mockImplementation(() => {});
    vi.spyOn(console, 'log').mockImplementation(() => {});
  });

  describe('getQuotaStatus', () => {
    it('should return initial quota status with zero usage', async () => {
      const status = await quotaManager.getQuotaStatus();

      expect(status.used_today).toBe(0);
      expect(status.remaining).toBe(15000);
      expect(status.limit).toBe(15000);
      expect(status.buffer_remaining).toBe(13000); // 15000 - 2000 buffer
      expect(status.can_make_calls).toBe(true);
      expect(status.next_reset_in_hours).toBeGreaterThan(0);
      expect(status.next_reset_in_hours).toBeLessThanOrEqual(24);
    });

    it('should return updated status after quota reservation', async () => {
      await quotaManager.reserveQuota(100);
      const status = await quotaManager.getQuotaStatus();

      expect(status.used_today).toBe(100);
      expect(status.remaining).toBe(14900);
      expect(status.buffer_remaining).toBe(12900);
      expect(status.can_make_calls).toBe(true);
    });

    it('should show can_make_calls=false when buffer exhausted', async () => {
      // Use up the entire buffer (13000)
      await quotaManager.reserveQuota(13000);
      const status = await quotaManager.getQuotaStatus();

      expect(status.used_today).toBe(13000);
      expect(status.remaining).toBe(2000);
      expect(status.buffer_remaining).toBe(0);
      expect(status.can_make_calls).toBe(false);
    });

    it('should handle KV failure gracefully', async () => {
      mockKV.setShouldFail(true);
      const status = await quotaManager.getQuotaStatus();

      // getTotalUsage() catches errors and returns 0, so used_today=0
      // This means buffer_remaining = 13000 - 0 = 13000
      // The fallback is only triggered if getTotalUsage() throws up to getQuotaStatus()
      // But since both catch their own errors, we get conservative values
      expect(status.used_today).toBe(0);
      expect(status.remaining).toBe(15000);
      // The actual behavior is to return used_today=0, which shows full quota available
      // This is actually safer than showing 0 buffer because operations will fail when they try to reserve
    });
  });

  describe('checkQuota', () => {
    it('should allow quota check when sufficient quota available', async () => {
      const result = await quotaManager.checkQuota(100, false);

      expect(result.allowed).toBe(true);
      expect(result.status.buffer_remaining).toBe(13000);
      expect(result.reason).toBeUndefined();
    });

    it('should deny quota check when buffer would be exceeded', async () => {
      await quotaManager.reserveQuota(12900);
      const result = await quotaManager.checkQuota(200, false);

      expect(result.allowed).toBe(false);
      expect(result.reason).toContain('would exceed daily limit');
    });

    it('should reserve quota when reserveQuota=true', async () => {
      const result = await quotaManager.checkQuota(500, true);

      expect(result.allowed).toBe(true);

      // Verify quota was actually reserved
      const status = await quotaManager.getQuotaStatus();
      expect(status.used_today).toBe(500);
    });

    it('should not reserve quota when reserveQuota=false', async () => {
      const result = await quotaManager.checkQuota(500, false);

      expect(result.allowed).toBe(true);

      // Verify quota was NOT reserved
      const status = await quotaManager.getQuotaStatus();
      expect(status.used_today).toBe(0);
    });

    it('should handle KV failure by showing available quota but failing on reserve', async () => {
      mockKV.setShouldFail(true);

      // Check-only will appear to succeed (because getTotalUsage returns 0)
      const checkResult = await quotaManager.checkQuota(100, false);
      expect(checkResult.allowed).toBe(true);

      // But actual reservation will fail (fail-closed)
      const reserveResult = await quotaManager.checkQuota(100, true);
      expect(reserveResult.allowed).toBe(false);
      expect(reserveResult.reason).toContain('exhausted by concurrent request');
    });
  });

  describe('reserveQuota', () => {
    it('should successfully reserve quota when available', async () => {
      const success = await quotaManager.reserveQuota(100);

      expect(success).toBe(true);
      const status = await quotaManager.getQuotaStatus();
      expect(status.used_today).toBe(100);
    });

    it('should allow multiple reservations up to limit', async () => {
      await quotaManager.reserveQuota(5000);
      await quotaManager.reserveQuota(5000);
      await quotaManager.reserveQuota(3000);

      const status = await quotaManager.getQuotaStatus();
      expect(status.used_today).toBe(13000);
      expect(status.buffer_remaining).toBe(0);
    });

    it('should deny reservation when buffer exhausted', async () => {
      await quotaManager.reserveQuota(13000); // Use entire buffer
      const success = await quotaManager.reserveQuota(1);

      expect(success).toBe(false);
      const status = await quotaManager.getQuotaStatus();
      expect(status.used_today).toBe(13000);
    });

    it('should deny partial reservation that would exceed buffer', async () => {
      await quotaManager.reserveQuota(12900);
      const success = await quotaManager.reserveQuota(200); // Would exceed by 100

      expect(success).toBe(false);
    });

    it('should return false on KV failure (fail-closed)', async () => {
      mockKV.setShouldFail(true);
      const success = await quotaManager.reserveQuota(100);

      expect(success).toBe(false);
    });
  });

  describe('recordApiCall', () => {
    it('should manually increment quota usage', async () => {
      await quotaManager.recordApiCall(250);

      const status = await quotaManager.getQuotaStatus();
      expect(status.used_today).toBe(250);
    });

    it('should support multiple manual increments', async () => {
      await quotaManager.recordApiCall(100);
      await quotaManager.recordApiCall(200);
      await quotaManager.recordApiCall(50);

      const status = await quotaManager.getQuotaStatus();
      expect(status.used_today).toBe(350);
    });

    it('should not throw on KV failure (graceful degradation)', async () => {
      mockKV.setShouldFail(true);

      await expect(quotaManager.recordApiCall(100)).resolves.not.toThrow();
    });
  });

  describe('resetQuota', () => {
    it('should reset quota to zero', async () => {
      await quotaManager.reserveQuota(5000);
      await quotaManager.resetQuota();

      const status = await quotaManager.getQuotaStatus();
      expect(status.used_today).toBe(0);
      expect(status.buffer_remaining).toBe(13000);
    });

    it('should update last reset date', async () => {
      await quotaManager.resetQuota();
      const afterReset = await quotaManager.getQuotaStatus();

      // Last reset should be today
      const today = new Date().toISOString().split('T')[0];
      expect(afterReset.last_reset).toBe(today);
    });
  });

  describe('daily reset', () => {
    it('should auto-reset quota when day changes', async () => {
      // Set initial usage
      await quotaManager.reserveQuota(1000);

      // Manually set last reset to yesterday
      const yesterday = new Date();
      yesterday.setUTCDate(yesterday.getUTCDate() - 1);
      const yesterdayStr = yesterday.toISOString().split('T')[0];
      await mockKV.put('isbndb_quota_last_reset', yesterdayStr);

      // Next operation should trigger reset
      const status = await quotaManager.getQuotaStatus();

      expect(status.used_today).toBe(0);
      expect(status.last_reset).not.toBe(yesterdayStr);
    });

    it('should not reset quota on same day', async () => {
      await quotaManager.reserveQuota(1000);

      // Call getQuotaStatus again on same day
      const status1 = await quotaManager.getQuotaStatus();
      const status2 = await quotaManager.getQuotaStatus();

      expect(status1.used_today).toBe(1000);
      expect(status2.used_today).toBe(1000);
      expect(status1.last_reset).toBe(status2.last_reset);
    });
  });

  describe('getSafeBatchSize', () => {
    it('should return half of remaining quota as safe batch size', async () => {
      // With 13000 buffer remaining, safe batch = 6500 * 1000 = 6,500,000
      // But default maxBatchSize is 1000, so it caps there
      const batchSize = await quotaManager.getSafeBatchSize();

      expect(batchSize).toBe(1000);
    });

    it('should respect maxBatchSize parameter', async () => {
      const batchSize = await quotaManager.getSafeBatchSize(500);

      expect(batchSize).toBe(500); // Limited by max
    });

    it('should return 0 when quota exhausted', async () => {
      await quotaManager.reserveQuota(13000); // Exhaust buffer
      const batchSize = await quotaManager.getSafeBatchSize();

      expect(batchSize).toBe(0);
    });

    it('should scale batch size with remaining quota', async () => {
      await quotaManager.reserveQuota(12000); // 1000 buffer remaining
      const batchSize = await quotaManager.getSafeBatchSize(1_000_000);

      // 1000 remaining / 2 = 500 calls * 1000 ISBNs = 500,000
      expect(batchSize).toBe(500_000);
    });

    it('should return large batch size when maxBatchSize is large', async () => {
      // With full buffer (13000), half = 6500 calls * 1000 = 6,500,000
      const batchSize = await quotaManager.getSafeBatchSize(10_000_000);

      expect(batchSize).toBe(6_500_000);
    });
  });

  describe('shouldAllowOperation', () => {
    it('should allow cron operation with sufficient buffer', async () => {
      const result = await quotaManager.shouldAllowOperation('cron', 100);

      expect(result.allowed).toBe(true);
    });

    it('should deny cron operation without 2x buffer', async () => {
      await quotaManager.reserveQuota(12800); // Only 200 buffer left
      const result = await quotaManager.shouldAllowOperation('cron', 150);

      // Needs 300 buffer (150 * 2), only 200 available
      expect(result.allowed).toBe(false);
      expect(result.reason).toContain('Cron operation blocked');
    });

    it('should allow bulk_author operation under 100 calls', async () => {
      const result = await quotaManager.shouldAllowOperation('bulk_author', 50);

      expect(result.allowed).toBe(true);
    });

    it('should deny bulk_author operation over 100 calls', async () => {
      const result = await quotaManager.shouldAllowOperation('bulk_author', 150);

      expect(result.allowed).toBe(false);
      expect(result.reason).toContain('Bulk operation too large');
    });

    it('should allow batch_direct and new_releases without extra rules', async () => {
      const directResult = await quotaManager.shouldAllowOperation('batch_direct', 500);
      const releasesResult = await quotaManager.shouldAllowOperation('new_releases', 500);

      expect(directResult.allowed).toBe(true);
      expect(releasesResult.allowed).toBe(true);
    });
  });

  describe('createQuotaManager factory', () => {
    it('should create QuotaManager instance', () => {
      const manager = createQuotaManager(mockKV as unknown as KVNamespace, mockLogger);

      expect(manager).toBeInstanceOf(QuotaManager);
    });
  });

  describe('getQuotaManager singleton', () => {
    it('should return same instance across multiple calls', () => {
      const manager1 = getQuotaManager(mockKV as unknown as KVNamespace, mockLogger);
      const manager2 = getQuotaManager(mockKV as unknown as KVNamespace, mockLogger);

      expect(manager1).toBe(manager2); // Same instance reference
      expect(manager1).toBeInstanceOf(QuotaManager);
    });

    it('should update logger on subsequent calls', () => {
      const logger1 = { info: vi.fn(), error: vi.fn(), warn: vi.fn(), debug: vi.fn() } as any;
      const logger2 = { info: vi.fn(), error: vi.fn(), warn: vi.fn(), debug: vi.fn() } as any;

      const manager = getQuotaManager(mockKV as unknown as KVNamespace, logger1);

      // First call should use logger1
      manager['logger'].info('test1');
      expect(logger1.info).toHaveBeenCalledWith('test1');
      expect(logger2.info).not.toHaveBeenCalled();

      // Get singleton again with logger2 - should update logger
      const sameManager = getQuotaManager(mockKV as unknown as KVNamespace, logger2);
      expect(sameManager).toBe(manager); // Same instance

      // Second call should use logger2
      sameManager['logger'].info('test2');
      expect(logger2.info).toHaveBeenCalledWith('test2');
    });

    it('should maintain state across singleton calls', async () => {
      const manager1 = getQuotaManager(mockKV as unknown as KVNamespace, mockLogger);
      await manager1.reserveQuota(100);

      const manager2 = getQuotaManager(mockKV as unknown as KVNamespace, mockLogger);
      const status = await manager2.getQuotaStatus();

      expect(status.used_today).toBe(100); // State preserved
    });
  });

  describe('withQuotaGuard utility', () => {
    it('should execute API call when quota available', async () => {
      const mockApiCall = vi.fn().mockResolvedValue({ data: 'success' });

      const result = await withQuotaGuard(
        quotaManager,
        'test-operation',
        10,
        mockApiCall,
        mockLogger
      );

      expect(result).toEqual({ data: 'success' });
      expect(mockApiCall).toHaveBeenCalledOnce();

      // Verify quota was reserved
      const status = await quotaManager.getQuotaStatus();
      expect(status.used_today).toBe(10);
    });

    it('should throw error when quota exhausted', async () => {
      await quotaManager.reserveQuota(13000); // Exhaust quota
      const mockApiCall = vi.fn();

      await expect(
        withQuotaGuard(quotaManager, 'test-operation', 10, mockApiCall, mockLogger)
      ).rejects.toThrow('Quota exhausted');

      expect(mockApiCall).not.toHaveBeenCalled();
    });

    it('should propagate API call errors', async () => {
      const mockApiCall = vi.fn().mockRejectedValue(new Error('API error'));

      await expect(
        withQuotaGuard(quotaManager, 'test-operation', 10, mockApiCall, mockLogger)
      ).rejects.toThrow('API error');

      // Quota should still be reserved even on failure
      const status = await quotaManager.getQuotaStatus();
      expect(status.used_today).toBe(10);
    });
  });

  describe('concurrent operations', () => {
    it('should handle concurrent reservations', async () => {
      // Simulate multiple concurrent reservations
      const reservations = await Promise.all([
        quotaManager.reserveQuota(100),
        quotaManager.reserveQuota(200),
        quotaManager.reserveQuota(300),
        quotaManager.reserveQuota(400),
      ]);

      expect(reservations).toEqual([true, true, true, true]);

      const status = await quotaManager.getQuotaStatus();
      // Due to race conditions in our mock (no true atomic operations),
      // we might not get exactly 1000, but we should get at least the last value
      expect(status.used_today).toBeGreaterThan(0);
      expect(status.used_today).toBeLessThanOrEqual(1000);
    });

    it('should eventually deny when concurrent reservations exhaust quota', async () => {
      // Reserve most of the quota
      await quotaManager.reserveQuota(12500);

      // Try concurrent reservations that would exceed
      const reservations = await Promise.all([
        quotaManager.reserveQuota(300),
        quotaManager.reserveQuota(300),
        quotaManager.reserveQuota(300),
      ]);

      // Due to race conditions with mock, exact behavior varies
      // But at least one should succeed, and total should not exceed 13000
      const successCount = reservations.filter(r => r).length;
      expect(successCount).toBeGreaterThanOrEqual(1);

      const status = await quotaManager.getQuotaStatus();
      expect(status.used_today).toBeLessThanOrEqual(13000);
    });
  });

  describe('edge cases', () => {
    it('should handle zero quota requests', async () => {
      const result = await quotaManager.checkQuota(0, true);

      expect(result.allowed).toBe(true);

      const status = await quotaManager.getQuotaStatus();
      expect(status.used_today).toBe(0);
    });

    it('should handle exactly buffer limit reservation', async () => {
      const success = await quotaManager.reserveQuota(13000);

      expect(success).toBe(true);

      const status = await quotaManager.getQuotaStatus();
      expect(status.used_today).toBe(13000);
      expect(status.buffer_remaining).toBe(0);
      expect(status.can_make_calls).toBe(false);
    });

    it('should handle large single reservation', async () => {
      const success = await quotaManager.reserveQuota(10000);

      expect(success).toBe(true);

      const status = await quotaManager.getQuotaStatus();
      expect(status.used_today).toBe(10000);
      expect(status.buffer_remaining).toBe(3000);
    });
  });
});