/**
 * @fileoverview Tests for AggregateRoot base class
 */

import { describe, it, expect, beforeEach } from 'vitest';
import { AggregateRoot } from '../aggregate-root.js';

/**
 * Test ID type
 */
type TestId = string & { readonly __brand: unique symbol };

/**
 * Test implementation of AggregateRoot
 */
class TestAggregate extends AggregateRoot<TestId> {
  private _status: 'active' | 'inactive' = 'active';
  private _name: string;

  constructor(id: TestId, name: string) {
    super(id);
    this._name = name;
  }

  get status(): 'active' | 'inactive' {
    return this._status;
  }

  get name(): string {
    return this._name;
  }

  activate(): void {
    if (this._status === 'active') {
      throw new Error('Already active');
    }

    this._status = 'active';
    this.addDomainEvent({
      aggregateId: this.id,
      eventType: 'TestAggregateActivated',
      occurredAt: new Date(),
      payload: { name: this._name } as Record<string, unknown>,
    });
  }

  deactivate(): void {
    if (this._status === 'inactive') {
      throw new Error('Already inactive');
    }

    this._status = 'inactive';
    this.addDomainEvent({
      aggregateId: this.id,
      eventType: 'TestAggregateDeactivated',
      occurredAt: new Date(),
      payload: { name: this._name } as Record<string, unknown>,
    });
  }

  updateName(name: string): void {
    const oldName = this._name;
    this._name = name;

    this.addDomainEvent({
      aggregateId: this.id,
      eventType: 'TestAggregateNameUpdated',
      occurredAt: new Date(),
      payload: { oldName, newName: name } as Record<string, unknown>,
    });
  }

  // Test method to add multiple events at once
  performComplexOperation(): void {
    this.addDomainEvent({
      aggregateId: this.id,
      eventType: 'ComplexOperationStarted',
      occurredAt: new Date(),
      payload: {} as Record<string, unknown>,
    });

    this.addDomainEvent({
      aggregateId: this.id,
      eventType: 'ComplexOperationCompleted',
      occurredAt: new Date(),
      payload: { result: 'success' } as Record<string, unknown>,
    });
  }
}

