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

import { DyNTS_DataService } from '../../../_services/base/data.service';
import {
  DyNTS_LVS_VectorPersist,
  DyNTS_lvsVectorPersist_dataParams
} from '../_models/data-models/lvs-vector-persist.data-model';

/**
 * `DyNTS_LVS_VectorPersist_DataService` (BFR-AM-001) — a `dynts_lvs_vector` collection CRUD-rétege; a
 * `LVS_VectorPool_ControlService` in-memory pool-jának tartós Mongo-háttértára. `extends
 * DyNTS_DataService`; a nts-konvenció szerinti `{ data?, issuer }` constructor.
 *
 * **FIGYELEM (memory: dynts_dataservice_eager_resolve):** a `DyNTS_DataService` base-ctor EAGER
 * `getDBService`-t hív → a hívó NEM tarthat élő data-service-példányt mezőként; minden művelet előtt
 * lazy `new DyNTS_LVS_VectorPersist_DataService(...)` kell (a `DyNTS_LVS_PersistentVectorPool_ControlService` így jár el).
 *
 * **Atomikus írás (memory: mongoose_mixed_atomic_write):** az upsert a `(collectionKey, vectorId)`
 * logikai-kulcson MEGLÉVŐ rekordot `updateOne({...},{$set:{embedding,dimensions,metadata}})`-tel
 * frissíti (a Mixed `metadata` `findOne→mutate→save` SILENT-DROP-ja ellen); ÚJ rekordot `saveData`-val ír.
 */
export class DyNTS_LVS_VectorPersist_DataService extends DyNTS_DataService<DyNTS_LVS_VectorPersist> {

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

  /**
   * Egy (logikai) pool ÖSSZES perzistált, nem-soft-delete-elt vektor-rekordja — a boot-hidratáláshoz
   * (a `DyNTS_LVS_PersistentVectorPool_ControlService.hydrateFromMongo` ezt tölti az in-memory pool-ba).
   */
  async findByCollectionKey(collectionKey: string): Promise<DyNTS_LVS_VectorPersist[]> {
    return this.findDataList(
      { collectionKey: collectionKey },
      true,
    );
  }

  /**
   * Egy vektor ATOMIKUS upsert-je a `(collectionKey, vectorId)` logikai-kulcson. MEGLÉVŐ rekordnál
   * `$set` (a Mixed `metadata` silent-drop ellen — memory: mongoose_mixed_atomic_write); ÚJ rekordnál
   * `saveData`. A dimenzió az `embedding.length`-ből rögzül.
   */
  async upsertVector(set: {
    collectionKey: string,
    vectorId: string,
    embedding: number[],
    metadata?: unknown,
  }): Promise<void> {
    const existing: DyNTS_LVS_VectorPersist = await this.findData(
      { collectionKey: set.collectionKey, vectorId: set.vectorId },
      true,
    );

    if (existing?._id) {
      await this.updateData({
        filterBy: { _id: existing._id },
        update: {
          $set: {
            embedding: set.embedding,
            dimensions: set.embedding.length,
            metadata: set.metadata,
          },
        },
      });

      return;
    }

    await this.saveData(
      new DyNTS_LVS_VectorPersist({
        collectionKey: set.collectionKey,
        vectorId: set.vectorId,
        embedding: set.embedding,
        dimensions: set.embedding.length,
        metadata: set.metadata,
      }),
      true,
    );
  }

  /**
   * Egy vektor-rekord végleges törlése a `(collectionKey, vectorId)` logikai-kulcson (a pool
   * `removeVector`-ja után — a tartós tár is törli). `addArchive` nincs → `absolute` true-val töröl.
   */
  async removeVector(collectionKey: string, vectorId: string): Promise<void> {
    const existing: DyNTS_LVS_VectorPersist = await this.findData(
      { collectionKey: collectionKey, vectorId: vectorId },
      true,
    );

    if (existing?._id) {
      await this.deleteData(existing._id, true);
    }
  }
}