import { Assertion, Orbit } from '@orbit/core';
import {
  DefaultRequestOptions,
  FullRequestOptions,
  FullResponse,
  queryable,
  RequestOptions,
  Resettable,
  ResponseHints,
  syncable,
  updatable
} from '@orbit/data';
import { RecordCacheUpdateDetails } from '@orbit/record-cache';
import {
  coalesceRecordOperations,
  RecordOperation,
  RecordOperationResult,
  RecordQuery,
  RecordQueryable,
  RecordQueryBuilder,
  RecordQueryExpressionResult,
  RecordQueryResult,
  RecordSource,
  RecordSourceQueryOptions,
  RecordSourceSettings,
  RecordSyncable,
  RecordTransform,
  RecordTransformBuilder,
  RecordTransformResult,
  RecordUpdatable
} from '@orbit/records';
import { Dict, toArray } from '@orbit/utils';
import {
  MemoryCache,
  MemoryCacheClass,
  MemoryCacheSettings
} from './memory-cache';

const { assert, deprecate } = Orbit;

export interface MemorySourceSettings<
  QO extends RequestOptions = RecordSourceQueryOptions,
  TO extends RequestOptions = RequestOptions,
  QB = RecordQueryBuilder,
  TB = RecordTransformBuilder,
  QRD = unknown,
  TRD extends RecordCacheUpdateDetails = RecordCacheUpdateDetails
> extends RecordSourceSettings<QO, TO, QB, TB> {
  base?: MemorySource<QO, TO, QB, TB, QRD, TRD>;
  cacheClass?: MemoryCacheClass<QO, TO, QB, TB, QRD, TRD>;
  cacheSettings?: Partial<MemoryCacheSettings<QO, TO, QB, TB, QRD, TRD>>;
}

export interface MemorySourceMergeOptions {
  coalesce?: boolean;

  /**
   * @deprecated since v0.17
   */
  sinceTransformId?: string;

  /**
   * @deprecated since v0.17, include transform options alongside merge options instead
   */
  transformOptions?: RequestOptions;
}

export interface MemorySource<
  QO extends RequestOptions = RecordSourceQueryOptions,
  TO extends RequestOptions = RequestOptions,
  QB = RecordQueryBuilder,
  TB = RecordTransformBuilder,
  QRD = unknown,
  TRD extends RecordCacheUpdateDetails = RecordCacheUpdateDetails
> extends RecordSource<QO, TO, QB, TB>,
    RecordSyncable,
    RecordQueryable<QRD, QB, QO>,
    RecordUpdatable<TRD, TB, TO> {}

