import { Observable } from "rxjs";

/**
 * An implementation of this abstract class provides functions for direct database access.
 * This interface is an extension of the [PouchDB API](https://pouchdb.com/api.html).
 *
 * PLEASE NOTE:
 * Direct access to the Database layer is rarely necessary, and you should probably use EntityMapperService instead.
 * Database is not an Angular Service and has to be accessed through the DatabaseResolverService.
 */
export abstract class Database {
  constructor(protected dbName: string) {}

  /**
   * Initialize the database fully after its initial creation,
   * e.g. once user details are available.
   * @param dbName A special database name, if different from the default name passed in the constructor
   */
  abstract init(dbName?: string);

  /**
   * Whether the database is already initialized and ready for use.
   */
  abstract isInitialized(): boolean;

  /**
   * Load a single document by id from the database.
   * @param id The primary key of the document to be loaded
   * @param options Optional options for the database engine (PouchDB)
   */
  abstract get(id: string, options?: GetOptions): Promise<any>;

  /**
   * Load all documents (matching the given PouchDB options) from the database.
   *
   * Normally you should rather use "getAll()" or another well typed method of this class
   * instead of passing PouchDB specific options here
   * because that will make your code tightly coupled with PouchDB rather than any other database provider.
   *
   * @param options PouchDB options object as in the normal PouchDB library
   */
  abstract allDocs(options?: GetAllOptions): Promise<any>;

  /**
   * Save a document to the database.
   * @param object The document to be saved
   * @param forceUpdate (Optional) Whether conflicts should be ignored and an existing conflicting document forcefully overwritten.
   */
  abstract put(object: any, forceUpdate?: boolean): Promise<any>;

  /**
   * Save a bunch of documents at once to the database
   * @param objects The documents to be saved
   * @param forceUpdate (Optional) Whether conflicts should be ignored and existing conflicting documents forcefully overwritten.
   * @returns array holding success responses or errors depending on the success of the operation
   */
  abstract putAll(objects: any[], forceUpdate?: boolean): Promise<any[]>;

  /**
   * Delete a document from the database
   * @param object The document to be deleted (usually this object must at least contain the _id and _rev)
   */
  abstract remove(object: any): Promise<any>;

  /**
   * Query data from the database based on a more complex, indexed request.
   *
   * This is directly calling the PouchDB implementation of this function.
   * Also see the documentation there: {@link https://pouchdb.com/api.html#query_database}
   *
   * @param fun The name of a previously saved database index
   * @param options Additional options for the query, like a `key`. See the PouchDB docs for details.
   */
  abstract query(fun: any, options?: QueryOptions): Promise<any>;

  /**
   * Create a database index to `query()` certain data more efficiently in the future.
   *
   * Also see the PouchDB documentation regarding indices and queries: {@link https://pouchdb.com/api.html#query_database}
   *
   * @param designDoc The PouchDB style design document for the map/reduce query
   */
  abstract saveDatabaseIndex(designDoc: any): Promise<any>;

  /**
   * Load all documents (with the given prefix) from the database.
   * @param prefix The string prefix of document ids that should be retrieved
   */
  getAll(prefix = ""): Promise<Array<any>> {
    return this.allDocs({
      include_docs: true,
      startkey: prefix,
      endkey: prefix + "\ufff0",
    });
  }

  /**
   * @returns true if there are no documents in the database
   */
  abstract isEmpty(): Promise<boolean>;

  /**
   * Closes open connections and un-initializes the database
   * (without deleting persisted data, see destroy() for that)
   */
  abstract reset(): Promise<any>;

  /**
   * Closes all open connections to the database base and destroys it (clearing all data)
   */
  abstract destroy(): Promise<any>;

  abstract changes(): Observable<DatabaseDocChange>;
}

/**
 * Based upon PouchDb changes feed format.
 */
export interface DatabaseDocChange {
  _id: string;
  _rev: string;
  _deleted?: boolean;

  [key: string]: any;
}

/**
 * Basic query options supported by {@link Database}.
 *
 * also see https://pouchdb.com/guides/queries.html
 */
export type QueryOptions = PouchDB.Query.Options<any, any>;

/**
 * Basic database read options supported by {@link Database}.
 *
 * also see https://pouchdb.com/api.html#fetch_document
 */
export type GetAllOptions =
  | PouchDB.Core.AllDocsWithKeyOptions
  | PouchDB.Core.AllDocsWithKeysOptions
  | PouchDB.Core.AllDocsWithinRangeOptions
  | PouchDB.Core.AllDocsOptions;

/**
 * Basic database read options supported by {@link Database}.
 *
 * also see https://pouchdb.com/api.html#fetch_document
 */
export type GetOptions = PouchDB.Core.GetOptions;