import * as mongodb from 'mongodb';
import { EventEmitter } from 'events';

export default MongoDbConnector;

type MongoDbList = Map<string, mongodb.Db>;

declare class MongoDbConnector extends EventEmitter {
  config: MongoDbConnector.Config;
  DATABASES: MongoDbList;
  MODELS: MongoDbConnector.Models;
  MIGRATIONS: Map<string, MongoDbConnector.Migration>;

  constructor(
    config: MongoDbConnector.Config,
    models?: MongoDbConnector.Models,
    migrations?: Map<string, MongoDbConnector.Migration>,
  );

  // Remove the info.uuid of a collection object
  static removeCollectionInfoUuid(
    collection: mongodb.Collection,
  ): mongodb.Collection;

  // Connect the database
  connect(): Promise<MongoDbList>;

  // Disconnect the database
  disconnect(): Promise<MongoDbList>;

  // Returns a database connection
  db(databaseName: string): mongodb.Db;

  // Returns the full information about a database
  state(databaseName: string): Promise<MongoDbConnector.DatabaseState>;

  states(): Promise<MongoDbConnector.DatabaseState[]>;

  //  Initialize the different collections based on the models definitions.
  init(models: MongoDbConnector.Models): Promise<void>;

  // Initializes a database model
  initModel(model: MongoDbConnector.ModelDefinition): Promise<boolean>;

  // MIGRATIONS
  checkDirection(direction: MongoDbConnector.MigrationDirectionType): void;

  // Apply a single migration
  applyMigration(
    direction: MongoDbConnector.MigrationDirectionType,
    migration: string,
  ): Promise<boolean>;

  // Apply all migrations sequentially
  applyAllMigrations(
    direction: MongoDbConnector.MigrationDirectionType,
  ): Promise<boolean>;

  // Apply collection definitions from models
  applyModels(
    direction: MongoDbConnector.MigrationDirectionType,
  ): Promise<boolean>;

  // Apply a migration to the database
  migrate(
    direction: MongoDbConnector.MigrationDirectionType,
    migration: MongoDbConnector.MigrationType | null,
  ): Promise<MongoDbConnector.MigrateResult>;

  // Apply migrations until a specific version included
  migrateUntil(
    direction: MongoDbConnector.MigrationDirectionType,
    migration: MongoDbConnector.MigrationType | null,
  ): Promise<MongoDbConnector.MigrateResult>;

  // Returns the helpers for applying migrations onto a database
  getMigrationHelper(
    helperName: MongoDbConnector.HelperType,
  ): MongoDbConnector.MigrationHelper;

  // Check equity between models definitions and migrations attached to the connector
  checkDangerouslyMigrationsAndModelsEquality(): mongodb.Db;

  // Check that each migration is effectively rollbackable.
  checkDangerouslyMigrationsRollbackability(): mongodb.Db;
}

declare namespace MongoDbConnector {
  export interface Config {
    databases: DatabaseConfig[];
    ensureIndexInBackground: boolean;
  }

  export interface DatabaseConfig {
    name: string;
    url: string;
    options?: mongodb.MongoClientOptions;
  }

  export interface DatabaseState {
    name: string;
    collections: CollectionInfo[];
    collectionIndexes: CursorFirstBatch[];
  }

  export interface Models {
    [key: string]: ModelDefinition;
  }

  /**
   * Example
   *  cursor: {
   *    id: 0,
   *    ns: 'test.$cmd.listIndexes.collectionName',
   *    firstBatch: [ CursorFirstBatch, CursorFirstBatch, CursorFirstBatch ]
   *  },
   *  ok: 1
   */
  export interface ListIndexesCursor {
    cursor: ListIndexCursor;
    ok: number;
  }

  export interface ListIndexCursor {
    id: number;
    ns: string;
    firstBatch: CursorFirstBatch[];
  }

  /**
   * Example
   * [ [ { v: 2, key: { _id: 1 }, name: '_id_', ns: 'dbName.collectionName' },
   * { v: 2,
   *     key: { date: 1 },
   *     name: 'date_1',
   *     ns: 'dbName.collectionName',
   *     expireAfterSeconds: 3600,
   *     background: true },
   * { v: 2,
   *      key: { processed: 1 },
   *      name: 'processed_1',
   *     ns: 'dbName.collectionName',
   *     background: true } ] ] }
   */
  export interface CursorFirstBatch {
    v: number;
    key: {
      date?: number;
      processed?: number;
    };
    name: string;
    ns: string;
    expireAfterSeconds?: number;
    background?: boolean;
  }

  export interface CollectionInfo {
    name: string;
    type: string;
    options: object;
    info: {
      readonly?: boolean;
      uuid: string;
    } | null;
    idIndex: CursorFirstBatch;
  }

  export interface ModelDefinition {
    DATABASE: string;
    COLLECTION: string;
    COLLECTION_OPTIONS: {
      capped?: boolean;
      max?: number;
      size?: number;
    };
    INDEXES: object[][];
    VALIDATOR_SCHEMA: any;
    VALIDATOR_OPTIONS: any;
  }

  export interface Migration {
    update(mongodbConnector?: MongoDbConnector): Promise<boolean>;
    rollback(mongodbConnector?: MongoDbConnector): Promise<boolean>;
  }

  export enum MigrationDirectionType {
    MIGRATION_UPDATE = 'update',
    MIGRATION_ROLLBACK = 'rollback',
  }

  export enum MigrationType {
    INIT = 'init',
    FROM_MODELS = 'from-models',
    ALL = 'all',
  }

  export interface MigrateResult {
    before: DatabaseState[];
    after: DatabaseState[];
  }

  export enum HelperType {
    CREATE_COLLECTION = 'createCollection',
    CREATE_INDEX = 'createIndex',
    DROP_COLLECTION = 'dropCollection',
    DROP_INDEX = 'dropIndex',
    UPDATE_VALIDATOR = 'updateValidator',
  }

  // createCollection, updateValidator
  export interface MigrationHelper {
    update(
      databaseName: string,
      collectionName: string,
      validator: object,
      validatorOptions: object,
    ): Promise<boolean>;
    rollback(databaseName: string, collectionName: string): Promise<boolean>;
  }

  // createIndex, dropIndex
  export interface MigrationHelper {
    update(
      databaseName: string,
      collectionName: string,
      indexName: string,
      indexKeys: object,
      indexOptions: object,
    ): Promise<boolean>;
    rollback(
      databaseName: string,
      collectionName: string,
      indexName: string,
      indexKeys: object,
      indexOptions: object,
    ): Promise<boolean>;
  }

  // dropCollection, createCollection without validator
  export interface MigrationHelper {
    update(databaseName: string, collectionName: string): Promise<boolean>;
    rollback(databaseName: string, collectionName: string): Promise<boolean>;
  }
}