/** @import { PseudoDocumentMetadata, BasePseudoDocument } from "./_types" */

/**@implements {BasePseudoDocument}*/
export default class BasePseudoDocument extends foundry.abstract.DataModel {
  /**
   * Pseudo-document metadata.
   * @type {PseudoDocumentMetadata}
   */
  static get metadata() {
    return {
      name: null,
      label: "",
      icon: "",
      embedded: {},
      sheetClass: null,
      defaultArtwork: foundry.documents.Item.DEFAULT_ICON,
    };
  }

  /** @override */
  static LOCALIZATION_PREFIXES = ["DOCUMENT"];

  /** @inheritdoc */
  static defineSchema() {
    const { fields } = foundry.data;

    return {
      _id: new fields.DocumentIdField({ initial: () => foundry.utils.randomID() }),
      name: new fields.StringField({ required: true, blank: false, textSearch: true }),
      img: new fields.FilePathField({ categories: ["IMAGE"], initial: this.metadata.defaultArtwork }),
      description: new fields.HTMLField({ textSearch: true }),
    };
  }

  /* -------------------------------------------- */
  /*  Instance Properties                         */
  /* -------------------------------------------- */

  /**
   * The id of this pseudo-document.
   * @type {string}
   */
  get id() {
    return this._id;
  }

  /* -------------------------------------------- */

  /**
   * The uuid of this document.
   * @type {string}
   */
  get uuid() {
    let parent = this.parent;
    while (!(parent instanceof BasePseudoDocument) && !(parent instanceof foundry.abstract.Document)) parent = parent.parent;
    return [parent.uuid, this.constructor.metadata.name, this.id].join(".");
  }

  /* -------------------------------------------- */

  /**
   * The parent document of this pseudo-document.
   * @type {Document}
   */
  get document() {
    let parent = this;
    while (!(parent instanceof foundry.abstract.Document)) parent = parent.parent;
    return parent;
  }

  /* -------------------------------------------- */

  /**
   * Item to which this PseudoDocument belongs, if applicable.
   * @type {foundry.documents.Item|null}
   */
  get item() {
    return this.parent?.parent instanceof Item ? this.parent.parent : null;
  }

  /* -------------------------------------------- */

  /**
   * Actor to which this PseudoDocument's item belongs, if the item is embedded.
   * @type {foundry.documents.Actor|null}
   */
  get actor() {
    return this.item?.parent ?? null;
  }

  /* -------------------------------------------- */

  /**
   * The property path to this pseudo document relative to its parent document.
   * @type {string}
   */
  get fieldPath() {
    const fp = this.schema.fieldPath;
    let path = fp.slice(0, fp.lastIndexOf("element") - 1);

    if (this.parent instanceof BasePseudoDocument) {
      path = [this.parent.fieldPath, this.parent.id, path].join(".");
    }

    return path;
  }

  /* -------------------------------------------- */
  /*  Embedded Document Methods                   */
  /* -------------------------------------------- */

  /**
   * Retrieve an embedded pseudo-document.
   * @param {string} embeddedName         The document name of the embedded pseudo-document.
   * @param {string} id                   The id of the embedded pseudo-document.
   * @param {object} [options]            Retrieval options.
   * @param {boolean} [options.invalid]   Retrieve an invalid pseudo-document?
   * @param {boolean} [options.strinct]   Throw an error if the embedded pseudo-document does not exist?
   * @returns {PseudoDocument|null}
   */
  getEmbeddedDocument(embeddedName, id, { invalid = false, strict = false } = {}) {
    const embeds = this.constructor.metadata.embedded ?? {};
    if (embeddedName in embeds) {
      const path = `${embeds[embeddedName]}.${id}`;
      return foundry.utils.getProperty(this, path) ?? null;
    }
    return null;
  }


  /* -------------------------------------------- */
  /*  CRUD Operations                             */
  /* -------------------------------------------- */

  /**
     * Does this pseudo-document exist in the document's source?
     * @type {boolean}
     */
  get isSource() {
    const source = foundry.utils.getProperty(this.document._source, this.fieldPath);
    if (foundry.utils.getType(source) !== "Object") {
      throw new Error("Source is not an object!");
    }
    return this.id in source;
  }

  /**
   * Create a new instance of this pseudo-document.
   * @param {object} [data]                                 The data used for the creation.
   * @param {object} operation                              The context of the update operation.
   * @param {foundry.abstract.Document} operation.parent    The parent of this document.
   * @returns {Promise<foundry.abstract.Document>}          A promise that resolves to the updated document.
   */
  static async create(data = {}, { parent, ...operation } = {}) {
    if (!parent) {
      throw new Error("A parent document must be specified for the creation of a pseudo-document!");
    }
    const id = operation.keepId && foundry.data.validators.isValidId(data._id) ? data._id : foundry.utils.randomID();

    const fieldPath = parent.system.constructor.metadata.embedded?.[this.metadata.name];
    if (!fieldPath) {
      throw new Error(`A ${parent.documentName} of type '${parent.type}' does not support ${this.metadata.name}!`);
    }

    const update = { [`system.${fieldPath}.${id}`]: { ...data, _id: id } };
    return parent.update(update, operation);
  }


  /**
   * Delete this pseudo-document.
   * @param {object} [operation]                      The context of the operation.
   * @returns {Promise<foundry.abstract.Document>}    A promise that resolves to the updated document.
   */
  async delete(operation = {}) {
    if (!this.isSource) throw new Error("You cannot delete a non-source pseudo-document!");
    const update = { [`${this.fieldPath}.-=${this.id}`]: null };
    return this.document.update(update, operation);
  }

  /**
   * Duplicate this pseudo-document.
   * @returns {Promise<foundry.abstract.Document>}    A promise that resolves to the updated document.
   */
  async duplicate() {
    if (!this.isSource) throw new Error("You cannot duplicate a non-source pseudo-document!");
    const docData = foundry.utils.mergeObject(this.toObject(), {
      name: game.i18n.format("DOCUMENT.CopyOf", { name: this.name }),
    });
    return this.constructor.create(docData, { parent: this.document });
  }

  /**
 * Update this pseudo-document.
 * @param {object} [change]                         The change to perform.
 * @param {object} [operation]                      The context of the operation.
 * @returns {Promise<foundry.abstract.Document>}    A promise that resolves to the updated document.
 */
  async update(change = {}, operation = {}) {
    if (!this.isSource) throw new Error("You cannot update a non-source pseudo-document!");
    const path = [this.fieldPath, this.id].join(".");
    const update = { [path]: change };
    return this.document.update(update, operation);
  }

}