import { DyNTS_AI_EmbeddingProvider_Registry } from './ai-embedding-provider.registry';
import { DyNTS_LMStudio_Embedding_ControlService } from './lmstudio-embedding.control-service';
import { DyNTS_AI_Embedding_MockService } from '../_modules/ai-mock/_services/ai-embedding-mock.service';
import { DyNTS_OAI_Embedding_ControlService } from '../_modules/open-ai/_services/oai-embedding.control-service';

describe('| DyNTS_AI_EmbeddingProvider_Registry', () => {

  /** Az env-mező visszaállításához (a normalizeKey env-feloldás-ágához). */
  let savedProviderEnv: string | undefined;
  let savedBaseUrlEnv: string | undefined;

  beforeEach(() => {
    savedProviderEnv = process.env.AI_EMBEDDING_PROVIDER;
    savedBaseUrlEnv = process.env.LMSTUDIO_BASE_URL;
    delete process.env.AI_EMBEDDING_PROVIDER;
    delete process.env.LMSTUDIO_BASE_URL;
  });

  afterEach(() => {
    if (savedProviderEnv === undefined) {
      delete process.env.AI_EMBEDDING_PROVIDER;
    } else {
      process.env.AI_EMBEDDING_PROVIDER = savedProviderEnv;
    }
    if (savedBaseUrlEnv === undefined) {
      delete process.env.LMSTUDIO_BASE_URL;
    } else {
      process.env.LMSTUDIO_BASE_URL = savedBaseUrlEnv;
    }
  });

  describe('| normalizeKey', () => {
    it('| should resolve openai aliases', () => {
      expect(DyNTS_AI_EmbeddingProvider_Registry.normalizeKey('openai')).toBe('openai');
      expect(DyNTS_AI_EmbeddingProvider_Registry.normalizeKey('OpenAI')).toBe('openai');
      expect(DyNTS_AI_EmbeddingProvider_Registry.normalizeKey('open-ai')).toBe('openai');
    });

    it('| should resolve lmstudio aliases', () => {
      expect(DyNTS_AI_EmbeddingProvider_Registry.normalizeKey('lmstudio')).toBe('lmstudio');
      expect(DyNTS_AI_EmbeddingProvider_Registry.normalizeKey('lm-studio')).toBe('lmstudio');
      expect(DyNTS_AI_EmbeddingProvider_Registry.normalizeKey('local-ai')).toBe('lmstudio');
    });

    it('| should resolve mock aliases', () => {
      expect(DyNTS_AI_EmbeddingProvider_Registry.normalizeKey('mock')).toBe('mock');
      expect(DyNTS_AI_EmbeddingProvider_Registry.normalizeKey('test')).toBe('mock');
    });

    it('| should default to openai when no provider and no env', () => {
      expect(DyNTS_AI_EmbeddingProvider_Registry.normalizeKey()).toBe('openai');
    });

    it('| should fall back to the AI_EMBEDDING_PROVIDER env var', () => {
      process.env.AI_EMBEDDING_PROVIDER = 'mock';
      expect(DyNTS_AI_EmbeddingProvider_Registry.normalizeKey()).toBe('mock');
    });

    it('| should throw on an unknown provider', () => {
      expect(() => DyNTS_AI_EmbeddingProvider_Registry.normalizeKey('gemini')).toThrow();
    });
  });

  describe('| resolve', () => {
    it('| should resolve the openai provider to DyNTS_OAI_Embedding_ControlService', () => {
      const service = DyNTS_AI_EmbeddingProvider_Registry.resolve({
        provider: 'openai',
        openAiSettings: { config: { apiKey: 'test-key' } },
      });
      expect(service).toBeInstanceOf(DyNTS_OAI_Embedding_ControlService);
    });

    it('| should resolve the lmstudio provider to DyNTS_LMStudio_Embedding_ControlService', () => {
      const service = DyNTS_AI_EmbeddingProvider_Registry.resolve({
        provider: 'lmstudio',
        lmStudioSettings: { baseUrl: 'http://localhost:1234/v1' },
      });
      expect(service).toBeInstanceOf(DyNTS_LMStudio_Embedding_ControlService);
    });

    it('| should resolve the lmstudio baseUrl from the LMSTUDIO_BASE_URL env var', () => {
      process.env.LMSTUDIO_BASE_URL = 'http://localhost:5678/v1';
      const service = DyNTS_AI_EmbeddingProvider_Registry.resolve({ provider: 'lmstudio' });
      expect(service).toBeInstanceOf(DyNTS_LMStudio_Embedding_ControlService);
    });

    it('| should throw if lmstudio is selected without a baseUrl', () => {
      expect(() => DyNTS_AI_EmbeddingProvider_Registry.resolve({ provider: 'lmstudio' })).toThrow();
    });

    it('| should resolve the mock provider to DyNTS_AI_Embedding_MockService', () => {
      const service = DyNTS_AI_EmbeddingProvider_Registry.resolve({ provider: 'mock' });
      expect(service).toBeInstanceOf(DyNTS_AI_Embedding_MockService);
    });

    it('| should pass the cost-event sink through to the mock provider', async () => {
      const events: string[] = [];
      const service = DyNTS_AI_EmbeddingProvider_Registry.resolve({
        provider: 'mock',
        onCostEvent: (event) => events.push(event.provider),
      });
      await service.createEmbeddings({ texts: ['x'], model: 'm', issuer: 'test' });
      expect(events).toEqual(['mock']);
    });

    it('| should throw on an unknown provider in resolve', () => {
      expect(() => DyNTS_AI_EmbeddingProvider_Registry.resolve({ provider: 'cohere' })).toThrow();
    });
  });
});