import { DyFM_DBFilter, DyFM_DBFilterSimple } from '@futdevpro/fsm-dynamo';

import { DyNTS_ArchiveDataService } from '../../../_services/base/archive-data.service';
import { DyNTS_DataService } from '../../../_services/base/data.service';
import { DyNTS_ScopedConfig_Level } from '../_enums/dynts-scoped-config-level.enum';
import {
  DyNTS_ScopedConfig,
  DyNTS_scopedConfig_dataParams
} from '../_models/data-models/dynts-scoped-config.data-model';

/**
 * `DyNTS_ScopedConfig_DataService` — a `dynts_scoped_config` collection CRUD + soft-delete history-rétege
 * (BFR-AM-004). `extends DyNTS_DataService`; `addArchive: true` → a felülírt (régi) értékek
 * soft-delete-elve megőrződnek (audit-trail). A nts-konvenció szerinti `{ data?, issuer }` constructor.
 *
 * **FIGYELEM (memory: dynts_dataservice_eager_resolve):** a `DyNTS_DataService` base-ctor EAGER
 * `getDBService`-t hív → a control-service NEM tarthat élő data-service-példányt mezőként; minden
 * művelet előtt lazy `new DyNTS_ScopedConfig_DataService(...)` kell.
 *
 * **A `value` írása `$set`-tel atomikus** (Mongoose Mixed silent-drop ellen — memory:
 * mongoose_mixed_atomic_write): a `findOne→mutate→save` SILENT-DROP-ot ad a Mixed mezőkre, ezért az
 * érték-frissítést a `setValue` `updateOne({ ... }, { $set: { value } })`-vel végzi.
 */
export class DyNTS_ScopedConfig_DataService extends DyNTS_DataService<DyNTS_ScopedConfig> {

  constructor(
    set: {
      data?: DyNTS_ScopedConfig,
      issuer: string,
    },
  ) {
    super(
      set.data instanceof DyNTS_ScopedConfig ? set.data : new DyNTS_ScopedConfig(set.data),
      DyNTS_scopedConfig_dataParams,
      set.issuer,
    );
  }

  /**
   * Az archív (soft-delete-elt) rekordokhoz tartozó data-service (a base override-ja). A
   * `DyNTS_DataService.deleteData` ezen át archiválja a felülírt aktív rekordokat (history).
   */
  override getArchiveDataService(): DyNTS_ArchiveDataService<DyNTS_ScopedConfig> {
    return new DyNTS_ArchiveDataService<DyNTS_ScopedConfig>(
      this.data,
      DyNTS_scopedConfig_dataParams,
      this.issuer,
    );
  }

  /**
   * Egy adott feloldási-kulcson (`level`+`tableScope`+`scopeId`+`key`) az AKTÍV (nem soft-delete-elt)
   * rekord. Az aktív rekordon a `_deleted` Date soft-delete marker nincs beállítva.
   */
  async findActive(filter: DyFM_DBFilter<DyNTS_ScopedConfig>): Promise<DyNTS_ScopedConfig> {
    return this.findData(filter, true);
  }

  /**
   * Az adott kontextusra konfigurált ÖSSZES aktív rekord (a `resolveAll` egy Mongo-köre).
   */
  async findActiveList(filter: DyFM_DBFilter<DyNTS_ScopedConfig>): Promise<DyNTS_ScopedConfig[]> {
    return this.findDataList(filter, true);
  }

  /**
   * Egy létező aktív rekord `value`-jának ATOMIKUS frissítése (`$set`). A Mixed mező `findOne→mutate→
   * save` útján SILENT-DROP-ot adna; a `$set` ezt elkerüli (memory: mongoose_mixed_atomic_write). A
   * `setBy`/`setByDetail`/`note` audit-mezők is frissülnek.
   */
  async setValue(
    id: string,
    value: unknown,
    audit: { setBy?: string, setByDetail?: string, note?: string } = {},
  ): Promise<void> {
    await this.updateData({
      filterBy: { _id: id },
      update: {
        $set: {
          value: value,
          setBy: audit.setBy,
          setByDetail: audit.setByDetail,
          note: audit.note,
        },
      },
    });
  }

  /** A `(level, tableScope, scopeId, key)` feloldási-kulcs filtere (a logikai unique-constraint). */
  static levelKeyFilter(
    level: DyNTS_ScopedConfig_Level,
    key: string,
    set: { tableScope?: string, scopeId?: string },
  ): DyFM_DBFilterSimple<DyNTS_ScopedConfig> {
    const filter: DyFM_DBFilterSimple<DyNTS_ScopedConfig> = { level: level, key: key };

    if (level === DyNTS_ScopedConfig_Level.table || level === DyNTS_ScopedConfig_Level.scope) {
      filter.tableScope = set.tableScope;
    }

    if (level === DyNTS_ScopedConfig_Level.scope) {
      filter.scopeId = set.scopeId;
    }

    return filter;
  }
}