describe('AggregateRoot', () => {
  const createTestId = (value: string): TestId => value as TestId;
  let aggregate: TestAggregate;
  let testId: TestId;

  beforeEach(() => {
    testId = createTestId('test-123');
    aggregate = new TestAggregate(testId, 'Test Aggregate');
  });

  describe('domain events', () => {
    it('should start with no domain events', () => {
      expect(aggregate.domainEvents).toHaveLength(0);
    });

    it('should add domain events when business methods are called', () => {
      aggregate.deactivate();

      expect(aggregate.domainEvents).toHaveLength(1);
      expect(aggregate.domainEvents[0]).toMatchObject({
        aggregateId: testId,
        eventType: 'TestAggregateDeactivated',
        payload: { name: 'Test Aggregate' },
      });
    });

    it('should accumulate multiple domain events', () => {
      aggregate.updateName('New Name');
      aggregate.deactivate();

      expect(aggregate.domainEvents).toHaveLength(2);
      expect(aggregate.domainEvents[0].eventType).toBe('TestAggregateNameUpdated');
      expect(aggregate.domainEvents[1].eventType).toBe('TestAggregateDeactivated');
    });

    it('should include timestamps in domain events', () => {
      // First deactivate so we can activate
      aggregate.deactivate();
      aggregate.clearEvents();

      const before = new Date();
      aggregate.activate();
      const after = new Date();

      const event = aggregate.domainEvents[0];
      expect(event.occurredAt.getTime()).toBeGreaterThanOrEqual(before.getTime());
      expect(event.occurredAt.getTime()).toBeLessThanOrEqual(after.getTime());
    });

    it('should clear events when requested', () => {
      aggregate.updateName('Name 1');
      aggregate.updateName('Name 2');

      expect(aggregate.domainEvents).toHaveLength(2);

      aggregate.clearEvents();

      expect(aggregate.domainEvents).toHaveLength(0);
    });

    it('should continue accumulating events after clearing', () => {
      aggregate.updateName('Name 1');
      aggregate.clearEvents();
      aggregate.updateName('Name 2');

      expect(aggregate.domainEvents).toHaveLength(1);
      expect(aggregate.domainEvents[0].payload).toMatchObject({
        oldName: 'Name 1',
        newName: 'Name 2',
      });
    });

    it('should handle complex operations with multiple events', () => {
      aggregate.performComplexOperation();

      expect(aggregate.domainEvents).toHaveLength(2);
      expect(aggregate.domainEvents[0].eventType).toBe('ComplexOperationStarted');
      expect(aggregate.domainEvents[1].eventType).toBe('ComplexOperationCompleted');
      expect(aggregate.domainEvents[1].payload).toMatchObject({ result: 'success' });
    });

    it('should return domain events as a readonly array type', () => {
      aggregate.updateName('New Name');

      const events = aggregate.domainEvents;

      // TypeScript should prevent modifications at compile time
      // At runtime, we can still verify the array contents
      expect(events).toHaveLength(1);
      expect(events[0].eventType).toBe('TestAggregateNameUpdated');

      // Verify the type is ReadonlyArray (this is a compile-time check)
      // The following line would cause a TypeScript error if uncommented:
      // events.push({ aggregateId: 'test', eventType: 'test', occurredAt: new Date(), payload: {} });

      // We can still access array methods that don't modify
      const filtered = events.filter((e) => e.eventType === 'TestAggregateNameUpdated');
      expect(filtered).toHaveLength(1);
    });
  });

  describe('business invariants', () => {
    it('should enforce business rules before adding events', () => {
      aggregate.deactivate();

      // Should throw when trying to deactivate an already inactive aggregate
      expect(() => aggregate.deactivate()).toThrow('Already inactive');

      // Should only have one event (from the first deactivate)
      expect(aggregate.domainEvents).toHaveLength(1);
    });

    it('should maintain state consistency with events', () => {
      expect(aggregate.status).toBe('active');

      aggregate.deactivate();
      expect(aggregate.status).toBe('inactive');

      aggregate.activate();
      expect(aggregate.status).toBe('active');

      // Should have two events
      expect(aggregate.domainEvents).toHaveLength(2);
    });
  });

  describe('inheritance', () => {
    it('should inherit Entity behavior', () => {
      const id = createTestId('test-456');
      const aggregate1 = new TestAggregate(id, 'Aggregate 1');
      const aggregate2 = new TestAggregate(id, 'Aggregate 2');

      expect(aggregate1.equals(aggregate2)).toBe(true);
    });

    it('should maintain identity across operations', () => {
      const originalId = aggregate.id;

      aggregate.updateName('Changed');
      aggregate.deactivate();
      aggregate.activate();

      expect(aggregate.id).toBe(originalId);
    });
  });

  describe('event payload validation', () => {
    it('should store event payloads correctly', () => {
      aggregate.updateName('Updated Name');

      const event = aggregate.domainEvents[0];
      expect(event.payload).toEqual({
        oldName: 'Test Aggregate',
        newName: 'Updated Name',
      });
    });

    it('should handle empty payloads', () => {
      aggregate.performComplexOperation();

      const startEvent = aggregate.domainEvents[0];
      expect(startEvent.payload).toEqual({});
    });

    it('should preserve payload reference sharing', () => {
      aggregate.updateName('New Name');

      const event = aggregate.domainEvents[0];
      const payload = event.payload as Record<string, unknown>;

      // Domain events don't freeze payloads by default
      // This test verifies that payloads are shared references
      payload.testProperty = 'added';

      // The change should be reflected in the aggregate's event
      const actualPayload = aggregate.domainEvents[0].payload as Record<string, unknown>;
      expect(actualPayload.testProperty).toBe('added');

      // But the original properties should still be there
      expect(actualPayload.oldName).toBe('Test Aggregate');
      expect(actualPayload.newName).toBe('New Name');
    });
  });
});