import { describe, it, expect, beforeEach } from 'vitest';
import {
  createMessagingTestHarness,
  createMockMessageBroker,
  createMockSpanContext,
  createMockProducerLink,
  createMockMessageBatch,
  createRebalanceScenario,
  createOutOfOrderScenario,
  createDuplicateScenario,
  extractTraceIdFromHeader,
  extractSpanIdFromHeader,
  type MessagingTestHarness,
  type MockMessageBroker,
} from './messaging-testing';

describe('Messaging Testing Utilities', () => {
  describe('createMessagingTestHarness', () => {
    let harness: MessagingTestHarness;

    beforeEach(() => {
      harness = createMessagingTestHarness();
      harness.reset();
    });

    describe('recordProducerCall', () => {
      it('should record producer calls', () => {
        harness.recordProducerCall({
          destination: 'orders',
          system: 'kafka',
          payload: { orderId: '123' },
          headers: { traceparent: '00-abc-def-01' },
        });

        expect(harness.producerCalls).toHaveLength(1);
        expect(harness.producerCalls[0]?.destination).toBe('orders');
      });

      it('should add timestamp automatically', () => {
        const before = Date.now();
        harness.recordProducerCall({
          destination: 'orders',
          system: 'kafka',
          payload: {},
          headers: {},
        });
        const after = Date.now();

        const call = harness.producerCalls[0];
        expect(call?.timestamp).toBeGreaterThanOrEqual(before);
        expect(call?.timestamp).toBeLessThanOrEqual(after);
      });
    });

    describe('recordConsumerCall', () => {
      it('should record consumer calls', () => {
        harness.recordConsumerCall({
          destination: 'orders',
          system: 'kafka',
          consumerGroup: 'order-processor',
          payload: { orderId: '123' },
          producerLinks: [],
          isDuplicate: false,
          outOfOrderInfo: null,
        });

        expect(harness.consumerCalls).toHaveLength(1);
        expect(harness.consumerCalls[0]?.consumerGroup).toBe('order-processor');
      });
    });

    describe('createMockMessage', () => {
      it('should create mock message with defaults', () => {
        const msg = harness.createMockMessage({ orderId: '123' });

        expect(msg.payload).toEqual({ orderId: '123' });
        expect(msg.headers).toBeDefined();
        expect(msg.headers?.traceparent).toBeDefined();
        expect(msg.offset).toBeDefined();
        expect(msg.messageId).toBeDefined();
      });

      it('should allow custom options', () => {
        const msg = harness.createMockMessage(
          { orderId: '123' },
          { partition: 5, key: 'user-1' },
        );

        expect(msg.partition).toBe(5);
        expect(msg.key).toBe('user-1');
      });
    });

    describe('createMockTraceHeaders', () => {
      it('should create valid traceparent header', () => {
        const headers = harness.createMockTraceHeaders();

        expect(headers.traceparent).toMatch(
          /^00-[a-f0-9]{32}-[a-f0-9]{16}-01$/,
        );
      });

      it('should use provided trace and span IDs', () => {
        const headers = harness.createMockTraceHeaders(
          'a'.repeat(32),
          'b'.repeat(16),
        );

        expect(headers.traceparent).toBe(
          `00-${'a'.repeat(32)}-${'b'.repeat(16)}-01`,
        );
      });
    });

    describe('assertProducerCalled', () => {
      it('should pass when producer was called', () => {
        harness.recordProducerCall({
          destination: 'orders',
          system: 'kafka',
          payload: {},
          headers: { traceparent: '00-abc-def-01' },
        });

        expect(() => harness.assertProducerCalled('orders')).not.toThrow();
      });

      it('should fail when producer was not called', () => {
        expect(() => harness.assertProducerCalled('orders')).toThrow(
          /Expected producer to be called/,
        );
      });

      it('should check message count', () => {
        harness.recordProducerCall({
          destination: 'orders',
          system: 'kafka',
          payload: {},
          headers: {},
        });
        harness.recordProducerCall({
          destination: 'orders',
          system: 'kafka',
          payload: {},
          headers: {},
        });

        expect(() =>
          harness.assertProducerCalled('orders', { messageCount: 2 }),
        ).not.toThrow();

        expect(() =>
          harness.assertProducerCalled('orders', { messageCount: 3 }),
        ).toThrow(/Expected 3 producer calls/);
      });

      it('should check trace headers', () => {
        harness.recordProducerCall({
          destination: 'orders',
          system: 'kafka',
          payload: {},
          headers: { traceparent: '00-abc-def-01' },
        });

        expect(() =>
          harness.assertProducerCalled('orders', { hasTraceHeaders: true }),
        ).not.toThrow();
      });

      it('should fail when trace headers missing', () => {
        harness.recordProducerCall({
          destination: 'orders',
          system: 'kafka',
          payload: {},
          headers: {},
        });

        expect(() =>
          harness.assertProducerCalled('orders', { hasTraceHeaders: true }),
        ).toThrow(/to have trace headers/);
      });
    });

    describe('assertProducerNotCalled', () => {
      it('should pass when producer was not called', () => {
        expect(() => harness.assertProducerNotCalled('orders')).not.toThrow();
      });

      it('should fail when producer was called', () => {
        harness.recordProducerCall({
          destination: 'orders',
          system: 'kafka',
          payload: {},
          headers: {},
        });

        expect(() => harness.assertProducerNotCalled('orders')).toThrow(
          /Expected producer not to be called/,
        );
      });
    });

    describe('assertConsumerProcessed', () => {
      it('should pass when consumer processed messages', () => {
        harness.recordConsumerCall({
          destination: 'orders',
          system: 'kafka',
          payload: {},
          producerLinks: [],
          isDuplicate: false,
          outOfOrderInfo: null,
        });

        expect(() => harness.assertConsumerProcessed('orders')).not.toThrow();
      });

      it('should check for duplicates', () => {
        harness.recordConsumerCall({
          destination: 'orders',
          system: 'kafka',
          payload: {},
          producerLinks: [],
          isDuplicate: true,
          outOfOrderInfo: null,
        });

        expect(() =>
          harness.assertConsumerProcessed('orders', { hasDuplicates: true }),
        ).not.toThrow();

        expect(() =>
          harness.assertConsumerProcessed('orders', { hasDuplicates: false }),
        ).toThrow(/Expected no duplicate messages/);
      });
    });

    describe('getProducerCalls / getConsumerCalls', () => {
      it('should filter by destination', () => {
        harness.recordProducerCall({
          destination: 'orders',
          system: 'kafka',
          payload: {},
          headers: {},
        });
        harness.recordProducerCall({
          destination: 'events',
          system: 'kafka',
          payload: {},
          headers: {},
        });

        const orderCalls = harness.getProducerCalls('orders');
        expect(orderCalls).toHaveLength(1);
        expect(orderCalls[0]?.destination).toBe('orders');

        const allCalls = harness.getProducerCalls();
        expect(allCalls).toHaveLength(2);
      });
    });

    describe('getLastProducerCall / getLastConsumerCall', () => {
      it('should return the last call', () => {
        harness.recordProducerCall({
          destination: 'orders',
          system: 'kafka',
          payload: { id: 1 },
          headers: {},
        });
        harness.recordProducerCall({
          destination: 'orders',
          system: 'kafka',
          payload: { id: 2 },
          headers: {},
        });

        const lastCall = harness.getLastProducerCall('orders');
        expect(lastCall?.payload).toEqual({ id: 2 });
      });

      it('should return undefined when no calls', () => {
        expect(harness.getLastProducerCall('orders')).toBeUndefined();
      });
    });

    describe('reset', () => {
      it('should clear all recorded calls', () => {
        harness.recordProducerCall({
          destination: 'orders',
          system: 'kafka',
          payload: {},
          headers: {},
        });
        harness.recordConsumerCall({
          destination: 'orders',
          system: 'kafka',
          payload: {},
          producerLinks: [],
          isDuplicate: false,
          outOfOrderInfo: null,
        });

        harness.reset();

        expect(harness.producerCalls).toHaveLength(0);
        expect(harness.consumerCalls).toHaveLength(0);
        expect(harness.rebalanceEvents).toHaveLength(0);
      });
    });
  });

  describe('createMockMessageBroker', () => {
    let broker: MockMessageBroker;

    beforeEach(() => {
      broker = createMockMessageBroker();
      broker.clear();
    });

    describe('publish / consume', () => {
      it('should publish and consume messages', () => {
        broker.publish('orders', { payload: { id: 1 } });
        broker.publish('orders', { payload: { id: 2 } });

        const messages = broker.consume('orders');
        expect(messages).toHaveLength(2);
        expect(messages[0]?.payload).toEqual({ id: 1 });
        expect(messages[1]?.payload).toEqual({ id: 2 });
      });

      it('should consume specified count', () => {
        broker.publish('orders', { payload: { id: 1 } });
        broker.publish('orders', { payload: { id: 2 } });
        broker.publish('orders', { payload: { id: 3 } });

        const messages = broker.consume('orders', 2);
        expect(messages).toHaveLength(2);

        const remaining = broker.consume('orders');
        expect(remaining).toHaveLength(1);
      });

      it('should auto-assign offsets', () => {
        broker.publish('orders', { payload: { id: 1 } });
        broker.publish('orders', { payload: { id: 2 } });

        const messages = broker.peek('orders');
        expect(messages[0]?.offset).toBe(0);
        expect(messages[1]?.offset).toBe(1);
      });
    });

    describe('peek', () => {
      it('should peek without consuming', () => {
        broker.publish('orders', { payload: { id: 1 } });

        const peeked = broker.peek('orders');
        expect(peeked).toHaveLength(1);

        const consumed = broker.consume('orders');
        expect(consumed).toHaveLength(1);
      });
    });

    describe('getMessageCount', () => {
      it('should return correct count', () => {
        expect(broker.getMessageCount('orders')).toBe(0);

        broker.publish('orders', { payload: {} });
        broker.publish('orders', { payload: {} });

        expect(broker.getMessageCount('orders')).toBe(2);
      });
    });

    describe('topic management', () => {
      it('should create and delete topics', () => {
        broker.createTopic('orders');
        expect(broker.listTopics()).toContain('orders');

        broker.deleteTopic('orders');
        expect(broker.listTopics()).not.toContain('orders');
      });

      it('should clear specific topic', () => {
        broker.publish('orders', { payload: {} });
        broker.publish('events', { payload: {} });

        broker.clear('orders');

        expect(broker.getMessageCount('orders')).toBe(0);
        expect(broker.getMessageCount('events')).toBe(1);
      });

      it('should clear all topics', () => {
        broker.publish('orders', { payload: {} });
        broker.publish('events', { payload: {} });

        broker.clear();

        expect(broker.listTopics()).toHaveLength(0);
      });
    });
  });

  describe('Context Propagation Helpers', () => {
    describe('extractTraceIdFromHeader', () => {
      it('should extract trace ID from valid traceparent', () => {
        const traceId = extractTraceIdFromHeader(
          '00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01',
        );
        expect(traceId).toBe('4bf92f3577b34da6a3ce929d0e0e4736');
      });

      it('should return null for invalid header', () => {
        expect(extractTraceIdFromHeader('invalid')).toBeNull();
        expect(extractTraceIdFromHeader('')).toBeNull();
      });
    });

    describe('extractSpanIdFromHeader', () => {
      it('should extract span ID from valid traceparent', () => {
        const spanId = extractSpanIdFromHeader(
          '00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01',
        );
        expect(spanId).toBe('00f067aa0ba902b7');
      });

      it('should return null for invalid header', () => {
        expect(extractSpanIdFromHeader('invalid')).toBeNull();
        expect(extractSpanIdFromHeader('00-abc')).toBeNull();
      });
    });

    describe('createMockSpanContext', () => {
      it('should create valid span context', () => {
        const ctx = createMockSpanContext();

        expect(ctx.traceId).toHaveLength(32);
        expect(ctx.spanId).toHaveLength(16);
        expect(ctx.traceFlags).toBe(1);
        expect(ctx.isRemote).toBe(true);
      });

      it('should use provided IDs', () => {
        const ctx = createMockSpanContext('a'.repeat(32), 'b'.repeat(16));

        expect(ctx.traceId).toBe('a'.repeat(32));
        expect(ctx.spanId).toBe('b'.repeat(16));
      });
    });

    describe('createMockProducerLink', () => {
      it('should create valid producer link', () => {
        const link = createMockProducerLink();

        expect(link.context.traceId).toHaveLength(32);
        expect(link.context.spanId).toHaveLength(16);
        expect(link.attributes?.['messaging.link.source']).toBe('producer');
      });
    });
  });

  describe('Scenario Builders', () => {
    describe('createMockMessageBatch', () => {
      it('should create batch with trace headers', () => {
        const batch = createMockMessageBatch([{ id: 1 }, { id: 2 }]);

        expect(batch).toHaveLength(2);
        expect(batch[0]?.headers?.traceparent).toBeDefined();
        expect(batch[1]?.headers?.traceparent).toBeDefined();
      });

      it('should use same trace ID for batch', () => {
        const batch = createMockMessageBatch([{ id: 1 }, { id: 2 }], {
          traceId: 'a'.repeat(32),
        });

        const traceId1 = extractTraceIdFromHeader(
          batch[0]?.headers?.traceparent ?? '',
        );
        const traceId2 = extractTraceIdFromHeader(
          batch[1]?.headers?.traceparent ?? '',
        );

        expect(traceId1).toBe('a'.repeat(32));
        expect(traceId2).toBe('a'.repeat(32));
      });

      it('should set sequential offsets', () => {
        const batch = createMockMessageBatch([{ id: 1 }, { id: 2 }], {
          startOffset: 100,
        });

        expect(batch[0]?.offset).toBe(100);
        expect(batch[1]?.offset).toBe(101);
      });

      it('should skip trace headers when disabled', () => {
        const batch = createMockMessageBatch([{ id: 1 }], {
          addTraceHeaders: false,
        });

        expect(batch[0]?.headers).toBeUndefined();
      });
    });

    describe('createRebalanceScenario', () => {
      it('should create assign and revoke events', () => {
        const scenario = createRebalanceScenario(
          'orders',
          'processors',
          [0, 1, 2],
        );

        expect(scenario.assignEvent.type).toBe('assigned');
        expect(scenario.assignEvent.partitions).toHaveLength(3);
        expect(scenario.assignEvent.destination).toBe('orders');
        expect(scenario.assignEvent.consumerGroup).toBe('processors');

        expect(scenario.revokeEvent.type).toBe('revoked');
        expect(scenario.revokeEvent.partitions).toHaveLength(3);
      });

      it('should have incrementing generations', () => {
        const scenario = createRebalanceScenario('orders', 'processors', [0]);

        expect(scenario.assignEvent.generation).toBe(1);
        expect(scenario.revokeEvent.generation).toBe(2);
      });
    });

    describe('createOutOfOrderScenario', () => {
      it('should create out-of-order messages', () => {
        const messages = createOutOfOrderScenario(
          [{ id: 1 }, { id: 2 }, { id: 3 }],
          [2], // Swap index 2 with index 1
        );

        // Original order: 0, 1, 2
        // After swap at index 2: 0, 2, 1
        expect(messages[0]?.payload).toEqual({ id: 1 });
        expect(messages[1]?.payload).toEqual({ id: 3 }); // Swapped
        expect(messages[2]?.payload).toEqual({ id: 2 }); // Swapped
      });
    });

    describe('createDuplicateScenario', () => {
      it('should create duplicate messages', () => {
        const messages = createDuplicateScenario(
          [{ id: 1 }, { id: 2 }],
          [0], // Duplicate first message
        );

        expect(messages).toHaveLength(3);
        expect(messages[0]?.payload).toEqual({ id: 1 });
        expect(messages[1]?.payload).toEqual({ id: 1 }); // Duplicate
        expect(messages[2]?.payload).toEqual({ id: 2 });
      });

      it('should handle multiple duplicates', () => {
        const messages = createDuplicateScenario(
          [{ id: 1 }, { id: 2 }, { id: 3 }],
          [0, 2],
        );

        // After duplicating index 0 and 2:
        // Original: [1, 2, 3]
        // After dup 0: [1, 1-dup, 2, 3]
        // After dup 2: [1, 1-dup, 2, 3, 3-dup] (original index 2 = {id:3})
        expect(messages.length).toBeGreaterThan(3);
      });
    });
  });
});