import { asClass, asFunction, asValue, createContainer } from 'awilix';
import { describe, expect, it, mock } from 'bun:test';
import {
  registerApplicationServices,
  registerCacheServices,
  registerDatabaseServices,
} from '../src/registrations';

describe('DI Registrations', () => {
  describe('registerCacheServices', () => {
    it('should register null cache when redis disabled', () => {
      const container = createContainer();
      const config = {
        service: {
          name: 'test-service',
          type: 'WORKER' as const,
        },
        redis: {
          enabled: false,
          host: 'localhost',
          port: 6379,
        },
      } as any;

      registerCacheServices(container, config);

      const cache = container.resolve('cache');
      expect(cache).toBeNull();
    });

    it('should register redis cache when redis config exists', () => {
      const container = createContainer();

      // Register logger first as it's a dependency
      container.register({
        logger: asValue({
          info: () => {},
          error: () => {},
          warn: () => {},
          debug: () => {},
        }),
      });

      const config = {
        service: {
          name: 'test-service',
          type: 'WORKER' as const,
        },
        redis: {
          enabled: true,
          host: 'localhost',
          port: 6379,
          db: 1,
        },
      } as any;

      registerCacheServices(container, config);

      const cache = container.resolve('cache');
      expect(cache).toBeDefined();
    });

    it('should register both cache and globalCache', () => {
      const container = createContainer();

      // Register logger dependency
      container.register({
        logger: asValue({
          info: () => {},
          error: () => {},
          warn: () => {},
          debug: () => {},
        }),
      });

      const config = {
        service: {
          name: 'test-service',
          serviceName: 'test-service',
        },
        redis: {
          enabled: true,
          host: 'localhost',
          port: 6379,
          db: 1,
        },
      } as any;

      registerCacheServices(container, config);

      const cache = container.resolve('cache');
      const globalCache = container.resolve('globalCache');
      expect(cache).toBeDefined();
      expect(globalCache).toBeDefined();
    });
  });

  describe('registerDatabaseServices', () => {
    it('should register MongoDB when config exists', () => {
      const container = createContainer();
      const mockLogger = {
        info: () => {},
        error: () => {},
        warn: () => {},
        debug: () => {},
      };

      container.register({
        logger: asValue(mockLogger),
      });

      const config = {
        service: {
          name: 'test-service',
          type: 'WORKER' as const,
        },
        mongodb: {
          enabled: true,
          uri: 'mongodb://localhost:27017',
          database: 'test-db',
        },
        redis: { enabled: false, host: 'localhost', port: 6379 },
        postgres: {
          enabled: false,
          host: 'localhost',
          port: 5432,
          database: 'test',
          user: 'test',
          password: 'test',
        },
      } as any;

      registerDatabaseServices(container, config);

      // Check that mongoClient is registered (not mongodb)
      const registrations = container.registrations;
      expect(registrations.mongoClient).toBeDefined();
    });

    it('should register Postgres when config exists', () => {
      const container = createContainer();
      const mockLogger = { info: () => {}, error: () => {} };

      container.register({
        logger: asValue(mockLogger),
      });

      const config = {
        service: {
          name: 'test-service',
          type: 'WORKER' as const,
        },
        postgres: {
          enabled: true,
          host: 'localhost',
          port: 5432,
          database: 'test-db',
          user: 'user',
          password: 'pass',
        },
        mongodb: { enabled: false, uri: 'mongodb://localhost', database: 'test' },
        redis: { enabled: false, host: 'localhost', port: 6379 },
      } as any;

      registerDatabaseServices(container, config);

      const registrations = container.registrations;
      expect(registrations.postgresClient).toBeDefined();
    });

    it('should register QuestDB when config exists', () => {
      const container = createContainer();
      const mockLogger = { info: () => {}, error: () => {} };

      container.register({
        logger: asValue(mockLogger),
      });

      const config = {
        service: {
          name: 'test-service',
          type: 'WORKER' as const,
        },
        questdb: {
          enabled: true,
          host: 'localhost',
          httpPort: 9000,
          pgPort: 8812,
          influxPort: 9009,
          database: 'test',
        },
        mongodb: { enabled: false, uri: 'mongodb://localhost', database: 'test' },
        postgres: {
          enabled: false,
          host: 'localhost',
          port: 5432,
          database: 'test',
          user: 'test',
          password: 'test',
        },
        redis: { enabled: false, host: 'localhost', port: 6379 },
      } as any;

      registerDatabaseServices(container, config);

      const registrations = container.registrations;
      expect(registrations.questdbClient).toBeDefined();
    });

    it('should register null for disabled databases', () => {
      const container = createContainer();
      const config = {
        service: {
          name: 'test-service',
          type: 'WORKER' as const,
        },
        mongodb: { enabled: false, uri: 'mongodb://localhost', database: 'test' },
        postgres: {
          enabled: false,
          host: 'localhost',
          port: 5432,
          database: 'test',
          user: 'test',
          password: 'test',
        },
        redis: { enabled: false, host: 'localhost', port: 6379 },
        // questdb is optional
      } as any;

      registerDatabaseServices(container, config);

      expect(container.resolve('mongoClient')).toBeNull();
      expect(container.resolve('postgresClient')).toBeNull();
      expect(container.resolve('questdbClient')).toBeNull();
    });
  });

  describe('registerApplicationServices', () => {
    it('should register browser service when config exists', () => {
      const container = createContainer();
      const mockLogger = { info: () => {}, error: () => {} };

      container.register({
        logger: asValue(mockLogger),
        config: asValue({
          browser: { headless: true },
        }),
      });

      const config = {
        service: {
          name: 'test-service',
          type: 'WORKER' as const,
        },
        browser: {
          headless: true,
          timeout: 30000,
        },
        redis: { enabled: true, host: 'localhost', port: 6379 },
        mongodb: { enabled: false, uri: 'mongodb://localhost', database: 'test' },
        postgres: {
          enabled: false,
          host: 'localhost',
          port: 5432,
          database: 'test',
          user: 'test',
          password: 'test',
        },
      } as any;

      registerApplicationServices(container, config);

      const registrations = container.registrations;
      expect(registrations.browser).toBeDefined();
    });

    it('should register proxy service when config exists', () => {
      const container = createContainer();
      const mockLogger = { info: () => {}, error: () => {} };

      container.register({
        logger: asValue(mockLogger),
      });

      const config = {
        service: {
          name: 'test-service',
          type: 'WORKER' as const,
        },
        proxy: {
          enabled: true,
          cachePrefix: 'proxy:',
          ttl: 3600,
        },
        redis: { enabled: true, host: 'localhost', port: 6379 },
        mongodb: { enabled: false, uri: 'mongodb://localhost', database: 'test' },
        postgres: {
          enabled: false,
          host: 'localhost',
          port: 5432,
          database: 'test',
          user: 'test',
          password: 'test',
        },
      } as any;

      registerApplicationServices(container, config);

      const registrations = container.registrations;
      expect(registrations.proxyManager).toBeDefined();
    });

    it('should register queue services when queue enabled', () => {
      const container = createContainer();
      const mockLogger = { info: () => {}, error: () => {} };
      const mockHandlerRegistry = { getAllHandlers: () => [] };

      container.register({
        logger: asValue(mockLogger),
        handlerRegistry: asValue(mockHandlerRegistry),
      });

      const config = {
        service: {
          name: 'test-service',
          serviceName: 'test-service',
        },
        queue: {
          enabled: true,
          workers: 2,
          concurrency: 5,
          enableScheduledJobs: true,
          defaultJobOptions: {},
        },
        redis: {
          enabled: true,
          host: 'localhost',
          port: 6379,
        },
        mongodb: { enabled: false, uri: 'mongodb://localhost', database: 'test' },
        postgres: {
          enabled: false,
          host: 'localhost',
          port: 5432,
          database: 'test',
          user: 'test',
          password: 'test',
        },
      } as any;

      registerApplicationServices(container, config);

      const registrations = container.registrations;
      expect(registrations.queueManager).toBeDefined();
    });

    it('should not register queue when disabled', () => {
      const container = createContainer();
      const config = {
        service: {
          name: 'test-api',
          type: 'API' as const,
        },
        queue: {
          enabled: false,
        },
        redis: {
          enabled: true,
          host: 'localhost',
          port: 6379,
        },
        mongodb: { enabled: false, uri: 'mongodb://localhost', database: 'test' },
        postgres: {
          enabled: false,
          host: 'localhost',
          port: 5432,
          database: 'test',
          user: 'test',
          password: 'test',
        },
      } as any;

      registerApplicationServices(container, config);

      const registrations = container.registrations;
      expect(registrations.queueManager).toBeDefined();
      expect(container.resolve('queueManager')).toBeNull();
    });
  });
});