import { DyNTS_archiveServiceRegistry } from '../../_collections/archive-service-registry.const';
import {
  DyFM_DataModel_Params,
  DyFM_DBFilterSimple,
  DyFM_Error,
  DyFM_Metadata
} from '@futdevpro/fsm-dynamo';

import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
import { DyNTS_GlobalService } from '../core/global.service';
import { DyNTS_DataService } from './data.service';
import { DyNTS_DBService } from './db.service';
import { DyNTS_global_settings } from '../../_collections/global-settings.const';

// TODO: 3 type of archiving service system: 
// 1.: within list (data have a list that have elements to archive)
// 2.: separate db elements needs to be archived
// 3.: from separate db elements to archive list elements

export class DyNTS_ArchiveDataService<T extends DyFM_Metadata> extends DyNTS_DataService<T> {

  originalDBService: DyNTS_DBService<T>;

  constructor(
    /**
     * Initial data, this will be used by functions on default
     * @deprecated
     */
    data: T,
    /**
     * DB data prams will be used to connect to usable dbService on GlobalService
     * This is the same data params as the original.
     */
    dataParams: DyFM_DataModel_Params<T>,
    /**
     * Initial set for issuer to be able to follow the issuer's activity
     */
    issuer: string
  ) {
    if (!dataParams.addArchive) {
      throw new Error('addArchive is missing from dataParams!');
    }

    const originalDataParams = { ...dataParams };

    dataParams = {
      ...dataParams,
      dataName: DyNTS_getArchivedDBName(dataParams.dataName),
      // An archive collection has NO archive-of-itself. Without this the archive service would inherit
      // the parent's `addArchive: true` → `haveArchiveDataService = true` → base deleteData()/loadData()
      // would call the (unimplemented) getArchiveDataService() and THROW
      // "getArchiveDataService is not implemented!". That broke archive-rotation hard-deletes (e.g. the
      // overseer build-report archive trim, which spun in a tight retry loop logging
      // "Failed to delete old archive"). Forcing it false makes deleteData(id, true) hard-delete the
      // archive record (the `absolute` branch), as intended.
      addArchive: false,
    };

    super(data, dataParams, issuer);

    this.originalDBService = DyNTS_GlobalService.getDBService<T>(originalDataParams);
  }

  async archiveDataById(id: string): Promise<T> {
    try {
      if (!id) {
        throw new DyFM_Error({
          ...this.getDefaultErrorSettings(
            'archiveDataById',
            new Error('archiveDataById failed, id is missing!')
          ),

          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ADS-ADI1`,
        });
      }
      
      const data = await this.originalDBService.getDataById(id);

      if (!data) {
        throw new DyFM_Error({
          ...this.getDefaultErrorSettings(
            'archiveDataById',
            new Error('archiveDataById failed, data not found!')
          ),

          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ADS-ADI2`,
          additionalContent: { 
            id: id,
          },
        });
      }

      return await this.archiveData(data);
    } catch (error) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings(
          'archiveDataById',
          error
        ),

        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ADS-ADI0`,
      });
    }      
  }

  async getDataByOriginalId(originalId: string, dontSetToService?: boolean): Promise<T> {
    try {
      return await this.findData(
        {
          _originalId: originalId,
        } as DyFM_DBFilterSimple<T>, 
        dontSetToService
      );
    } catch (error) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings(
          'getDataByOriginalId',
          error
        ),

        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ADS-GDOI0`,
      });
    }
  }

  async archiveData(data?: T, dontSetToService?: boolean): Promise<T> {
    try {
      data = this.ensureData(data);
      
      if (data?._originalId) {
        throw new DyFM_Error({
          ...this.getDefaultErrorSettings(
            'archiveData',
            new Error(
              `archiveData failed, originalId is already exists! (${this.dataParams.dataName})`
            )
          ),

          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ADS-AD1`,
        });
      }

      if (data?._archived) {
        throw new DyFM_Error({
          ...this.getDefaultErrorSettings(
            'archiveData',
            new Error(
              `archiveData failed, data is already archived! (${this.dataParams.dataName})`
            )
          ),

          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ADS-AD2`,
        });
      }

      if (!data?._id) {
        throw new DyFM_Error({
          ...this.getDefaultErrorSettings(
            'archiveData',
            new Error(`archiveData failed, id is missing! (${this.dataParams.dataName})`)
          ),

          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ADS-AD3`,
        });
      }

      await this.originalDBService.trueDeleteDataById(data._id);

      data._originalId = data._id;
      data._archived = new Date();
      delete data._id;

      return await this.saveData(data, dontSetToService);
    } catch (error) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings(
          'archiveData',
          error
        ),

        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ADS-AD0`,
      });
    }
  }

  override async saveData(data?: T, dontSetToService?: boolean): Promise<T> {
    try {
      data = this.ensureData(data);
  
      if (!data?._originalId) {
        throw new DyFM_Error({
          ...this.getDefaultErrorSettings(
            'saveData',
            new Error(`saveData failed, originalId is missing! (${this.dataParams.dataName})`)
          ),
  
          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ADS-SD1`,
        });
      }
  
      if (!data?._archived) {
        throw new DyFM_Error({
          ...this.getDefaultErrorSettings(
            'saveData',
            new Error(`saveData failed, data is not archived! (${this.dataParams.dataName})`)
          ),
  
          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ADS-SD2`,
        });
      }
      
      return await super.saveData(data, dontSetToService);
    } catch (error) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings(
          'saveData',
          error
        ),

        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ADS-SD0`,
      });
    }
  }
}

// BFR-AM-012: onregisztracio a base data-service default getArchiveDataService()-ehez (ciklus-mentes ut).
DyNTS_archiveServiceRegistry.ArchiveDataService = DyNTS_ArchiveDataService;