import * as mongodb from 'mongodb';

export default DataMigration;

/**
 * Template T is used as the Object document
 * and TSchema as Schema (according to the mongodb doc)
 */

type RollBackUpdateObject = {
  $set?: any;
  $unset?: any;
};

declare class DataMigration<TSchema> {
  constructor(
    migrationId: string,
    collectionName: string,
    query: mongodb.FilterQuery<TSchema>,
    projection: mongodb.FindOneOptions,
    update: (arg: TSchema) => Promise<mongodb.FilterQuery<TSchema>>,
    options?: DataMigration.Options<TSchema>,
  );

  // Returns the collection name for restoring data after the migration execution
  getMigrationCollectionName(): string;

  // Creates the migration collection and returns its definition
  getMigrationCollection<TSchema>(
    db: mongodb.Db,
  ): Promise<mongodb.Collection<TSchema>>;

  // Returns the collection on which the migration must be applied
  getCollection<TSchema>(db: mongodb.Db): mongodb.Collection<TSchema>;

  // Merge MongoDb JSON bulk operation results into a single one
  static mergeBulkOperationResults(
    resultA: DataMigration.BulkOperation,
    resultB: DataMigration.BulkOperation,
  ): DataMigration.BulkOperation;

  // Returns a bulk and initialized result object to batch operations
  static getBulk<TSchema>(
    collection: mongodb.Collection<TSchema>,
  ): Promise<DataMigration.Bulk>;

  // Effectively execute bulk operations and returns the merged results after having log a progress message
  doBulk(
    bulk: DataMigration.Bulk,
    result: DataMigration.Bulk,
    message: string,
    doIt: boolean,
  ): DataMigration.BulkOperation;

  // Performs the migration
  // Steps:
  // 1. Make the backup of the data
  // 2. After the backup is done, execute the bulk operation
  update(db: mongodb.Db, doIt: boolean): Promise<DataMigration.BulkOperation>;

  // Build the rollback update based on existing filtered document and the corresponding update query
  getRollbackUpdate<T>(obj: Promise<T | null>): RollBackUpdateObject;

  // Performs the migration rollback
  rollback(db: mongodb.Db, doIt: boolean): Promise<DataMigration.BulkOperation>;

  // Remove migration flags from the documents
  clean(db: mongodb.Db, doIt: boolean): Promise<any>;
}

declare namespace DataMigration {
  export interface Options<TSchema> {
    maxBulkSize?: number;
    delayBetweenBatches?: number;
    continueOnFailure?: boolean;
    filter?: (obj: object) => object;
    rollback?: (arg: TSchema) => Promise<mongodb.FilterQuery<TSchema>>;
  }

  export interface Bulk {
    bulk: mongodb.UnorderedBulkOperation;
    result: BulkOperation;
  }

  export interface BulkOperation {
    ok: number;
    writeErrors: string[];
    writeConcernErrors: string[];
    insertedIds: string[];
    nInserted: number;
    nUpserted: number;
    nMatched: number;
    nModified: number;
    nRemoved: number;
    upserted: string[];
  }
}