/**
 * Unit Tests — core/result-tracker.js
 */
import { describe, it, expect, beforeEach } from 'vitest';

const { ResultTracker } = require('../../src/core/result-tracker');

const AGENTS = {
  coder:    { type: 'executor', description: 'coder' },
  writer:   { type: 'executor', description: 'writer' },
  verifier: { type: 'validator', description: 'verifier' },
  reviewer: { type: 'validator', description: 'reviewer' },
};

describe('ResultTracker', () => {
  let tracker;

  beforeEach(() => {
    tracker = new ResultTracker(AGENTS);
  });

  describe('isEmpty', () => {
    it('should be empty initially', () => {
      expect(tracker.isEmpty()).toBe(true);
    });

    it('should not be empty after merge', () => {
      tracker.merge([{ agent: 'coder', status: 'DONE', message: 'done' }]);
      expect(tracker.isEmpty()).toBe(false);
    });
  });

  describe('merge', () => {
    it('should merge a batch of results', () => {
      tracker.merge([
        { agent: 'coder', status: 'DONE', message: 'ok' },
        { agent: 'verifier', status: 'PASS', message: 'ok' },
      ]);
      const all = tracker.getAll();
      expect(all).toHaveLength(2);
    });

    it('should overwrite existing results', () => {
      tracker.merge([{ agent: 'coder', status: 'ERROR', message: 'fail' }]);
      tracker.merge([{ agent: 'coder', status: 'DONE', message: 'fixed' }]);
      const all = tracker.getAll();
      expect(all).toHaveLength(1);
      expect(all[0].status).toBe('DONE');
    });
  });

  describe('set', () => {
    it('should set a single result', () => {
      tracker.set('writer', { agent: 'writer', status: 'DONE', message: 'written' });
      const all = tracker.getAll();
      expect(all).toHaveLength(1);
      expect(all[0].agent).toBe('writer');
    });
  });

  describe('history tracking', () => {
    it('should record state changes', () => {
      tracker.merge([{ agent: 'coder', status: 'ERROR', message: 'fail' }], 1);
      tracker.merge([{ agent: 'coder', status: 'DONE', message: 'fixed' }], 2);
      const history = tracker.getHistory('coder');
      expect(history).toHaveLength(2);
      expect(history[0].oldStatus).toBeNull();
      expect(history[0].newStatus).toBe('ERROR');
      expect(history[1].oldStatus).toBe('ERROR');
      expect(history[1].newStatus).toBe('DONE');
    });

    it('should return full history without filter', () => {
      tracker.merge([
        { agent: 'coder', status: 'DONE', message: '' },
        { agent: 'verifier', status: 'PASS', message: '' },
      ]);
      const history = tracker.getHistory();
      expect(history).toHaveLength(2);
    });
  });

  describe('validator queries', () => {
    it('should list all validators', () => {
      expect(tracker.allValidators).toEqual(['verifier', 'reviewer']);
    });

    it('should track passed validators', () => {
      tracker.merge([{ agent: 'verifier', status: 'PASS', message: '' }]);
      expect(tracker.passedValidators).toEqual(['verifier']);
      expect(tracker.unpassedValidators).toEqual(['reviewer']);
    });

    it('should track unpassed validators', () => {
      expect(tracker.unpassedValidators).toEqual(['verifier', 'reviewer']);
    });
  });

  describe('executor queries', () => {
    it('should list all executors', () => {
      expect(tracker.allExecutors).toEqual(['coder', 'writer']);
    });
  });

  describe('isComplete', () => {
    it('should be false when no results', () => {
      expect(tracker.isComplete()).toBe(false);
    });

    it('should be true when all agents are done/pass', () => {
      tracker.merge([
        { agent: 'coder', status: 'DONE', message: '' },
        { agent: 'writer', status: 'DONE', message: '' },
        { agent: 'verifier', status: 'PASS', message: '' },
        { agent: 'reviewer', status: 'PASS', message: '' },
      ]);
      expect(tracker.isComplete()).toBe(true);
    });

    it('should be false when a validator has not passed', () => {
      tracker.merge([
        { agent: 'coder', status: 'DONE', message: '' },
        { agent: 'writer', status: 'DONE', message: '' },
        { agent: 'verifier', status: 'PASS', message: '' },
        { agent: 'reviewer', status: 'FAIL', message: '' },
      ]);
      expect(tracker.isComplete()).toBe(false);
    });
  });
});