@syncable
@queryable
@updatable
export class MemorySource<
    QO extends RequestOptions = RecordSourceQueryOptions,
    TO extends RequestOptions = RequestOptions,
    QB = RecordQueryBuilder,
    TB = RecordTransformBuilder,
    QRD = unknown,
    TRD extends RecordCacheUpdateDetails = RecordCacheUpdateDetails
  >
  extends RecordSource<QO, TO, QB, TB>
  implements
    RecordSyncable,
    RecordQueryable<QRD, QB, QO>,
    RecordUpdatable<TRD, TB, TO>,
    Resettable {
  protected _cache: MemoryCache<QO, TO, QB, TB, QRD, TRD>;
  protected _base?: MemorySource<QO, TO, QB, TB, QRD, TRD>;
  protected _forkPoint?: string;
  protected _transforms: Dict<RecordTransform>;
  protected _transformInverses: Dict<RecordOperation[]>;

  constructor(settings: MemorySourceSettings<QO, TO, QB, TB, QRD, TRD>) {
    const { keyMap, schema, base } = settings;

    settings.name = settings.name ?? 'memory';

    super(settings);

    this._transforms = {};
    this._transformInverses = {};

    this.transformLog.on('clear', this._logCleared.bind(this));
    this.transformLog.on('truncate', this._logTruncated.bind(this));
    this.transformLog.on('rollback', this._logRolledback.bind(this));

    let cacheSettings: Partial<MemoryCacheSettings<QO, TO, QB, TB, QRD, TRD>> =
      settings.cacheSettings ?? {};
    cacheSettings.schema = schema;
    cacheSettings.keyMap = keyMap;
    cacheSettings.queryBuilder ??= this.queryBuilder;
    cacheSettings.transformBuilder ??= this.transformBuilder;
    cacheSettings.defaultQueryOptions ??= this.defaultQueryOptions;
    cacheSettings.defaultTransformOptions ??= this.defaultTransformOptions;
    cacheSettings.autoValidate ??= settings.autoValidate;

    if (
      cacheSettings.autoValidate !== false &&
      cacheSettings.validatorFor === undefined &&
      cacheSettings.validators === undefined
    ) {
      cacheSettings.validatorFor = this._validatorFor;
    }

    if (base) {
      this._base = base;
      this._forkPoint = base.transformLog.head;
      cacheSettings.base = base.cache;
    }

    const cacheClass = settings.cacheClass ?? MemoryCache;
    this._cache = new cacheClass(
      cacheSettings as MemoryCacheSettings<QO, TO, QB, TB, QRD, TRD>
    );
  }

  get cache(): MemoryCache<QO, TO, QB, TB, QRD, TRD> {
    return this._cache;
  }

  get base(): MemorySource<QO, TO, QB, TB, QRD, TRD> | undefined {
    return this._base;
  }

  get forkPoint(): string | undefined {
    return this._forkPoint;
  }

  async upgrade(): Promise<void> {
    this._cache.upgrade();
  }

  /////////////////////////////////////////////////////////////////////////////
  // Syncable interface implementation
  /////////////////////////////////////////////////////////////////////////////

  async _sync(transform: RecordTransform): Promise<void> {
    if (!this.transformLog.contains(transform.id)) {
      this._applyTransform(transform);
      await this.transformed([transform]);
    }
  }

  /////////////////////////////////////////////////////////////////////////////
  // Updatable interface implementation
  /////////////////////////////////////////////////////////////////////////////

  async _update(
    transform: RecordTransform,
    hints?: ResponseHints<RecordTransformResult, TRD>
  ): Promise<FullResponse<RecordTransformResult, TRD, RecordOperation>> {
    let results: RecordTransformResult;
    const response: FullResponse<
      RecordTransformResult,
      TRD,
      RecordOperation
    > = {};

    if (!this.transformLog.contains(transform.id)) {
      results = this._applyTransform(transform);
      response.transforms = [transform];
    }

    if (hints?.data) {
      if (Array.isArray(transform.operations)) {
        assert(
          'MemorySource#update: `hints.data` must be an array if `transform.operations` is an array',
          Array.isArray(hints.data)
        );

        response.data = (hints.data as RecordOperationResult[]).map((h) =>
          this._retrieveOperationResult(h)
        );
      } else {
        response.data = this._retrieveOperationResult(
          hints.data as RecordOperationResult
        );
      }
    } else if (results) {
      response.data = results;
    }

    if (hints?.details) {
      response.details = hints.details;
    }

    return response;
  }

  /////////////////////////////////////////////////////////////////////////////
  // Queryable interface implementation
  /////////////////////////////////////////////////////////////////////////////

  async _query(
    query: RecordQuery,
    hints?: ResponseHints<RecordQueryResult, QRD>
  ): Promise<FullResponse<RecordQueryResult, QRD, RecordOperation>> {
    let response: FullResponse<RecordQueryResult, QRD, RecordOperation>;

    if (hints?.data) {
      response = {};
      if (Array.isArray(query.expressions)) {
        assert(
          'MemorySource#query: `hints.data` must be an array if `query.expressions` is an array',
          Array.isArray(hints.data)
        );

        response.data = (hints.data as RecordQueryExpressionResult[]).map((h) =>
          this._retrieveQueryExpressionResult(h)
        );
      } else {
        response.data = this._retrieveQueryExpressionResult(
          hints.data as RecordQueryExpressionResult
        );
      }
    } else {
      response = this._cache.query(query, {
        fullResponse: true
      } as FullRequestOptions<QO>);
    }

    if (hints?.details) {
      response.details = hints.details;
    }

    return response;
  }

  /////////////////////////////////////////////////////////////////////////////
  // Public methods
  /////////////////////////////////////////////////////////////////////////////

  /**
   * Create a clone, or "fork", from a "base" source.
   *
   * The forked source will have the same `schema` and `keyMap` as its base source.
   * The forked source's cache will start with the same immutable document as
   * the base source. Its contents and log will evolve independently.
   *
   * @returns The forked source.
   */
  fork(
    settings: Partial<MemorySourceSettings<QO, TO, QB, TB, QRD, TRD>> = {}
  ): MemorySource<QO, TO, QB, TB, QRD, TRD> {
    // required settings
    settings.base = this;
    settings.schema = this.schema;
    settings.keyMap = this.keyMap;

    // customizable settings
    settings.queryBuilder ??= this._queryBuilder;
    settings.transformBuilder ??= this._transformBuilder;
    settings.defaultQueryOptions ??= this._defaultQueryOptions;
    settings.defaultTransformOptions ??= this._defaultTransformOptions;
    if (settings.autoValidate !== false) {
      settings.validatorFor ??= this._validatorFor;
      if (
        settings.autoValidate === undefined &&
        settings.validatorFor === undefined
      ) {
        settings.autoValidate = false;
      }
    }

    return new MemorySource<QO, TO, QB, TB, QRD, TRD>(
      settings as MemorySourceSettings<QO, TO, QB, TB, QRD, TRD>
    );
  }

  /**
   * Merge transforms from a forked source back into a base source.
   *
   * By default, all of the operations from all of the transforms in the forked
   * source's history will be reduced into a single transform. A subset of
   * operations can be selected by specifying the `sinceTransformId` option.
   *
   * The `coalesce` option controls whether operations are coalesced into a
   * minimal equivalent set before being reduced into a transform.
   *
   * @param forkedSource - The source to merge.
   * @param options - Merge options
   * @returns The result of calling `update()` with the forked transforms.
   */
  merge<RequestData extends RecordTransformResult = RecordTransformResult>(
    forkedSource: MemorySource<QO, TO, QB, TB, QRD, TRD>,
    options?: DefaultRequestOptions<TO> & MemorySourceMergeOptions
  ): Promise<RequestData>;
  merge<RequestData extends RecordTransformResult = RecordTransformResult>(
    forkedSource: MemorySource<QO, TO, QB, TB, QRD, TRD>,
    options: FullRequestOptions<TO> & MemorySourceMergeOptions
  ): Promise<FullResponse<RequestData, TRD, RecordOperation>>;
  async merge<
    RequestData extends RecordTransformResult = RecordTransformResult
  >(
    forkedSource: MemorySource<QO, TO, QB, TB, QRD, TRD>,
    options?: TO & MemorySourceMergeOptions
  ): Promise<
    RecordTransformResult | FullResponse<RequestData, TRD, RecordOperation>
  > {
    let { coalesce, sinceTransformId, transformOptions, ...remainingOptions } =
      options ?? {};

    let requestOptions: TO;
    if (transformOptions) {
      deprecate(
        'In MemorySource#merge, passing `transformOptions` nested within `options` is deprecated. Instead, include them directly alongside other options.'
      );
      requestOptions = transformOptions as TO;
    } else {
      requestOptions = (remainingOptions ?? {}) as TO;
    }

    let ops: RecordOperation[] = [];

    if (forkedSource.cache.isTrackingUpdateOperations) {
      ops = forkedSource.cache.getAllUpdateOperations();
    } else {
      let transforms: RecordTransform[];
      if (sinceTransformId) {
        deprecate(
          'In MemorySource#merge, passing `sinceTransformId` is deprecated. Instead, call `update` with a custom transform/operations.'
        );
        transforms = forkedSource.getTransformsSince(sinceTransformId);
      } else {
        transforms = forkedSource.getAllTransforms();
      }

      transforms.forEach((t) => {
        Array.prototype.push.apply(ops, toArray(t.operations));
      });
    }

    if (coalesce !== false) {
      ops = coalesceRecordOperations(ops);
    }

    if (requestOptions.fullResponse) {
      return this.update<RequestData>(
        ops,
        requestOptions as FullRequestOptions<TO>
      );
    } else {
      return this.update<RequestData>(
        ops,
        requestOptions as DefaultRequestOptions<TO>
      );
    }
  }

  /**
   * Rebase works similarly to a git rebase:
   *
   * After a source is forked, there is a parent- and a child-source. Both may
   * be updated with transforms. When `childSource.rebase()` is called, the
   * child source's state will be reset to match the current state of its
   * parent, and then any locally made transforms will be replayed on the child
   * source.
   */
  rebase(): void {
    const base = this._base;

    if (!base) {
      throw new Assertion(
        'A `base` source must be defined for `rebase` to work'
      );
    }

    // reset the state of the cache to match the base cache
    this.cache.reset();

    // replay all locally made transforms
    this.getAllTransforms().forEach((t) => this._applyTransform(t));

    // reset the fork point
    this._forkPoint = base.transformLog.head;
  }

  /**
   * Reset the source's cache and transform log to its initial state, which will
   * be either empty or a matching its `base`, if it has one.
   */
  async reset(): Promise<void> {
    // reset the state of the cache (which will match a base cache, if present)
    this.cache.reset();

    // reset the fork point
    this._forkPoint = this._base ? this._base.transformLog.head : undefined;

    // clear the transform log, which in turn will clear any tracked transforms
    await this.transformLog.clear();
  }

  /**
   * Rolls back the source to a particular `transformId`.
   *
   * `relativePosition` can be a positive or negative integer used to specify a
   * position relative to `transformId`.
   */
  rollback(transformId: string, relativePosition = 0): Promise<void> {
    return this.transformLog.rollback(transformId, relativePosition);
  }

  /**
   * Returns all logged transforms since a particular `transformId`.
   */
  getTransformsSince(transformId: string): RecordTransform[] {
    return this.transformLog
      .after(transformId)
      .map((id) => this._transforms[id]);
  }

  /**
   * @deprecated since v0.17, call `getTransformsSince` instead
   */
  transformsSince(transformId: string): RecordTransform[] {
    deprecate(
      'MemorySource#transformsSince has been deprecated. Please call `source.getTransformsSince(tranformId)` instead.'
    );
    return this.getTransformsSince(transformId);
  }

  /**
   * Returns all logged transforms.
   */
  getAllTransforms(): RecordTransform[] {
    return this.transformLog.entries.map((id) => this._transforms[id]);
  }

  /**
   * @deprecated since v0.17, call `getAllTransforms` instead
   */
  allTransforms(): RecordTransform[] {
    deprecate(
      'MemorySource#allTransforms has been deprecated. Please call `source.getAllTransforms()` instead.'
    );
    return this.getAllTransforms();
  }

  getTransform(transformId: string): RecordTransform {
    return this._transforms[transformId];
  }

  getInverseOperations(transformId: string): RecordOperation[] {
    return this._transformInverses[transformId];
  }

  get defaultQueryOptions(): DefaultRequestOptions<QO> | undefined {
    return super.defaultQueryOptions;
  }

  set defaultQueryOptions(options: DefaultRequestOptions<QO> | undefined) {
    super.defaultQueryOptions = this._cache.defaultQueryOptions = options;
  }

  get defaultTransformOptions(): DefaultRequestOptions<TO> | undefined {
    return super.defaultTransformOptions;
  }

  set defaultTransformOptions(options: DefaultRequestOptions<TO> | undefined) {
    this._defaultTransformOptions = this._cache.defaultTransformOptions = options;
  }

  /////////////////////////////////////////////////////////////////////////////
  // Protected methods
  /////////////////////////////////////////////////////////////////////////////

  protected _retrieveQueryExpressionResult(
    result: RecordQueryExpressionResult
  ): RecordQueryExpressionResult {
    if (Array.isArray(result)) {
      return this._cache.getRecordsSync(result);
    } else if (result) {
      return this._cache.getRecordSync(result);
    } else {
      return result;
    }
  }

  protected _retrieveOperationResult(
    result: RecordOperationResult
  ): RecordOperationResult {
    if (result) {
      return this._cache.getRecordSync(result);
    } else {
      return result;
    }
  }

  protected _applyTransform(transform: RecordTransform): RecordTransformResult {
    const { data, details } = this.cache.update(transform, {
      fullResponse: true
    } as FullRequestOptions<TO>);
    this._transforms[transform.id] = transform;
    this._transformInverses[transform.id] = details?.inverseOperations ?? [];
    return data;
  }

  protected _clearTransformFromHistory(transformId: string): void {
    delete this._transforms[transformId];
    delete this._transformInverses[transformId];
  }

  protected _logCleared(): void {
    this._transforms = {};
    this._transformInverses = {};
  }

  protected _logTruncated(
    transformId: string,
    relativePosition: number,
    removed: string[]
  ): void {
    removed.forEach((id) => this._clearTransformFromHistory(id));
  }

  protected _logRolledback(
    transformId: string,
    relativePosition: number,
    removed: string[]
  ): void {
    removed.reverse().forEach((id) => {
      const inverseOperations = this._transformInverses[id];
      if (inverseOperations) {
        this.cache.update(inverseOperations);
      }
      this._clearTransformFromHistory(id);
    });
  }
}