import { DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';

import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
import { DyNTS_GlobalService } from '../../../_services/core/global.service';
import { DyNTS_ScopedConfig_Level } from '../_enums/dynts-scoped-config-level.enum';
import { DyNTS_ScopedConfig } from '../_models/data-models/dynts-scoped-config.data-model';
import { DyNTS_ScopedConfig_DataService } from './dynts-scoped-config.data-service';

/**
 * BFR-AM-004 — a `DyNTS_ScopedConfig_DataService` spec-jei. A base-ctor eager `getDBService`-jét
 * stub-oljuk (memory: dynts_dataservice_eager_resolve), így NEM kell élő Mongo. A `setValue`
 * spec bizonyítja a Mixed-érték ATOMIKUS `$set` írását (memory: mongoose_mixed_atomic_write).
 */
describe('| DyNTS_ScopedConfig_DataService', () => {

  let mockDBService: jasmine.SpyObj<{ find: () => Promise<unknown[]>; findOne: () => Promise<unknown> }>;

  beforeAll(() => {
    if (!DyNTS_global_settings.systemShortCodeName) {
      (DyNTS_global_settings as { systemShortCodeName?: string }).systemShortCodeName = 'TEST';
    }

    if (!DyNTS_global_settings.env_settings) {
      (DyNTS_global_settings as { env_settings?: unknown }).env_settings = {
        environment: DyFM_EnvironmentFlag.local,
      };
    }
  });

  beforeEach(() => {
    mockDBService = jasmine.createSpyObj('DyNTS_DBService', [ 'find', 'findOne' ]);
    mockDBService.find.and.returnValue(Promise.resolve([]));
    mockDBService.findOne.and.returnValue(Promise.resolve(null));
    spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockDBService as never);
  });

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

    it('| should create the service with a data model', () => {
      const data: DyNTS_ScopedConfig = new DyNTS_ScopedConfig({
        level: DyNTS_ScopedConfig_Level.global,
        key: 'read.topK',
        value: 5,
      });

      const service: DyNTS_ScopedConfig_DataService =
        new DyNTS_ScopedConfig_DataService({ data: data, issuer: 'issuer-123' });

      expect(service).toBeInstanceOf(DyNTS_ScopedConfig_DataService);
      expect(service.data).toBeDefined();
      expect(service.data.key).toBe('read.topK');
      expect(service.haveArchiveDataService).toBeTrue();
    });

    it('| should create the service without data', () => {
      const service: DyNTS_ScopedConfig_DataService =
        new DyNTS_ScopedConfig_DataService({ issuer: 'issuer-123' });

      expect(service).toBeInstanceOf(DyNTS_ScopedConfig_DataService);
      expect(service.data).toBeInstanceOf(DyNTS_ScopedConfig);
    });
  });

  describe('| setValue — atomic $set (Mongoose Mixed)', () => {

    it('| should issue an updateOne $set for the Mixed value + audit fields', async () => {
      const service: DyNTS_ScopedConfig_DataService =
        new DyNTS_ScopedConfig_DataService({ issuer: 'issuer-123' });

      const updateSpy = spyOn(service, 'updateData').and.returnValue(Promise.resolve());

      await service.setValue('rec-id', [ 'a', 'b' ], { setBy: 'cli', setByDetail: 'user-x' });

      expect(updateSpy).toHaveBeenCalledTimes(1);
      const arg = updateSpy.calls.mostRecent().args[0] as {
        filterBy: { _id: string };
        update: { $set: { value: unknown; setBy?: string; setByDetail?: string } };
      };

      expect(arg.filterBy._id).toBe('rec-id');
      expect(arg.update.$set.value).toEqual([ 'a', 'b' ]);
      expect(arg.update.$set.setBy).toBe('cli');
      expect(arg.update.$set.setByDetail).toBe('user-x');
    });
  });

  describe('| levelKeyFilter (static)', () => {

    it('| should build a global filter with only level + key', () => {
      const filter = DyNTS_ScopedConfig_DataService.levelKeyFilter(
        DyNTS_ScopedConfig_Level.global, 'read.topK', {},
      );

      expect(filter).toEqual({ level: DyNTS_ScopedConfig_Level.global, key: 'read.topK' });
    });

    it('| should include tableScope for a table filter', () => {
      const filter = DyNTS_ScopedConfig_DataService.levelKeyFilter(
        DyNTS_ScopedConfig_Level.table, 'read.topK', { tableScope: 'documents' },
      );

      expect(filter).toEqual({
        level: DyNTS_ScopedConfig_Level.table,
        key: 'read.topK',
        tableScope: 'documents',
      });
    });

    it('| should include tableScope + scopeId for a scope filter', () => {
      const filter = DyNTS_ScopedConfig_DataService.levelKeyFilter(
        DyNTS_ScopedConfig_Level.scope, 'read.topK', { tableScope: 'documents', scopeId: 'leaf' },
      );

      expect(filter).toEqual({
        level: DyNTS_ScopedConfig_Level.scope,
        key: 'read.topK',
        tableScope: 'documents',
        scopeId: 'leaf',
      });
    });
  });
});