import { destroy, isAlive, types } from "mobx-state-tree";
import { defaultStyle } from "../core/Constants";
import { guidGenerator } from "../core/Helpers";
import Result from "../regions/Result";
import { PER_REGION_MODES } from "./PerRegion";
import { ReadOnlyRegionMixin } from "./ReadOnlyMixin";
import { FF_LSDV_4930, FF_TAXONOMY_LABELING, isFF } from "../utils/feature-flags";

let ouid = 1;

export const AreaMixinBase = types
  .model({
    id: types.optional(types.identifier, guidGenerator),
    ouid: types.optional(types.number, () => ouid++),
    results: types.array(Result),
    parentID: types.maybeNull(types.string),
  })
  .views((self) => ({
    // self id without annotation id added to uniquiness across all the tree
    get cleanId() {
      return self.id.replace(/#.*/, "");
    },

    /**
     * @return {Result[]} all results with labeling (created by *Labels control)
     */
    get labelings() {
      return self.results.filter((r) => r.from_name.isLabeling);
    },

    /**
     * @return {Result?} first result with labels (usually it's the only one, but not always)
     */
    get labeling() {
      if (!isAlive(self)) {
        return undefined;
      }
      return self.results.find((r) => r.from_name.isLabeling && r.hasValue);
    },

    get emptyLabel() {
      return self.results.find((r) => r.from_name?.emptyLabel)?.from_name?.emptyLabel;
    },

    get texting() {
      return isAlive(self) && self.results.find((r) => r.type === "textarea" && r.hasValue);
    },

    get tag() {
      return self.labeling?.from_name;
    },

    hasLabel(value) {
      const labels = self.labeling?.mainValue;

      if (!labels || !value) return false;
      // label can contain comma, so check for full match first
      if (labels.includes(value)) return true;
      if (value.includes(",")) {
        return value.split(",").some((v) => labels.includes(v));
      }
      return false;
    },

    get perRegionTags() {
      return self.annotation.toNames.get(self.object.name)?.filter((tag) => tag.perregion) || [];
    },

    // special tags that can be used for labeling (only <Taxonomy isLabeling/> for now)
    get labelingTags() {
      if (!isFF(FF_TAXONOMY_LABELING)) return [];

      return self.annotation.toNames.get(self.object.name)?.filter((tag) => tag.classification && tag.isLabeling) || [];
    },

    get perRegionDescControls() {
      return self.perRegionTags.filter((tag) => tag.displaymode === PER_REGION_MODES.REGION_LIST);
    },

    get perRegionFocusTarget() {
      return self.perRegionTags.find((tag) => tag.isVisible !== false && tag.focusable);
    },

    get labelName() {
      if (!isAlive(self)) {
        return void 0;
      }
      return self.labeling?.mainValue?.[0] || self.emptyLabel?._value;
    },

    get labels() {
      return Array.from(self.labeling?.mainValue ?? []);
    },

    // used only in labels on regions for Image and Video tags
    getLabelText(joinstr) {
      const index = self.region_index;
      const label = self.labeling;
      const text = self.texting?.mainValue?.[0]?.replace(/\n\r|\n/, " ");
      const labelNames = label?.getSelectedString(joinstr);
      const labelText = [];

      if (index) labelText.push(String(index));
      if (labelNames) labelText.push(labelNames);
      if (text) labelText.push(text);
      return labelText.join(": ");
    },

    get parent() {
      if (!isAlive(self)) {
        return void 0;
      }
      return self.object;
    },

    get style() {
      if (!isAlive(self)) {
        return void 0;
      }

      const styled = self.results.find((r) => r.style);

      if (styled && styled.style) {
        return styled.style;
      }
      const emptyStyled = self.results.find((r) => r.emptyStyle);

      if (emptyStyled && emptyStyled.emptyStyle) {
        return emptyStyled.emptyStyle;
      }

      const controlStyled = self.results.find((r) => self.type.startsWith(r.type));

      return controlStyled && controlStyled.controlStyle;
    },

    // @todo may be slow, consider to add some code to annotation (un)select* methods
    get selected() {
      return self.annotation?.highlightedNode === self;
    },

    getOneColor() {
      return (self.style || defaultStyle).fillcolor;
    },

    get highlighted() {
      return self.parent?.selectionArea?.isActive ? self.isInSelectionArea : self._highlighted;
    },

    get isInSelectionArea() {
      return (!isFF(FF_LSDV_4930) || !self.hidden) && self.parent?.selectionArea?.isActive
        ? self.parent.selectionArea.intersectsBbox(self.bboxCoords)
        : false;
    },

    get supportSuggestions() {
      return self.object.supportSuggestions;
    },

    // index of the region in the regions tree (Outliner); will be updated on any order change
    get region_index() {
      if (!self.isRealRegion) {
        return null;
      }
      return self.annotation?.regionStore.regionIndexMap[self.id] || null;
    },
  }))
  .actions((self) => ({
    beforeDestroy() {
      self.results.forEach((r) => destroy(r));

      // Some region indexes have to be recalculated after destroying regions
      self.annotation?.updateAppearenceFromState?.();
    },

    setSelected(value) {
      self.selected = value;
    },

    /**
     * Remove region
     */
    deleteRegion() {
      if (self.annotation.isReadOnly()) return;
      if (self.isReadOnly()) return;
      if (self.selected) self.annotation.unselectAll(true);
      if (self.destroyRegion) self.destroyRegion();
      self.annotation.deleteRegion(self);
    },

    addResult(r) {
      self.results.push(r);
    },

    /**
     * Applies additional data from the given result.
     * In the results we have almost all data meaningful stored in value but in regions we have two places for it:
     * - region itself (fields in model)
     * - related results (in results array)
     * so for some fields we should control more if we want to apply fields that could be in both places into the region.
     * This method also helps to avoid region type detection at the deserialization stage.
     *
     * @param {Object} result - The result object containing additional data.
     * @returns {void}
     */
    applyAdditionalDataFromResult(_result) {
      // This method should be overridden if we need to get some additional data from result on deserialize
    },

    removeResult(r) {
      const index = self.results.indexOf(r);

      if (index < 0) return;
      self.results.splice(index, 1);
      destroy(r);
      if (!self.results.length) self.annotation.deleteArea(self);
    },

    setValue(tag) {
      const result = self.results.find((r) => r.from_name === tag);
      const values = tag.selectedValues();

      if (result) {
        if (tag.holdsState) result.setValue(values);
        else self.removeResult(result);
      } else {
        self.results.push({
          area: self,
          from_name: tag,
          to_name: self.object,
          type: tag.resultType,
          value: {
            [tag.valueType]: values,
          },
        });
      }
      self.updateAppearenceFromState && self.updateAppearenceFromState();
    },
  }));

export const AreaMixin = types.compose("AreaMixin", AreaMixinBase, ReadOnlyRegionMixin);