import { describe, it, expect, beforeEach } from 'vitest';
import {
  TokenEconomicsTracker,
  createTokenEconomicsTracker,
} from '../token-economics.js';

describe('TokenEconomicsTracker', () => {
  let tracker: TokenEconomicsTracker;

  beforeEach(() => {
    tracker = new TokenEconomicsTracker();
  });

  describe('token estimation', () => {
    it('should estimate tokens (~4 chars per token)', () => {
      const text = 'This is a test'; // 14 chars
      const tokens = tracker.estimateTokens(text);
      expect(tokens).toBe(4); // ceil(14/4) = 4
    });

    it('should handle empty string', () => {
      expect(tracker.estimateTokens('')).toBe(0);
    });

    it('should handle long text', () => {
      const text = 'a'.repeat(1000);
      expect(tracker.estimateTokens(text)).toBe(250);
    });
  });

  describe('recording creation', () => {
    it('should record memory creation', () => {
      tracker.recordCreation('entry1', 'Test content here');

      const stats = tracker.getStats();
      expect(stats.totalObservations).toBe(1);
      expect(stats.totalDiscoveryTokens).toBeGreaterThan(0);
    });

    it('should track multiple creations', () => {
      tracker.recordCreation('entry1', 'First content');
      tracker.recordCreation('entry2', 'Second content');
      tracker.recordCreation('entry3', 'Third content');

      const stats = tracker.getStats();
      expect(stats.totalObservations).toBe(3);
    });

    it('should track per-entry metrics', () => {
      tracker.recordCreation('entry1', 'Test content');

      const metrics = tracker.getEntryMetrics('entry1');
      expect(metrics.length).toBe(1);
      expect(metrics[0].entryId).toBe('entry1');
      expect(metrics[0].discoveryTokens).toBeGreaterThan(0);
      expect(metrics[0].accessCount).toBe(0);
    });
  });

  describe('recording retrieval', () => {
    it('should record memory retrieval', () => {
      tracker.recordCreation('entry1', 'Test content');
      tracker.recordRetrieval('entry1', 'Test content');

      const stats = tracker.getStats();
      expect(stats.totalReadTokens).toBeGreaterThan(0);
    });

    it('should update access count', () => {
      tracker.recordCreation('entry1', 'Test content');
      tracker.recordRetrieval('entry1', 'Test content');
      tracker.recordRetrieval('entry1', 'Test content');

      const metrics = tracker.getEntryMetrics('entry1');
      expect(metrics[0].accessCount).toBe(2);
    });

    it('should calculate value score', () => {
      tracker.recordCreation('entry1', 'A'.repeat(100)); // 25 discovery tokens
      tracker.recordRetrieval('entry1', 'B'.repeat(40)); // 10 read tokens

      const metrics = tracker.getEntryMetrics('entry1');
      // savings = 25 - 10 = 15
      // valueScore = 15 * 1 = 15
      expect(metrics[0].savings).toBe(15);
      expect(metrics[0].valueScore).toBe(15);
    });
  });

  describe('statistics', () => {
    it('should calculate savings', () => {
      tracker.recordCreation('entry1', 'A'.repeat(100));
      tracker.recordRetrieval('entry1', 'B'.repeat(40));

      const stats = tracker.getStats();
      expect(stats.totalSavings).toBe(15); // 25 - 10
    });

    it('should calculate savings percentage', () => {
      tracker.recordCreation('entry1', 'A'.repeat(100));
      tracker.recordRetrieval('entry1', 'B'.repeat(40));

      const stats = tracker.getStats();
      // (25 - 10) / 25 * 100 = 60%
      expect(stats.savingsPercent).toBe(60);
    });

    it('should handle zero discovery tokens', () => {
      const stats = tracker.getStats();
      expect(stats.savingsPercent).toBe(0);
      expect(stats.avgTokensPerObservation).toBe(0);
    });

    it('should calculate average tokens per observation', () => {
      tracker.recordCreation('entry1', 'A'.repeat(40)); // 10 tokens
      tracker.recordCreation('entry2', 'B'.repeat(80)); // 20 tokens

      const stats = tracker.getStats();
      expect(stats.avgTokensPerObservation).toBe(15); // (10 + 20) / 2
    });
  });

  describe('top/low value entries', () => {
    beforeEach(() => {
      // Create entries with different value scores
      tracker.recordCreation('high-value', 'A'.repeat(200));
      tracker.recordRetrieval('high-value', 'B'.repeat(40));
      tracker.recordRetrieval('high-value', 'B'.repeat(40));
      tracker.recordRetrieval('high-value', 'B'.repeat(40));

      tracker.recordCreation('low-value', 'A'.repeat(40));
      // No retrievals - never accessed

      tracker.recordCreation('medium-value', 'A'.repeat(100));
      tracker.recordRetrieval('medium-value', 'B'.repeat(40));
    });

    it('should return top value entries', () => {
      const top = tracker.getTopValueEntries(2);

      expect(top.length).toBe(2);
      expect(top[0].entryId).toBe('high-value');
    });

    it('should return low value entries', () => {
      const low = tracker.getLowValueEntries(2);

      expect(low.length).toBeGreaterThanOrEqual(1);
      // low-value has 0 access count
      expect(low.some((e) => e.entryId === 'low-value')).toBe(true);
    });
  });

  describe('session tracking', () => {
    it('should track session input tokens', () => {
      tracker.recordSessionInput('session1', 500);

      const summary = tracker.getSessionSummary('session1');
      expect(summary).toBeDefined();
      expect(summary?.inputTokens).toBe(500);
    });

    it('should track session recalls', () => {
      tracker.recordCreation('entry1', 'Test content');
      tracker.recordRetrieval('entry1', 'Test content', 'session1');

      const summary = tracker.getSessionSummary('session1');
      expect(summary).toBeDefined();
      expect(summary?.memoriesRecalled).toBe(1);
    });

    it('should get all session summaries', () => {
      tracker.recordSessionInput('session1', 100);
      tracker.recordSessionInput('session2', 200);

      const summaries = tracker.getAllSessionSummaries();
      expect(summaries.length).toBe(2);
    });
  });

  describe('export/import', () => {
    it('should export metrics', () => {
      tracker.recordCreation('entry1', 'Test content');
      tracker.recordRetrieval('entry1', 'Test content');

      const exported = tracker.export();

      expect(exported.stats).toBeDefined();
      expect(exported.entries).toBeDefined();
      expect(exported.entries.length).toBe(1);
    });

    it('should import metrics', () => {
      const data = {
        entries: [
          {
            entryId: 'imported1',
            discoveryTokens: 100,
            readTokens: 50,
            savings: 50,
            accessCount: 5,
            valueScore: 250,
          },
        ],
      };

      tracker.import(data);

      const metrics = tracker.getEntryMetrics('imported1');
      expect(metrics.length).toBe(1);
      expect(metrics[0].discoveryTokens).toBe(100);
    });
  });

  describe('reset', () => {
    it('should reset all metrics', () => {
      tracker.recordCreation('entry1', 'Test content');
      tracker.recordRetrieval('entry1', 'Test content');

      tracker.reset();

      const stats = tracker.getStats();
      expect(stats.totalObservations).toBe(0);
      expect(stats.totalDiscoveryTokens).toBe(0);
      expect(stats.totalReadTokens).toBe(0);
    });
  });

  describe('formatStats', () => {
    it('should format stats for display', () => {
      tracker.recordCreation('entry1', 'Test content for display');

      const formatted = tracker.formatStats();

      expect(formatted).toContain('Token Economics');
      expect(formatted).toContain('Observations');
      expect(formatted).toContain('Discovery Tokens');
    });
  });

  describe('createTokenEconomicsTracker factory', () => {
    it('should create tracker with default config', () => {
      const tracker = createTokenEconomicsTracker();
      expect(tracker).toBeInstanceOf(TokenEconomicsTracker);
    });

    it('should create tracker with custom config', () => {
      const tracker = createTokenEconomicsTracker({ charsPerToken: 5 });
      // 10 chars / 5 = 2 tokens
      expect(tracker.estimateTokens('1234567890')).toBe(2);
    });
  });

  describe('configuration', () => {
    it('should use default chars per token', () => {
      const tracker = new TokenEconomicsTracker();
      expect(tracker.estimateTokens('1234')).toBe(1);
    });

    it('should accept custom chars per token', () => {
      const tracker = new TokenEconomicsTracker({ charsPerToken: 2 });
      expect(tracker.estimateTokens('1234')).toBe(2);
    });

    it('should include metadata tokens when configured', () => {
      const tracker = new TokenEconomicsTracker({ includeMetadata: true });
      tracker.recordCreation('entry1', 'content', { key: 'value' });

      const metrics = tracker.getEntryMetrics('entry1');
      // Should include metadata tokens
      expect(metrics[0].discoveryTokens).toBeGreaterThan(
        Math.ceil('content'.length / 4)
      );
    });
  });
});