/* global LSF_VERSION */

import { destroy, detach, flow, getEnv, getParent, getSnapshot, isRoot, types, walk } from "mobx-state-tree";

import uniqBy from "lodash/uniqBy";
import InfoModal from "../components/Infomodal/Infomodal";
import { Hotkey } from "../core/Hotkey";
import { destroy as destroySharedStore } from "../mixins/SharedChoiceStore/mixin";
import ToolsManager from "../tools/Manager";
import Utils from "../utils";
import { guidGenerator } from "../utils/unique";
import { clamp, delay, isDefined } from "../utils/utilities";
import { CREATE_RELATION_MODE } from "./Annotation/LinkingModes";
import AnnotationStore from "./Annotation/store";
import Project from "./ProjectStore";
import Settings from "./SettingsStore";
import Task from "./TaskStore";
import { UserExtended } from "./UserStore";
import { UserLabels } from "./UserLabels";
import {
  FF_CUSTOM_SCRIPT,
  FF_DEV_1536,
  FF_LSDV_4620_3_ML,
  FF_LSDV_4998,
  FF_REVIEWER_FLOW,
  FF_SIMPLE_INIT,
  isFF,
} from "../utils/feature-flags";
import { CommentStore } from "./Comment/CommentStore";
import { CustomButton } from "./CustomButton";

const hotkeys = Hotkey("AppStore", "Global Hotkeys");

export default types
  .model("AppStore", {
    /**
     * XML config
     */
    config: types.string,

    /**
     * Task with data, id and project
     */
    task: types.maybeNull(Task),

    project: types.maybeNull(Project),

    /**
     * History of task {taskId, annotationId}:
     */
    taskHistory: types.array(
      types.model({
        taskId: types.number,
        annotationId: types.maybeNull(types.string),
      }),
      [],
    ),

    /**
     * Configure the visual UI shown to the user
     */
    interfaces: types.array(types.string),

    /**
     * Flag for labeling of tasks
     */
    explore: types.optional(types.boolean, false),

    /**
     * Annotations Store
     */
    annotationStore: types.optional(AnnotationStore, {
      annotations: [],
      predictions: [],
      history: [],
    }),

    /**
     * Comments Store
     */
    commentStore: types.optional(CommentStore, {
      comments: [],
    }),

    /**
     * User of Label Studio
     */
    user: types.optional(types.maybeNull(types.safeReference(UserExtended)), null),

    /**
     * Debug for development environment
     */
    debug: window.HTX_DEBUG === true,

    /**
     * Settings of Label Studio
     */
    settings: types.optional(Settings, {}),

    /**
     * Data of description flag
     */
    description: types.maybeNull(types.string),
    // apiCalls: types.optional(types.boolean, true),

    /**
     * Flag for settings
     */
    showingSettings: types.optional(types.boolean, false),
    /**
     * Flag
     * Description of task in Label Studio
     */
    showingDescription: types.optional(types.boolean, false),
    /**
     * Loading of Label Studio
     */
    isLoading: types.optional(types.boolean, false),
    /**
     * Submitting task; used to prevent from duplicating requests
     */
    isSubmitting: false,
    /**
     * Flag for disable task in Label Studio
     */
    noTask: types.optional(types.boolean, false),
    /**
     * Flag for no access to specific task
     */
    noAccess: types.optional(types.boolean, false),
    /**
     * Finish of labeling
     */
    labeledSuccess: types.optional(types.boolean, false),

    /**
     * Show or hide comments section
     */
    showComments: false,

    /**
     * Dynamic preannotations
     */
    _autoAnnotation: false,

    /**
     * Auto accept suggested annotations
     */
    _autoAcceptSuggestions: false,

    /**
     * Indicator for suggestions awaiting
     */
    awaitingSuggestions: false,

    users: types.optional(types.array(UserExtended), []),

    userLabels: isFF(FF_DEV_1536) ? types.optional(UserLabels, { controls: {} }) : types.undefined,

    queueTotal: types.optional(types.number, 0),

    queuePosition: types.optional(types.number, 0),

    /**
     * Project field used for applying classifications to comments
     */
    commentClassificationConfig: types.maybeNull(types.string),

    customButtons: types.map(
      types.union(types.string, CustomButton, types.array(types.union(types.string, CustomButton))),
    ),
  })
  .preProcessSnapshot((sn) => {
    // This should only be handled if the sn.user value is an object, and converted to a reference id for other
    // entities.
    if (typeof sn.user !== "number") {
      const currentUser = sn.user ?? window.APP_SETTINGS?.user ?? null;

      // This should never be null, but just incase the app user is missing from constructor or the window
      if (currentUser) {
        sn.user = currentUser.id;

        sn.users = sn.users?.length
          ? [currentUser, ...sn.users.filter(({ id }) => id !== currentUser.id)]
          : [currentUser];
      }
    }
    // fix for old version of custom buttons which were just an array
    // @todo remove after a short time
    if (Array.isArray(sn.customButtons)) {
      sn.customButtons = { _replace: sn.customButtons };
    }
    return {
      ...sn,
      _autoAnnotation: localStorage.getItem("autoAnnotation") === "true",
      _autoAcceptSuggestions: localStorage.getItem("autoAcceptSuggestions") === "true",
    };
  })
  .volatile(() => ({
    version: typeof LSF_VERSION === "string" ? LSF_VERSION : "0.0.0",
    initialized: false,
    hydrated: false,
    suggestionsRequest: null,
    // @todo should be removed along with the FF; it's used to detect FF in other parts
    simpleInit: isFF(FF_SIMPLE_INIT),
  }))
  .views((self) => ({
    get events() {
      return getEnv(self).events;
    },
    get hasSegmentation() {
      // not an object and not a classification
      const isSegmentation = (t) => !t.getAvailableStates && !t.perRegionVisible;

      return Array.from(self.annotationStore.names.values()).some(isSegmentation);
    },
    get canGoNextTask() {
      const hasHistory = self.task && self.taskHistory && self.taskHistory.length > 1;

      if (hasHistory) {
        const lastTaskId = self.taskHistory[self.taskHistory.length - 1].taskId;

        return self.task.id !== lastTaskId;
      }
      return false;
    },
    get canGoPrevTask() {
      const hasHistory = self.task && self.taskHistory && self.taskHistory.length > 1;

      if (hasHistory) {
        const firstTaskId = self.taskHistory[0].taskId;

        return self.task.id !== firstTaskId;
      }
      return false;
    },
    get forceAutoAnnotation() {
      return getEnv(self).forceAutoAnnotation;
    },
    get forceAutoAcceptSuggestions() {
      return getEnv(self).forceAutoAcceptSuggestions;
    },
    get autoAnnotation() {
      return self.forceAutoAnnotation || self._autoAnnotation;
    },
    get autoAcceptSuggestions() {
      return self.forceAutoAcceptSuggestions || self._autoAcceptSuggestions;
    },
  }))
  .actions((self) => {
    let appControls;

    function setAppControls(controls) {
      appControls = controls;
    }

    function clearApp() {
      appControls?.clear();
    }

    function renderApp() {
      appControls?.render();
    }
    /**
     * Update settings display state
     */
    function toggleSettings() {
      self.showingSettings = !self.showingSettings;
    }

    /**
     * Update description display state
     */
    function toggleDescription() {
      self.showingDescription = !self.showingDescription;
    }

    function setFlags(flags) {
      const names = [
        "showingSettings",
        "showingDescription",
        "isLoading",
        "isSubmitting",
        "noTask",
        "noAccess",
        "labeledSuccess",
        "awaitingSuggestions",
      ];

      for (const n of names) if (n in flags) self[n] = flags[n];
    }

    /**
     * Check for interfaces
     * @param {string} name
     * @returns {string | undefined}
     */
    function hasInterface(...names) {
      return self.interfaces.find((i) => names.includes(i)) !== undefined;
    }

    function addInterface(name) {
      return self.interfaces.push(name);
    }

    function toggleInterface(name, value) {
      const index = self.interfaces.indexOf(name);
      const newValue = value ?? index < 0;

      if (newValue) {
        if (index < 0) self.interfaces.push(name);
      } else {
        if (index < 0) return;
        self.interfaces.splice(index, 1);
      }
    }

    function toggleComments(state) {
      return (self.showComments = state);
    }

    /**
     * Function
     */
    function afterCreate() {
      ToolsManager.setRoot(self);

      // important thing to detect Area atomatically: it hasn't access to store, only via global
      window.Htx = self;

      self.attachHotkeys();

      getEnv(self).events.invoke("labelStudioLoad", self);
    }

    function attachHotkeys() {
      // Unbind previous keys in case LS was re-initialized
      hotkeys.unbindAll();

      /**
       * Hotkey for submit
       */
      if (self.hasInterface("submit", "update", "review")) {
        hotkeys.addNamed("annotation:submit", () => {
          const annotationStore = self.annotationStore;
          const shouldDenyEmptyAnnotation = self.hasInterface("annotations:deny-empty");
          const entity = annotationStore.selected;
          const areResultsEmpty = entity.results.length === 0;
          const isReview = self.hasInterface("review") || entity.canBeReviewed;
          const isUpdate = !isReview && isDefined(entity.pk);
          // no changes were made over previously submitted version — no drafts, no pending changes
          const noChanges = !entity.history.canUndo && !entity.draftId;
          const isUpdateDisabled = isFF(FF_REVIEWER_FLOW) && isUpdate && noChanges;

          if (shouldDenyEmptyAnnotation && areResultsEmpty) return;
          if (annotationStore.viewingAll) return;
          if (isUpdateDisabled) return;
          if (entity.isReadOnly()) return;

          entity?.submissionInProgress();

          if (self.hasInterface("annotation:bulk")) {
            const customButtons = self.customButtons?.get("_replace");
            const submitButton = customButtons?.find((btn) => btn.name === "submit");
            if (submitButton && !submitButton.disabled) {
              self.handleCustomButton?.(submitButton);
            }
          } else if (isReview) {
            self.acceptAnnotation();
          } else if (!isUpdate && self.hasInterface("submit")) {
            self.submitAnnotation();
          } else if (self.hasInterface("update")) {
            self.updateAnnotation();
          }
        });
      }

      /**
       * Hotkey for skip task
       */
      if (self.hasInterface("skip", "review")) {
        hotkeys.addNamed("annotation:skip", () => {
          if (self.annotationStore.viewingAll) return;

          const entity = self.annotationStore.selected;

          entity?.submissionInProgress();

          if (self.hasInterface("review")) {
            self.rejectAnnotation();
          } else {
            self.skipTask();
          }
        });
      }

      /**
       * Hotkey for delete
       */
      hotkeys.addNamed("region:delete-all", () => {
        const { selected } = self.annotationStore;

        if (window.confirm(getEnv(self).messages.CONFIRM_TO_DELETE_ALL_REGIONS)) {
          selected.deleteAllRegions();
        }
      });

      // create relation
      hotkeys.addNamed("region:relation", () => {
        const c = self.annotationStore.selected;

        if (c && c.highlightedNode && !c.isLinkingMode) {
          c.startLinkingMode(CREATE_RELATION_MODE, c.highlightedNode);
        }
      });

      // Focus fist focusable perregion when region is selected
      hotkeys.addNamed("region:focus", (e) => {
        e.preventDefault();
        const c = self.annotationStore.selected;

        if (c && c.highlightedNode && !c.isLinkingMode) {
          c.highlightedNode.requestPerRegionFocus();
        }
      });

      // unselect region
      hotkeys.addNamed("region:unselect", () => {
        const c = self.annotationStore.selected;

        if (c && !c.isLinkingMode && !c.isDrawing) {
          self.annotationStore.history.forEach((obj) => {
            obj.unselectAll();
          });

          c.unselectAll();
        }
      });

      hotkeys.addNamed("region:visibility", () => {
        const c = self.annotationStore.selected;

        if (c && !c.isLinkingMode) {
          c.hideSelectedRegions();
        }
      });

      hotkeys.addNamed("region:lock", () => {
        const c = self.annotationStore.selected;

        if (c && !c.isLinkingMode) {
          c.lockSelectedRegions();
        }
      });

      hotkeys.addNamed("region:visibility-all", () => {
        const { selected } = self.annotationStore;
        selected.regionStore.toggleVisibility();
      });

      hotkeys.addNamed("annotation:undo", () => {
        const annotation = self.annotationStore.selected;

        // Allow undo even during drawing - the undo() method handles stopping drawing
        // when appropriate (e.g., when vertices <= 1 for vector regions)
        // This matches the behavior of the undo button which doesn't check isDrawing
        annotation.undo();
      });

      hotkeys.addNamed("annotation:redo", () => {
        const annotation = self.annotationStore.selected;

        // Allow redo even during drawing - matches the behavior of the redo button
        // which doesn't check isDrawing
        annotation.redo();
      });

      hotkeys.addNamed("region:exit", (e) => {
        e.stopImmediatePropagation();

        const c = self.annotationStore.selected;
        const managers = ToolsManager.allInstances();
        const tools = managers
          .map((m) => m.findSelectedTool())
          .filter(Boolean)
          .filter((t) => t.isDrawing);

        if (tools.length > 0) {
          tools.forEach((t) => t.complete?.());
        } else if (c && c.isLinkingMode) {
          c.stopLinkingMode();
        } else if (!c.isDrawing) {
          c.unselectAll();
        }
      });

      hotkeys.addNamed("region:delete", () => {
        const c = self.annotationStore.selected;

        if (c) {
          c.deleteSelectedRegions();
        }
      });

      hotkeys.addNamed("region:cycle", () => {
        const c = self.annotationStore.selected;

        c && c.regionStore.selectNext();
      });

      // duplicate selected regions
      hotkeys.addNamed("region:duplicate", (e) => {
        const { selected } = self.annotationStore;
        const { serializedSelection } = selected || {};

        if (!serializedSelection?.length) return;
        e.preventDefault();
        const results = selected.appendResults(serializedSelection);

        selected.selectAreas(results);
      });
    }

    function setTaskHistory(taskHistory) {
      self.taskHistory = taskHistory;
    }

    /**
     *
     * @param {*} taskObject
     * @param {*[]} taskHistory
     */
    function assignTask(taskObject) {
      if (taskObject && !Utils.Checkers.isString(taskObject.data)) {
        taskObject = {
          ...taskObject,
          data: JSON.stringify(taskObject.data),
        };
      }
      self.task = Task.create(taskObject);

      if (!self.taskHistory.some((x) => x.taskId === self.task.id)) {
        self.taskHistory.push({
          taskId: self.task.id,
          annotationId: null,
        });
      }
    }

    function assignConfig(config) {
      const cs = self.annotationStore;

      self.config = config;
      cs.initRoot(self.config);
    }

    /* eslint-disable no-unused-vars */
    function showModal(message, type = "warning") {
      InfoModal[type](message);

      // InfoModal.warning("You need to label at least something!");
    }
    /* eslint-enable no-unused-vars */

    function submitDraft(c, params = {}) {
      return new Promise((resolve) => {
        const events = getEnv(self).events;

        if (!events.hasEvent("submitDraft")) return resolve();
        const res = events.invokeFirst("submitDraft", self, c, params);

        if (res && res.then) res.then(resolve);
        else resolve(res);
      });
    }

    function waitForDraftSubmission() {
      return new Promise((resolve) => {
        if (!self.annotationStore.selected.isDraftSaving) resolve();

        const checkInterval = setInterval(() => {
          if (!self.annotationStore.selected.isDraftSaving) {
            clearInterval(checkInterval);
            resolve();
          }
        }, 100);
      });
    }

    // Set `isSubmitting` flag to block [Submit] and related buttons during request
    // to prevent from sending duplicating requests.
    // Better to return request's Promise from SDK to make this work perfect.
    function handleSubmittingFlag(fn, defaultMessage = "Error during submit") {
      if (self.isSubmitting) return;
      self.setFlags({ isSubmitting: true });
      const res = fn();

      self.commentStore.setAddedCommentThisSession(false);

      // Wait for request, max 5s to not make disabled forever broken button;
      // but block for at least 0.2s to prevent from double clicking.
      Promise.race([Promise.all([res, delay(200)]), delay(5000)])
        .catch((err) => {
          showModal(err?.message || err || defaultMessage);
          console.error(err);
        })
        .then(() => self.setFlags({ isSubmitting: false }));
    }

    function incrementQueuePosition(number = 1) {
      self.queuePosition = clamp(self.queuePosition + number, 1, self.queueTotal);
    }

    function submitAnnotation() {
      if (self.isSubmitting) return;

      const entity = self.annotationStore.selected;
      const event = entity.exists ? "updateAnnotation" : "submitAnnotation";

      entity.beforeSend();

      if (!entity.validate()) return;

      if (!isFF(FF_CUSTOM_SCRIPT)) {
        entity.sendUserGenerate();
      }
      handleSubmittingFlag(async () => {
        if (isFF(FF_CUSTOM_SCRIPT)) {
          await self.waitForDraftSubmission();
          const allowedToSave = await getEnv(self).events.invoke("beforeSaveAnnotation", self, entity, { event });
          if (allowedToSave && allowedToSave.some((x) => x === false)) return;

          entity.sendUserGenerate();
        }
        await getEnv(self).events.invoke(event, self, entity);
        self.incrementQueuePosition();
        if (isFF(FF_CUSTOM_SCRIPT)) {
          entity.dropDraft();
        }
      });
      if (!isFF(FF_CUSTOM_SCRIPT)) {
        entity.dropDraft();
      }
    }

    function updateAnnotation(extraData) {
      if (self.isSubmitting) return;

      const entity = self.annotationStore.selected;

      entity.beforeSend();

      if (!entity.validate()) return;

      handleSubmittingFlag(async () => {
        if (isFF(FF_CUSTOM_SCRIPT)) {
          const allowedToSave = await getEnv(self).events.invoke("beforeSaveAnnotation", self, entity, {
            event: "updateAnnotation",
          });
          if (allowedToSave && allowedToSave.some((x) => x === false)) return;
        }
        await getEnv(self).events.invoke("updateAnnotation", self, entity, extraData);
        self.incrementQueuePosition();
        if (isFF(FF_CUSTOM_SCRIPT)) {
          entity.dropDraft();
          !entity.sentUserGenerate && entity.sendUserGenerate();
        }
      });
      if (!isFF(FF_CUSTOM_SCRIPT)) {
        entity.dropDraft();
        !entity.sentUserGenerate && entity.sendUserGenerate();
      }
    }

    function skipTask(extraData) {
      if (self.isSubmitting) return;
      // Manager roles that can force-skip unskippable tasks (OW=Owner, AD=Admin, MA=Manager)
      const MANAGER_ROLES = ["OW", "AD", "MA"];
      const task = self.task;
      const taskAllowSkip = task?.allow_skip !== false;
      const userRole = window.APP_SETTINGS?.user?.role;
      const hasForceSkipPermission = MANAGER_ROLES.includes(userRole);
      const canSkip = taskAllowSkip || hasForceSkipPermission;
      if (!canSkip) {
        console.warn("Task cannot be skipped: allow_skip is false and user lacks manager role");
        return;
      }
      handleSubmittingFlag(() => {
        getEnv(self).events.invoke("skipTask", self, extraData);
        self.incrementQueuePosition();
      }, "Error during skip, try again");
    }

    function unskipTask() {
      if (self.isSubmitting) return;
      handleSubmittingFlag(() => {
        getEnv(self).events.invoke("unskipTask", self);
      }, "Error during cancel skipping task, try again");
    }

    function acceptAnnotation() {
      if (self.isSubmitting) return;

      handleSubmittingFlag(async () => {
        const entity = self.annotationStore.selected;

        entity.beforeSend();
        if (!entity.validate()) return;
        if (isFF(FF_CUSTOM_SCRIPT)) {
          const allowedToSave = await getEnv(self).events.invoke("beforeSaveAnnotation", self, entity, {
            event: "acceptAnnotation",
          });
          if (allowedToSave && allowedToSave.some((x) => x === false)) return;
        }

        // changes in current sessions or saved draft should send the result along with approval
        const isDirty = entity.history.canUndo || entity.versions.draft;

        entity.dropDraft();
        await getEnv(self).events.invoke("acceptAnnotation", self, { isDirty, entity });
        self.incrementQueuePosition();
      }, "Error during accept, try again");
    }

    function rejectAnnotation({ comment = null }) {
      if (self.isSubmitting) return;

      handleSubmittingFlag(async () => {
        const entity = self.annotationStore.selected;

        entity.beforeSend();
        if (!entity.validate()) return;
        if (isFF(FF_CUSTOM_SCRIPT)) {
          const allowedToSave = await getEnv(self).events.invoke("beforeSaveAnnotation", self, entity, {
            event: "rejectAnnotation",
          });
          if (allowedToSave && allowedToSave.some((x) => x === false)) return;
        }

        const isDirty = entity.history.canUndo;

        entity.dropDraft();
        await getEnv(self).events.invoke("rejectAnnotation", self, { isDirty, entity, comment });
        self.incrementQueuePosition(-1);
      }, "Error during reject, try again");
    }

    function handleCustomButton(button) {
      if (self.isSubmitting) return;
      const buttonName = button.name;

      handleSubmittingFlag(async () => {
        const entity = self.annotationStore.selected;

        entity.beforeSend();
        // @todo add needsValidation or something like that as a parameter to custom buttons
        // if (!entity.validate()) return;

        const isDirty = entity.history.canUndo;

        await getEnv(self).events.invoke("customButton", self, buttonName, { isDirty, entity, button });
        self.incrementQueuePosition();
        entity.dropDraft();
      }, `Error during handling ${button} button, try again`);
    }

    /**
     * Exchange storage url for presigned url for task
     */
    async function presignUrlForProject(url) {
      // Event invocation returns array of results for all handlers.
      const urls = await self.events.invoke("presignUrlForProject", self, url);

      const presignUrl = urls?.[0];

      return presignUrl;
    }

    /**
     * Reset annotation store
     */
    function resetState() {
      // Tools are attached to the control and object tags
      // and need to be recreated when we st a new task
      ToolsManager.removeAllTools();

      // Same with hotkeys
      Hotkey.unbindAll();
      self.attachHotkeys();
      const oldAnnotationStore = self.annotationStore;

      if (oldAnnotationStore) {
        oldAnnotationStore.beforeReset?.();
        if (isFF(FF_LSDV_4998)) {
          destroySharedStore();
        }
        detach(oldAnnotationStore);
        destroy(oldAnnotationStore);
      }

      self.annotationStore = AnnotationStore.create({ annotations: [] });
      self.initialized = false;
    }

    function resetAnnotationStore() {
      const oldAnnotationStore = self.annotationStore;

      if (oldAnnotationStore) {
        oldAnnotationStore.beforeReset?.();
        oldAnnotationStore.resetAnnotations?.();
      }
    }

    /**
     * Function to initialize annotation store
     * Given annotations and predictions
     * `completions` is a fallback for old projects; they'll be saved as `annotations` anyway
     */
    function initializeStore({ annotations = [], completions = [], predictions = [], annotationHistory }) {
      const as = self.annotationStore;

      // some hacks to properly clear react and mobx structures
      as.afterReset?.();

      if (!as.initialized) {
        as.initRoot(self.config);
        if (isFF(FF_LSDV_4620_3_ML) && !appControls?.isRendered()) {
          appControls?.render();
        }
      }

      // goal here is to deserialize everything fast and select only first annotation
      // no extra processes during eserialization and further processes triggered during select
      if (self.simpleInit) {
        window.STORE_INIT_OK = false;

        // add predictions and annotations to the store;
        // `hidden` will stop them from calling any rendering helpers;
        // correct annotation will be selected at the end and everything will be called inside.
        predictions.forEach((p) => {
          const obj = as.addPrediction(p);
          const results = p.result.map((r) => ({ ...r, origin: "prediction" }));

          obj.deserializeResults(results, { hidden: true });
        });

        [...completions, ...annotations].forEach((c) => {
          const obj = as.addAnnotation(c);

          obj.deserializeResults(c.draft || c.result, { hidden: true });
        });

        window.STORE_INIT_OK = true;
        // simple logging to detect if simple init is used on users' machines
        console.log("LSF: deserialization is finished");

        // next line might be unclear after removing FF_SIMPLE_INIT
        // reversing the list caused problems before when task is reloaded and list is reversed again.
        // AnnotationsCarousel has its own ordering anyway, so we just keep technical order
        // as simple as possible.
        const current = as.annotations.at(-1);
        const currentPrediction = !current && as.predictions.at(-1);

        if (current) {
          as.selectAnnotation(current.id);
          // looks like we still need it anyway, but it's fast and harmless,
          // and we only call it once on already visible annotation
          current.reinitHistory();
        } else if (currentPrediction) {
          as.selectPrediction(currentPrediction.id);
        }

        // annotation history is set when annotation is selected,
        // so no need to set it here
      } else {
        (predictions ?? []).forEach((p) => {
          const obj = as.addPrediction(p);

          as.selectPrediction(obj.id);
          obj.deserializeResults(
            p.result.map((r) => ({
              ...r,
              origin: "prediction",
            })),
          );
        });

        [...(completions ?? []), ...(annotations ?? [])]?.forEach((c) => {
          const obj = as.addAnnotation(c);

          as.selectAnnotation(obj.id);
          obj.deserializeResults(c.draft || c.result);
          obj.reinitHistory();
        });

        const current = as.annotations.at(-1);

        if (current) current.setInitialValues();

        self.setHistory(annotationHistory);
      }

      if (!self.initialized) {
        self.initialized = true;
        getEnv(self).events.invoke("storageInitialized", self);
      }
    }

    function setHistory(history = []) {
      const as = self.annotationStore;

      as.clearHistory();

      // always check that history is for correct and submitted annotation
      if (!history.length || !as.selected?.pk) return;
      if (Number(as.selected.pk) !== Number(history[0].annotation_id)) return;

      (history ?? []).forEach((item) => {
        const obj = as.addHistory(item);

        obj.deserializeResults(item.result ?? [], { hidden: true });
      });
    }

    const setAutoAnnotation = (value) => {
      self._autoAnnotation = value;
      localStorage.setItem("autoAnnotation", value);
    };

    const setAutoAcceptSuggestions = (value) => {
      self._autoAcceptSuggestions = value;
      localStorage.setItem("autoAcceptSuggestions", value);
    };

    const loadSuggestions = flow(function* (request, dataParser) {
      const requestId = guidGenerator();

      self.suggestionsRequest = requestId;

      self.setFlags({ awaitingSuggestions: true });

      try {
        const response = yield request;

        if (requestId === self.suggestionsRequest) {
          self.annotationStore.selected.setSuggestions(dataParser(response));
          self.setFlags({ awaitingSuggestions: false });
        }
      } catch (_e) {
        self.setFlags({ awaitingSuggestions: false });
        // @todo handle errors + situation when task is changed
      }
    });

    function addAnnotationToTaskHistory(annotationId) {
      const taskIndex = self.taskHistory.findIndex(({ taskId }) => taskId === self.task.id);

      if (taskIndex >= 0) {
        self.taskHistory[taskIndex].annotationId = annotationId;
      }
    }

    async function postponeTask() {
      const annotation = self.annotationStore.selected;

      // save draft before postponing; this can be new draft with FF_DEV_4174 off
      // or annotation created from prediction
      await annotation.saveDraft({ was_postponed: true });
      await getEnv(self).events.invoke("nextTask");
      self.incrementQueuePosition();
    }

    function nextTask() {
      if (self.canGoNextTask) {
        const { taskId, annotationId } =
          self.taskHistory[self.taskHistory.findIndex((x) => x.taskId === self.task.id) + 1];

        getEnv(self).events.invoke("nextTask", taskId, annotationId);
        self.incrementQueuePosition();
      }
    }

    function prevTask(_e, shouldGoBack = false) {
      const length = shouldGoBack
        ? self.taskHistory.length - 1
        : self.taskHistory.findIndex((x) => x.taskId === self.task.id) - 1;

      if (self.canGoPrevTask || shouldGoBack) {
        const { taskId, annotationId } = self.taskHistory[length];

        getEnv(self).events.invoke("prevTask", taskId, annotationId);
        self.incrementQueuePosition(-1);
      }
    }

    function setUsers(users) {
      self.users.replace(users);
    }

    // @deprecated use `enrichUsers` instead (as mergeUsers will not update existing users and can lose previous data)
    function mergeUsers(users) {
      self.setUsers(uniqBy([...getSnapshot(self.users), ...users], "id"));
    }

    function enrichUsers(users) {
      const oldUsers = getSnapshot(self.users);
      const oldUsersMap = {};
      oldUsers.forEach((user) => {
        oldUsersMap[user.id] = user;
      });
      const newUsers = users.map((user) => {
        return { ...oldUsersMap[user.id], ...user };
      });
      self.setUsers(uniqBy([...newUsers, ...oldUsers], "id"));
    }

    return {
      setFlags,
      addInterface,
      hasInterface,
      toggleInterface,

      afterCreate,
      assignTask,
      assignConfig,
      resetState,
      resetAnnotationStore,
      initializeStore,
      setHistory,
      attachHotkeys,

      skipTask,
      unskipTask,
      setTaskHistory,
      submitDraft,
      waitForDraftSubmission,
      submitAnnotation,
      updateAnnotation,
      acceptAnnotation,
      rejectAnnotation,
      handleCustomButton,
      presignUrlForProject,
      setUsers,
      mergeUsers,
      enrichUsers,

      showModal,
      toggleComments,
      toggleSettings,
      toggleDescription,

      setAutoAnnotation,
      setAutoAcceptSuggestions,
      loadSuggestions,

      addAnnotationToTaskHistory,
      nextTask,
      prevTask,
      postponeTask,
      incrementQueuePosition,
      beforeDestroy() {
        ToolsManager.removeAllTools();
        appControls = null;
      },

      setAppControls,
      clearApp,
      renderApp,
      selfDestroy() {
        const children = [];

        walk(self, (node) => {
          if (!isRoot(node) && getParent(node) === self) children.push(node);
        });

        let node;

        while ((node = children.shift())) {
          try {
            destroy(node);
          } catch (e) {
            console.log("Problem: ", e);
          }
        }
      },
    };
  });