import CryptoJS from 'crypto-js'
import dayjs from 'dayjs'
import IsBetween from 'dayjs/plugin/isBetween'
import {
  castArray,
  chunk,
  difference,
  get,
  isEqual,
  isString,
  noop,
  partition,
  pick,
  set,
  uniq,
} from 'lodash'
import log from 'loglevel'
import {
  action,
  IMapDidChange,
  makeObservable,
  observable,
  observe,
  reaction,
  runInAction,
} from 'mobx'
import { createPatch } from 'rfc6902'

import { findFileNameConflicts } from '../files'
import {
  $SchemaIdTemplate,
  AttributeType,
  DateQuery,
  ElementSchema,
  ElementType,
  List,
  Reference,
  SchemaId,
  Stage,
  Template,
  TemplateId,
} from '../interfaces'
import {
  AttributeData,
  AttributeDefinition,
  AttributeDefinitions,
  AttributeFileData,
  AttributeGroup,
  AttributeValue,
  AttributeValueMultiple,
  ConditionalViewConfig,
  ElementAttributeData,
  ElementBatchCreateData,
  ElementData,
  ElementFormData,
  ElementRaw,
  ElementsPrivileges,
  ElementsTemplates,
  ElementTemplateV1,
  ElementTypePrivilegesList,
  ILogicalOperator,
  instanceOfLocalElement,
  isFileData,
  isLocalFile,
  isRemoteFile,
  LocalElement,
  Operation,
  Operations,
  PlatformFile,
  PreparedFiles,
  RemoveOperation,
  ViewConfigCondition,
} from '../interfaces/element.interface'
import { DehydratedElement } from '../interfaces/offline.interface'
import { CheckList, CheckPoint, Record as RecordModel, Ticket } from '../models'
import { CommitState, isLocal } from '../models/_mixin/isLocal'
import { isElementObject, TICKET_SPECIAL_ATTRIBUTES } from '../models/constants'
import {
  cloneElementData,
  Element,
  getAttributeNameFromOperation,
  getPatchedElementFromOperations,
} from '../models/element'
import { getSchemaId, urlToSchemaId } from '../schema/schemaIdUrl'
import {
  BatchCreateResponse,
  BatchMetadata,
  FilesBatchPostData,
  IBatchEditAttributeDataV2,
} from '../services/edocu/batch'
import { DEFAULT_TEMPLATE_ID } from '../services/edocu/editors'
import {
  ElementGetQueryParams,
  ElementPrivileges,
  ElementSearchOptions,
  GetElementSearch,
  TYPE_LIST_PER_PAGE,
} from '../services/edocu/elements'
import { isArrayLike } from '../util/isArrayLike'
import { transformType } from '../util/transformType'

import { MainStore } from './mainStore'

dayjs.extend(IsBetween)

const MAX_PER_BATCH = 250

interface InstantiateElementOptions {
  setToMemory: boolean
  extendWithOlderData: boolean
}

interface SyncJobs {
  create: LocalElement[]
  update: Element[]
}

type SyncProgress = {
  done: number
  failed: number
  total: number
}

const comparisonFuncs: Record<
  ILogicalOperator,
  (
    elementAttrValue: AttributeValue,
    comparedValue: AttributeValue & DateQuery,
  ) => boolean
> = {
  '===': (elementAttrValue: AttributeValue, comparedValue: AttributeValue) =>
    comparedValue === elementAttrValue,
  '!==': (elementAttrValue: AttributeValue, comparedValue: AttributeValue) =>
    comparedValue !== elementAttrValue,
  '!!': (elementAttrValue: AttributeValue) => !!elementAttrValue,
  '!': (elementAttrValue: AttributeValue) => !elementAttrValue,
  IN: (elementAttrValue: AttributeValue, comparedValue: DateQuery) => {
    const isValidDate = isValidDateString(elementAttrValue as string)
    return (
      isValidDate &&
      comparedValue &&
      isBetween(elementAttrValue as string, comparedValue)
    )
  },
  NOTIN: (elementAttrValue: AttributeValue, comparedValue: DateQuery) => {
    const isValidDate = isValidDateString(elementAttrValue as string)
    return (
      isValidDate &&
      comparedValue &&
      !isBetween(elementAttrValue as string, comparedValue)
    )
  },
  CONTAINS: (
    elementAttrValue: AttributeValue,
    comparedValue: AttributeValue,
  ) => {
    return !!(
      elementAttrValue &&
      comparedValue &&
      typeof elementAttrValue === 'string' &&
      typeof comparedValue === 'string' &&
      elementAttrValue.includes(comparedValue)
    )
  },
}

function isBetween(date: string, comparedObj: DateQuery) {
  return dayjs(date).isBetween(
    comparedObj.$gte || '',
    comparedObj.$lte || '',
    undefined,
    '[]',
  )
}
export function isValidDateString(date: string | undefined) {
  return dayjs(
    date,
    [
      'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]',
      'YYYY-MM-DD[T]HH:mm:ss[Z]',
      'YYYY-MM-DD[T]HH:mm:ss.SSSSSSSSS[Z]',
    ],
    true,
  ).isValid()
}

export class ElementStore {
  static listeners: (() => void)[] = []

  // V1 typeData and templates - Legacy
  elementsTypeDataV1: Map<string, AttributeDefinitions> = new Map()
  elementTemplatesV1: ElementsTemplates = new Map()
  workRecordActions: Map<string, string[]> = new Map()

  // V2 schema and template
  elementSchemas: Map<SchemaId, ElementSchema> = new Map()
  elementTemplates: Map<string, Template> = new Map()

  privileges: ElementsPrivileges = new Map()
  elements: Map<string, Element> = new Map()

  syncProgress: SyncProgress | undefined = undefined

  socketEventIds: string[] = []

  main: MainStore

  constructor(main: MainStore) {
    makeObservable(this, {
      elementsTypeDataV1: observable,
      elementTemplatesV1: observable,
      workRecordActions: observable.shallow,
      elementSchemas: observable.shallow,
      elementTemplates: observable.shallow,
      privileges: observable,
      elements: observable.shallow,
      syncProgress: observable,
      socketEventIds: observable,
      addTypeData: action,
      addWorkRecordActions: action,
      addTemplateV1Data: action,
      addPrivilegesData: action,
      getElementSchema: action,
      setSchema: action,
      saveSchema: action,
      addSchema: action,
      getTemplate: action,
      saveTemplate: action,
      setTemplate: action,
      create: action,
      createTicket: action,
      rehydrateElement: action,
      instantiateElement: action,
      applyPatchToElement: action,
    })

    this.main = main

    observe(this.elements, (change) => this.onElementsChange(change))

    reaction(
      () => this.main.connectivityService?.isConnected,
      () => this.onConnectionChange(),
    )
  }

  addTypeData(type: string, typeData: AttributeDefinitions) {
    this.elementsTypeDataV1.set(type, typeData)
  }

  addWorkRecordActions(type: string, actions: string[]) {
    this.workRecordActions.set(type, actions)
  }

  async search(
    query: string,
    options?: ElementSearchOptions,
  ): Promise<GetElementSearch | undefined> {
    return this.main.elements.search(query, options)
  }

  addTemplateV1Data(
    type: string,
    organization: string,
    template: ElementTemplateV1,
  ) {
    const typeTemplate = this.elementTemplatesV1.get(type)

    this.elementTemplatesV1.set(type, {
      ...(typeTemplate || {}),
      [organization]: template,
    })
  }

  addPrivilegesData(
    type: ElementType,
    organization: string,
    privileges: ElementPrivileges,
  ) {
    const typePrivileges = this.privileges.get(type)

    if (typePrivileges && typePrivileges?.[organization]) {
      return
    }

    this.privileges.set(type, {
      ...(typePrivileges || {}),
      [organization]: privileges,
    })
  }

  async get<T extends Element>(
    hash: string,
    type: ElementType,
    queryParams?: ElementGetQueryParams,
  ): Promise<T | null> {
    const element = this.instantiateElement(
      hash,
      {
        _type: type,
      } as ElementData,
      false,
      { setToMemory: false },
    ) as T

    if (!element) {
      return null
    }

    const res = await element.loadData(false, queryParams)

    // only set AFTER loading data
    if (res?.ok) {
      this.elements.set(hash, element)
    }

    if (element.errored) {
      throw element.errored
    }

    return element
  }

  async getElementTypeData(
    type: string,
  ): Promise<AttributeDefinitions | undefined> {
    const typeData = this.elementsTypeDataV1.get(type)
    if (typeData) {
      return typeData
    }

    const typeDataRequest = await this.main.elements.getTypeDataV1(type)

    if (!typeDataRequest.ok || !typeDataRequest.data) {
      return
    }

    this.addTypeData(type, typeDataRequest.data.attributes)
    this.addWorkRecordActions(type, typeDataRequest.data.actions)

    return typeDataRequest.data.attributes
  }

  async getElementTemplateV1(type: string, organization: string) {
    const template = this.elementTemplatesV1.get(type)
    if (template && template[organization]) {
      return template[organization]
    }

    const templateRequest = await this.main.elements.getTemplateV1(
      type,
      organization,
    )

    if (!templateRequest.ok || !templateRequest.data) {
      return
    }

    this.addTemplateV1Data(type, organization, templateRequest.data)

    return templateRequest.data
  }
  async getElementSchema(
    type: ElementType,
    options?: { stage?: Stage; useStoreCache?: boolean; cache?: false },
  ): Promise<ElementSchema | undefined> {
    const schemaId = getSchemaId(type)

    const sameStage =
      !options?.stage || options?.stage === this.main.config.stage
    const useStoreCache = sameStage && (options?.useStoreCache ?? true)
    const schema = this.elementSchemas.get(schemaId)

    if (useStoreCache && schema) {
      return schema
    }

    const schemaRes = await this.main.editors.getTypeSchema(schemaId, options)

    // Schema does not exist
    if (schemaRes.status === 404) {
      return
    }

    if (!schemaRes.ok || !schemaRes.data) {
      return
    }

    runInAction(() => {
      if (useStoreCache && schemaRes.data) {
        this.setSchema(schemaId, schemaRes.data)
      }
    })

    return schemaRes.data
  }

  setSchema(schemaId: SchemaId, schema: ElementSchema) {
    this.elementSchemas.set(schemaId, schema)
  }

  async saveSchema(
    type: ElementType,
    schema: ElementSchema,
    options?: { stage?: Stage },
  ) {
    const schemaId = getSchemaId(type)

    const useStoreCache =
      !options?.stage || options?.stage === this.main.config.stage
    const res = await this.main.editors.saveTypeSchema(
      schemaId,
      schema,
      options,
    )

    if (!res.ok || !res.data) {
      throw res.originalError
    }

    runInAction(() => {
      if (useStoreCache && res.data) {
        this.setSchema(schemaId, res.data)
      }
    })

    return res.data
  }

  async addSchema(
    schema: Required<Pick<ElementSchema, 'id' | 'scope' | 'properties'>>,
    options?: { stage?: Stage },
  ) {
    const res = await this.main.editors.addSchema(schema, options)
    const useStoreCache =
      !options?.stage || options?.stage === this.main.config.stage

    if (!res.ok || !res.data) {
      throw res.originalError
    }

    runInAction(() => {
      if (useStoreCache && res.data) {
        const schemaId = getSchemaId(res.data.$id)
        this.setSchema(schemaId, res.data)
      }
    })

    return res.data
  }

  async getTemplate(
    type: ElementType,
    templateId = DEFAULT_TEMPLATE_ID,
    options?: {
      stage?: Stage
      useStoreCache?: boolean
      cache?: false
      strict?: boolean
    },
  ) {
    const schemaId = getSchemaId(type)
    const id = getTemplateId(schemaId, templateId)

    const sameStage =
      !options?.stage || options?.stage === this.main.config.stage
    const useStoreCache = sameStage && (options?.useStoreCache ?? true)
    const template = this.elementTemplates.get(id)

    if (useStoreCache && template) {
      return template
    }

    const templateDataRequest = await this.main.editors.getTemplate(
      schemaId,
      templateId,
      options,
    )

    if (!templateDataRequest.ok || !templateDataRequest.data) {
      return
    }

    runInAction(() => {
      if (useStoreCache && templateDataRequest.data) {
        this.setTemplate(schemaId, templateDataRequest.data, templateId)
      }
    })

    return templateDataRequest.data
  }

  async saveTemplate(
    schemaId: SchemaId,
    templateId?: TemplateId,
    data?: Partial<Template>,
    options?: { stage?: Stage },
  ) {
    const useStoreCache =
      !options?.stage || options?.stage === this.main.config.stage
    const res = await this.main.editors.saveTemplate(
      schemaId,
      templateId,
      data,
      options,
    )

    if (!res.ok || !res.data) {
      throw res.originalError
    }

    runInAction(() => {
      if (useStoreCache && res.data) {
        this.setTemplate(schemaId, res.data, templateId)
      }
    })

    return res.data
  }

  setTemplate(
    schemaId: SchemaId,
    template: Template,
    templateId: TemplateId = DEFAULT_TEMPLATE_ID,
  ) {
    const id = getTemplateId(schemaId, templateId)

    this.elementTemplates.set(id, template)
  }

  async getElementPrivileges(type: ElementType, organization: string) {
    const transformedTypes = transformType(type, organization)
    const privileges = this.privileges.get(transformedTypes)?.[organization]
    if (privileges) {
      return privileges
    }

    const privilegesRequest = await this.main.elements.getPrivileges(
      organization,
      transformedTypes,
    )

    if (!privilegesRequest.ok || !privilegesRequest.data) {
      return
    }

    this.addPrivilegesData(
      transformedTypes,
      organization,
      privilegesRequest.data.privileges,
    )

    return privilegesRequest.data.privileges
  }

  async loadElementTypes(right?: 'read' | 'update' | 'create') {
    const types: string[] = []

    const getTypeIds = (data?: ElementTypePrivilegesList): string[] => {
      return data?.['element-types']?.map((t) => t.id) || []
    }

    const firstPage = await this.main.elements.getElementTypeList(
      this.main.userStore.organization.id,
      right,
      1,
    )
    types.push(...getTypeIds(firstPage))

    if (firstPage && firstPage.count > TYPE_LIST_PER_PAGE) {
      // request more
      const pagesToFetch = Math.ceil(firstPage.count / TYPE_LIST_PER_PAGE)

      for (let index = 1; index < pagesToFetch; index++) {
        const page = await this.main.elements.getElementTypeList(
          this.main.userStore.organization.id,
          right,
          index + 1,
        )

        types.push(...getTypeIds(page))
      }
    }

    return types
  }

  async create(
    type: ElementType,
    data: ElementAttributeData,
    organization: string,
    options?: {
      parent?: Element
      shouldLoad?: boolean
    },
  ): Promise<{ hash: string }> {
    const typeDataV1 = this.elementsTypeDataV1.get(type)

    const schemaId = getSchemaId(type)
    const typeSchema = this.elementSchemas.get(schemaId)

    if (!typeDataV1 && !typeSchema) {
      throw new Error(
        `Element create() called with no type definitions \n ${JSON.stringify(
          { type, data, organization, options },
          null,
          2,
        )}`,
      )
    }

    const files = this.getLocalFiles(data)

    files.forEach((file) => {
      const fileAttribute =
        typeof file.attribute === 'string' ? file.attribute : file.attribute.id
      // we can throw this data out now so it doesnt mess up the element update
      delete data[fileAttribute]
    })

    const operations = this.prepareOperations(type, data, {})
    const forceVersion = this.main.userStore.schemaVersion

    const createRequest = await this.main.elements.create(
      type,
      operations,
      organization,
      options?.parent?.hash,
      {
        forceVersion,
      },
    )

    if (!createRequest.ok || !createRequest.data?.element) {
      log.error(
        `Create element failed`,
        createRequest.data,
        type,
        operations,
        organization,
        options?.parent?.hash,
      )

      // console.warn(createRequest)
      throw new Error(
        createRequest.originalError?.response?.data?.error?.description ||
          'Create element failed, unknown error',
      )
    }

    const hash = createRequest.data.element.hash

    if (!hash) {
      throw new Error('Create element failed, hash is undefined')
    }

    await this.uploadFiles(type, hash, files)

    return {
      hash,
    }
  }

  async createTicket(
    data: ElementAttributeData,
    organization: string,
  ): Promise<{ hash: string }> {
    const ordinaryAttributes: ElementFormData = {}
    const ticketData = Object.entries(data).reduce(
      (acc, [key, value]) => {
        let rawValue: AttributeFileData<PlatformFile> | AttributeValue
        if (isFileData(value)) {
          rawValue = value
        } else {
          rawValue = value.value
        }

        if (!TICKET_SPECIAL_ATTRIBUTES.includes(key)) {
          ordinaryAttributes[key] = rawValue
        } else {
          acc[key] = rawValue
        }

        return acc
      },
      {} as Record<string, unknown>,
    )

    console.log('ticketCreate', ticketData, ordinaryAttributes)

    const ticketCreate = await this.main.tickets.create(
      ticketData,
      organization,
    )

    if (!ticketCreate.ok || !ticketCreate.data) {
      throw new Error(
        `Failed to create ticket \n ${JSON.stringify(ticketData, null, 2)}`,
      )
    }

    return {
      hash: ticketCreate.data.hash,
    }
  }

  async createBatchElements(
    elements: LocalElement[],
  ): Promise<BatchCreateResponse> {
    const data = elements
      .map((element) => {
        if (!element.data || !element.type || !element.organization) {
          log.warn(
            `Element missing data, type or organization ${element.elementName}(${element.hash})`,
          )
          return
        }

        const operations = this.prepareOperations(element.type, element.data)

        const batchData: ElementBatchCreateData = {
          organization: {
            id: element.organization,
          },
          element: {
            type: element.type,
          },
          operations,
        }

        return batchData
      })
      .filter(Boolean) as ElementBatchCreateData[]

    const response = await this.main.batch.createElements(data)

    if (!response.ok || !response.data) {
      throw new Error('Failed to create batch elements')
    }

    return response.data
  }

  getLocalFiles(data: ElementAttributeData): PreparedFiles[] {
    return Object.entries(data).reduce(
      (acc: PreparedFiles[], [attributeKey, attributeValue]) => {
        if (!attributeValue || !isArrayLike(attributeValue)) {
          return acc
        }

        const hasLocalFiles = attributeValue.some(isLocalFile)
        if (hasLocalFiles) {
          const { localFiles: newFiles } =
            this.getFilesWithUniqNames(attributeValue)

          if (newFiles.length > 0) {
            acc.push({
              attribute: attributeKey,
              value: newFiles,
            })
          }
        }

        return acc
      },
      [],
    )
  }

  async uploadFiles(
    type: ElementType,
    hash: string,
    files: PreparedFiles[],
    workRecordHash?: string,
  ) {
    if (files.length === 0) {
      return
    }

    if (!this.main.fileService) {
      throw new Error('FileService is not assigned')
    }

    if (!this.main.userStore.organization.id) {
      throw new Error('Organization is not assigned, use setupUserMetadata()')
    }

    const batchData = (await this.main.fileService?.uploadFiles(
      type,
      hash,
      this.main.userStore.organization.id,
      files,
      workRecordHash,
    )) as FilesBatchPostData[]

    const batchDataRequest = await this.main.batch.batchFiles(batchData)

    if (!batchDataRequest.ok) {
      console.error(batchDataRequest)
      throw new Error('Failed to upload files - BatchFiles failed')
    }

    return batchDataRequest
  }

  async onElementsChange(change: IMapDidChange<string, Element>) {
    if (!this.main.connectivityService?.isConnected) {
      return
    }

    if (change.type === 'add') {
      const element = change.newValue as Element

      if (element.source !== 'offline-cache') {
        this.saveElementToStorage(element)
      }
    }
  }

  async onConnectionChange() {
    // To be sure connection is stable, we wait for a second
    setTimeout(() => {
      if (!this.main.connectivityService?.isConnected) {
        return
      }

      this.syncLocalElements()
    }, 1000)
  }

  async syncLocalElements() {
    if (!this.main.connectivityService?.isConnected) {
      return
    }

    if (this.syncProgress) {
      console.warn('Sync already in progress')
      return
    }

    const promiseAllWithProgress = <T>(
      promises: Promise<T>[],
      onFulfilled: (res: T) => void,
      onRejected?: (err: unknown) => void,
    ) => {
      for (const promise of promises) {
        promise.then(onFulfilled).catch(onRejected)
      }

      return Promise.all(promises)
    }

    // load elements from storage
    const localSaved = await this.main.offlineStore.getLocalElementsList()
    localSaved.forEach((localHash) => {
      if (this.elements.has(localHash)) {
        return
      }

      this.rehydrateElement(localHash)
    })

    const jobs: SyncJobs = Array.from(this.elements).reduce(
      (acc, [, element]) => {
        if (
          instanceOfLocalElement(element) &&
          (element.state === CommitState.STAGED ||
            element.state === CommitState.ERRORED)
        ) {
          console.log(`local element ${element.elementName}`)
          acc.create.push(element)
        } else if (element.dirty) {
          acc.update.push(element)
        }

        return acc
      },
      {
        update: [],
        create: [],
      } as SyncJobs,
    )

    console.log(
      `jobs calculated, createJobs: ${jobs.create.length}, updateJobs: ${jobs.update.length}`,
    )

    const totalJobs = jobs.create.length + jobs.update.length
    if (totalJobs === 0) {
      return
    }
    this.syncProgress = {
      done: 0,
      failed: 0,
      total: jobs.create.length + jobs.update.length,
    }

    // create jobs cannot run in paralel
    await jobs.create.reduce(async (accP: Promise<string[]>, localElement) => {
      const acc = await accP

      console.log(
        `createJob: ${localElement.type}/${localElement.hash}`,
        localElement.data,
      )

      const createdHash = await localElement.publish()

      // Create element failed
      if (!createdHash) {
        console.warn(
          `createJob failed: ${localElement.type}/${localElement.hash}`,
        )
        if (this.syncProgress) {
          // Update progress
          this.syncProgress = {
            ...this.syncProgress,
            failed: this.syncProgress.done + 1,
          }
        }

        return acc
      }

      if (this.syncProgress) {
        // Update progress
        this.syncProgress = {
          ...this.syncProgress,
          done: this.syncProgress.done + 1,
        }
      }
      acc.push(createdHash)

      return acc
    }, Promise.resolve([]))

    // update jobs can run in parallel
    await promiseAllWithProgress<boolean>(
      jobs.update.map((element) => {
        console.log(
          `updateJob: ${element.type}/${element.elementName}`,
          element.data,
        )
        return element.update()
      }),
      (res) => {
        if (this.syncProgress) {
          if (res) {
            this.syncProgress = {
              ...this.syncProgress,
              done: this.syncProgress.done + 1,
            }
          } else {
            this.syncProgress = {
              ...this.syncProgress,
              failed: this.syncProgress.done + 1,
            }
          }
        }
      },
      (err) => {
        console.warn('updateJob failed', err)
        if (this.syncProgress) {
          // Update progress
          this.syncProgress = {
            ...this.syncProgress,
            failed: this.syncProgress.failed + 1,
          }
        }
      },
    )

    if (this.syncProgress.failed > 0) {
      throw new Error(
        `${this.syncProgress.failed} of ${this.syncProgress.total} elements failed to sync`,
      )
    }
    this.syncProgress = undefined
  }

  saveElementToStorage(originalElement: Element) {
    const dehydrated = this.dehydrateElement(originalElement)

    if (!dehydrated) {
      console.warn(`cannot dehydrate element ${originalElement.hash}`)
      return
    }

    // log.debug('dehydrated', dehydrated)

    return this.main.offlineService?.saveElement(
      originalElement.hash,
      dehydrated,
    )
  }

  removeElement(hash: string) {
    return this.main.offlineService?.removeElement(hash)
  }

  dehydrateElement(element: Element): DehydratedElement | undefined {
    if (!element.data || !element.originalData || !element.type) {
      return
    }

    return {
      state: '',
      data: Element.dehydrateData(element.data),
      originalData: Element.dehydrateData(element.originalData),
      type: element.type,
      hash: element.hash,
      childrenData: element.childrenData?.slice(),
      parent: element.parent?.hash,
    }
  }

  async rehydrateElement(hash: string) {
    const elementObject = await this.main.offlineService?.getElement(hash)

    if (!elementObject) {
      return
    }

    // hydrate store, class instance
    const type = elementObject?.type

    if (!type) {
      return
    }

    let element: Element
    if (elementObject.state) {
      let parentElement: Element | undefined = undefined
      if (elementObject.parent) {
        parentElement = this.main.elementStore.elements.get(
          elementObject.parent,
        )
      }

      const instance = this.instantiateLocalElement(
        elementObject.type,
        elementObject.data.organization,
        elementObject.data,
        parentElement,
      )
      instance.state = elementObject.state as unknown as CommitState

      element = instance
    } else {
      // TODO: Similar code to instantiateElement, maybe refactor this?
      const model = this.getModelForElementType(type)
      element = new model(this.main, elementObject.hash, elementObject.data)
    }

    element.originalData = elementObject?.originalData
    element.source = 'offline-cache'

    this.elements.set(elementObject.hash, element)

    return element
  }

  async rehydrateElements() {
    const hashes = await this.main.offlineService?.getElementsList()

    const rehydratingPromises = hashes?.map((hash: string) => {
      // log.debug('rehydrating', hash)
      this.rehydrateElement(hash)
    })

    if (!rehydratingPromises) {
      return
    }

    await Promise.all(rehydratingPromises)
  }

  async batchMetadata(
    elements: Element[],
    attributes: string[],
  ): Promise<BatchMetadata<string> | undefined> {
    const elementMap = elements.reduce(
      (acc: Record<string, Element>, element) => ({
        ...acc,
        [element.hash]: element,
      }),
      {},
    )

    const response = await this.main.batch.getBatchAttributes({
      elements: Object.keys(elementMap),
      metadata: attributes,
    })

    if (!response || !response.ok || !response.data) {
      return
    }

    Object.entries(response.data.elements).forEach(
      ([hash, { element: data }]) => {
        const e = elementMap[hash]

        if (!e) {
          return
        }

        e.extendElementData(data)
      },
    )

    return response.data
  }

  instantiateElementValue(value: AttributeValue): Element[] {
    if (!value) {
      return []
    }

    const arrayValue = castArray(value as (string | ElementData | Element)[])

    return arrayValue
      .map((e) => {
        if (isString(e)) {
          return this.instantiateElement(e, {
            _type: '',
            organization: this.main.userStore.organization.id,
          } as ElementData)
        } else if (e instanceof Element) {
          return e
        } else if (isElementObject(e)) {
          return this.instantiateElement(e.hash, e as ElementData)
        }

        return
      })
      .filter(Boolean) as Element[]
  }

  instantiateElement(
    hash: string,
    data?: ElementData | undefined,
    shouldLoad = false,
    paramOptions: Partial<InstantiateElementOptions> = {},
  ): Element | undefined {
    const options: InstantiateElementOptions = Object.assign(
      {
        setToMemory: true,
        extendWithOlderData: false,
      },
      paramOptions,
    )

    const extendData = (element: Element, freshData?: ElementData) => {
      // Offline cached elements should be updated with fresh data if online.
      if (this.main.connectivityService?.isConnected) {
        // console.log(
        //   `updating element ${element.elementName} with data`,
        //   element.data,
        //   data,
        // )
        // Only update if data is newer
        element.extendElementData(freshData, !options.extendWithOlderData)
      }

      return element
    }

    if (this.elements.has(hash)) {
      const element = this.elements.get(hash)

      if (element) {
        return extendData(element, data)
      }
    }

    // try loading from storage and rehydrate
    // const fromStorage = this.rehydrateElement(hash)

    // if (fromStorage) {
    //   return extendData(fromStorage, data)
    // }

    if (!data || data._type === undefined) {
      // log.debug('NO TYPE PROVIDED', data, hash);
      return
    }

    const typeModel = this.getModelForElementType(data._type)

    const element = new typeModel(this.main, hash, data, shouldLoad)

    if (options.setToMemory) {
      this.elements.set(hash, element)
    }
    return element
  }

  instantiateLocalElement(
    type: string,
    organization: string,
    data?: Omit<ElementData, '_type' | 'organization' | 'hash'>,
    parent?: Element,
  ): LocalElement {
    const typeModel = this.getModelForElementType(type)

    const localModel = isLocal(typeModel)

    const element = new localModel(
      this.main,
      undefined as unknown as string,
      {
        ...(data || {}),
        _type: type,
        organization: organization,
      } as ElementData,
      false,
    )

    if (parent && parent.data && element.data) {
      element.parent = parent
    }

    return element
  }

  instantiateElementWithChildren(elementRaw: ElementRaw) {
    const instance = this.instantiateElement(
      elementRaw.element.hash,
      elementRaw.element,
    )
    if (!instance) {
      throw new Error(
        `Cannot instantiate element ${elementRaw.element._type} ${elementRaw.element.hash}`,
      )
    }

    // We have complete data
    instance.completeData = true
    // insert children
    const children =
      (elementRaw.children
        ?.map((c) => this.instantiateElementWithChildren(c))
        .filter(Boolean) as Element[]) || []

    instance.children = children
    instance.childrenCount = children.length

    return instance
  }

  getModelForElementType(type?: ElementType) {
    if (!type) {
      return Element
    }

    const model = this.main.modelMap.get(type)

    if (model) {
      return model
    }

    const { id: bareType } = urlToSchemaId(type)
    const ALLOWED_BARE_TYPES = [
      RecordModel.TYPE,
      CheckPoint.TYPE,
      CheckList.TYPE,
    ]

    if (ALLOWED_BARE_TYPES.includes(bareType)) {
      const sharedModel = this.main.modelMap.get(bareType)

      if (sharedModel) {
        return sharedModel
      }
    }

    return Element
  }

  async batchUpdateElements(elements: Element[], changes?: ElementFormData) {
    const batchData = elements.reduce(
      (acc: IBatchEditAttributeDataV2[], element) => {
        if (
          !element.data ||
          !element.type ||
          !element.organization ||
          !element.originalData
        ) {
          return acc
        }

        let modifiedData: ElementData = element.data
        if (changes) {
          modifiedData = cloneElementData(element.data)

          Object.entries(changes).forEach(([attribute, value]) => {
            const attr = modifiedData[attribute]

            if (Array.isArray(attr)) {
              return
            }

            if (isFileData(value)) {
              modifiedData[attribute] = value
              return
            }

            if (value === undefined) {
              delete modifiedData[attribute]
              return
            }

            if (attr === undefined) {
              modifiedData[attribute] = {
                value,
                timestamp: dayjs().toISOString(),
                author: {
                  cn: this.main.userStore.user!.cn,
                  uid: this.main.userStore.user!.id,
                  sn: this.main.userStore.user!.sn,
                },
              }
            } else {
              ;(modifiedData[attribute] as AttributeData).value = value
            }
          })
        }

        const original = Element.dehydrateData(element.originalData)
        const modified = Element.dehydrateData(modifiedData)

        const { fileAttributes } = element.getLocalFiles(modified)

        fileAttributes.forEach((attribute) => {
          delete original[attribute]
          delete modified[attribute]
        })
        const elementOperations = this.prepareOperations(
          element.type,
          modified,
          original,
        )

        if (elementOperations.length === 0) {
          return acc
        }

        acc.push({
          element: {
            hash: element.hash,
            type: element.type,
          },
          operations: elementOperations,
          organization: {
            id: element.organization,
          },
        })

        return acc
      },
      [],
    )

    if (batchData.length === 0) {
      return
    }

    const response = await this.main.batch.batchEditAttributesV2(batchData)

    if (!response.ok) {
      // reset elements to original data
      elements.forEach((element) => {
        if (!element.data || !element.originalData) {
          return
        }

        element.data = cloneElementData(element.originalData)
      })

      throw new Error('Failed to batch update elements')
    }

    // Update elements with fresh data
    elements.forEach((element) => {
      if (!element.data) {
        return
      }

      element.originalData = cloneElementData(element.data)
    })

    return response
  }

  async getElementFromHash(
    hash: string,
    options?: { loadFullData?: boolean; forceLoad?: boolean },
  ): Promise<Element> {
    if (this.elements.has(hash)) {
      const element = this.elements.get(hash)

      if (element) {
        return element
      }
    }

    const elementRequest = await this.main.batch.getBatchAttributes({
      elements: [hash],
      metadata: ['element_name', '_type', 'organization'],
    })
    const elementData = elementRequest.data?.elements[hash]

    if (!elementRequest.ok || !elementRequest.data || !elementData) {
      throw new Error('Cannot load element')
    }

    const element = this.instantiateElement(hash, elementData.element)

    if (!element) {
      throw new Error('Cannot load element')
    }

    if (options?.loadFullData) {
      await element?.loadData(options.forceLoad)
    }

    return element
  }

  getElementFromQR = async (url: string): Promise<Element> => {
    const hash = await this.main.elements.getElementHashFromQR(url)

    if (!hash) {
      throw new Error('Cannot resolve QR code')
    }

    return this.getElementFromHash(hash)
  }

  static areAllConditionsMet(
    conditions: ConditionalViewConfig['conditions'],
    element: Element,
  ): boolean {
    if (!conditions) {
      return false
    }
    const conditionsIteratorFn =
      conditions.logicalOperator === 'every'
        ? Array.prototype.every
        : Array.prototype.some

    return conditionsIteratorFn.bind(conditions.items)(
      (condition: ViewConfigCondition) => {
        const predicate = comparisonFuncs[condition.comparsionOperator]
        const actualValue =
          element.getAttributeRawValue(condition.attribute) || ''
        const comparedTemplateValue = condition.comparedValue

        return predicate(actualValue, comparedTemplateValue)
      },
    )
  }

  static getSolvedGroupVisibility(
    group: AttributeGroup,
    element: Element,
  ): boolean {
    const hasVisibilityCustom =
      get(group, 'styles.visibility.type') === 'custom'
    const conditions = get(group, 'styles.visibility.conditions')
    return !hasVisibilityCustom || this.areAllConditionsMet(conditions, element)
  }

  static getSolvedGroupCollapse(
    group: AttributeGroup,
    element: Element,
  ): boolean {
    const isCollapsed =
      get(group, 'styles.collapse.type') === 'collapsed' ||
      get(group, 'styles.showHide.collapsed')
    const isCollapseCustom = get(group, 'styles.collapse.type') === 'custom'
    const conditions = get(group, 'styles.collapse.conditions')
    return (
      isCollapsed ||
      (isCollapseCustom && !this.areAllConditionsMet(conditions, element))
    )
  }

  static getSolvedAttrVisibility(
    attributeDefinition:
      | AttributeDefinition
      | { visibility: ConditionalViewConfig },
    element: Element,
  ): boolean {
    if (!element) {
      return true
    }

    const hasVisibilityCustom =
      get(attributeDefinition, 'visibility.type') === 'custom'
    const conditions = get(attributeDefinition, 'visibility.conditions')
    return !hasVisibilityCustom || this.areAllConditionsMet(conditions, element)
  }

  getAttributeType(
    type: ElementType,
    attributeKey: string,
  ): AttributeType | undefined {
    if (attributeKey === 'timestamp' || attributeKey === 'updatedAt') {
      return AttributeType.DATETIME
    }
    if (
      attributeKey === 'organization' ||
      attributeKey === '_type' ||
      attributeKey === 'hash'
    ) {
      return AttributeType.TEXT
    }
    if (attributeKey === 'author' || attributeKey === 'updatedBy') {
      return AttributeType.USER
    }

    const schemaId = getSchemaId(type)
    const definition = this.elementsTypeDataV1.get(type)
    const schema = this.elementSchemas.get(schemaId)

    if (definition) {
      // TODO: fix this mapping
      return definition?.[attributeKey]?.type as AttributeType
    } else if (schema) {
      const attribute = schema.properties?.[attributeKey]

      if (!attribute) {
        return
      }

      if ((attribute as List)?.type === 'array') {
        return ((attribute as List).items as Reference).$ref?.replace(
          '#',
          '',
        ) as AttributeType
      } else {
        return (attribute as Reference).$ref?.replace('#', '') as AttributeType
      }
    }

    return
  }

  prepareOperations(
    type: ElementType,
    data: ElementAttributeData,
    oldData: ElementAttributeData = {},
  ): Operation[] {
    const addedKeys = difference(Object.keys(data), Object.keys(oldData))
    addedKeys.forEach((key) => {
      const attributeType = this.getAttributeType(type, key)
      if (attributeType === AttributeType.FILE) {
        return
      }

      const attributeData = data[key] as AttributeData
      if (isArrayLike(attributeData.value)) {
        if (attributeType === AttributeType.GEO) {
          return
        }

        const emptyData: AttributeData = {
          value: [],
          author: {
            uid: '',
            cn: '',
            sn: '',
          },
          timestamp: '',
          organization: '',
        }
        oldData[key] = emptyData
      }
    })

    // This is needed to exclude Geo attributes from diff() as they would be parsed as arrays
    const geoAttrs: Record<string, [number, number]> = {}

    const cleanedOldData = Object.entries(oldData).reduce(
      (acc: Record<string, AttributeValue>, [key, attributeData]) => {
        const attributeType = this.getAttributeType(type, key)
        if (attributeType === AttributeType.FILE) {
          return acc
        }

        const value = (attributeData as AttributeData).value
        acc[key] = value

        return acc
      },
      {},
    )

    const cleanedData = Object.entries(data).reduce(
      (acc: Record<string, AttributeValue>, [key, attributeData]) => {
        const attributeType = this.getAttributeType(type, key)
        if (attributeType === AttributeType.FILE) {
          return acc
        }

        const value = (attributeData as AttributeData).value

        if (attributeType === AttributeType.GEO) {
          if (isEqual(cleanedOldData[key], value)) {
            delete cleanedOldData[key]
          } else {
            geoAttrs[key] = value as [number, number]
          }
        } else {
          acc[key] = value
        }

        return acc
      },
      {},
    )
    const operations = createPatch(
      { element: cleanedOldData },
      { element: cleanedData },
    ) as Operation[]

    const multipleAttributes = uniq(
      operations
        .filter((o) => o.path.replace(/[^/]/g, '').length === 3)
        .map(getAttributeNameFromOperation),
    )

    const withoutMultipleOperations = operations.filter(
      (o) => !multipleAttributes.includes(getAttributeNameFromOperation(o)),
    )

    const multipleOperations = multipleAttributes.reduce(
      (accu: Operation[], attributeName) => {
        const added = difference(
          cleanedData[attributeName] as string[],
          cleanedOldData[attributeName] as string[],
        )
        const removed = difference(
          cleanedOldData[attributeName] as string[],
          cleanedData[attributeName] as string[],
        )
        const isPublic =
          (data[attributeName] as AttributeData)?.isPublic || false

        const addOperations = added.map((value) => ({
          op: Operations.ADD,
          path: `/element/${attributeName}/-`,
          value,
          isPublic,
        }))

        const removeOperations: RemoveOperation[] = removed.map((value) => ({
          op: Operations.REMOVE,
          path: `/element/${attributeName}/${value}`,
          isPublic,
        }))

        return [...accu, ...removeOperations, ...addOperations]
      },
      [],
    )

    const completeOperations = withoutMultipleOperations.concat(
      multipleOperations,
      Object.entries(geoAttrs).reduce((acc: Operation[], [key, value]) => {
        acc.push({
          op: Operations.ADD,
          path: `/element/${key}`,
          value,
          isPublic: (data[key] as AttributeData).isPublic,
        })

        return acc
      }, []),
    )

    // THIS IS A workaround TO COMPLY WITH eDocu backend that doesn't respect the RFC6902 spec
    const finalOperations = completeOperations
      .map((operation) => {
        const eDocuOperation = { ...operation } as Operation
        if (operation.op === Operations.REPLACE) {
          eDocuOperation.op = Operations.ADD
        }

        const afterLastSlash = operation.path.substr(
          operation.path.lastIndexOf('/') + 1,
        )
        const attribute = getAttributeNameFromOperation(eDocuOperation)
        const potentialIndex = Number(afterLastSlash)

        // Element hash is 40 characters long, so we need to skip it
        if (!Number.isNaN(potentialIndex) && afterLastSlash.length !== 40) {
          if (eDocuOperation.op === Operations.REMOVE) {
            const oldValue = !isArrayLike(oldData[attribute])
              ? (oldData[attribute] as AttributeData).value
              : undefined
            const hash = (oldValue as AttributeValueMultiple)?.[potentialIndex]

            if (attribute && hash) {
              eDocuOperation.path =
                eDocuOperation.path.substr(
                  0,
                  eDocuOperation.path.lastIndexOf('/'),
                ) +
                '/' +
                hash
            }
          } else {
            // Modify the path to use array append notation '/-' regardless of the index value in ADD operations
            const makeArrayAppendNotation = (path: string) => {
              const parts = path.split('/')
              return parts.slice(0, -1).join('/') + '/-'
            }
            eDocuOperation.path = makeArrayAppendNotation(eDocuOperation.path)
          }
        }

        eDocuOperation.isPublic =
          (data[attribute] as AttributeData)?.isPublic || false

        if (
          eDocuOperation.op !== Operations.REMOVE &&
          isArrayLike(eDocuOperation.value) &&
          eDocuOperation.value.length === 0
        ) {
          return
        }

        return eDocuOperation
      })
      .filter(Boolean) as Operation[]

    if (finalOperations.length > 0) {
      log.debug('cleanedOldData', JSON.stringify(cleanedOldData, null, 2))
      log.debug('cleanedData', JSON.stringify(cleanedData, null, 2))
      log.debug('operations', JSON.stringify(finalOperations, null, 2))
    }

    return finalOperations
  }

  async loadAndPersistBatchElements(
    hashes: string[],
    projection: string[] = [],
    paramOptions?: { setToMemory?: boolean },
  ): Promise<Element[]> {
    const options = Object.assign({}, { setToMemory: false }, paramOptions)
    const chunked = chunk(hashes, MAX_PER_BATCH)
    const result: Element[] = []

    log.debug(`Loaded ${hashes.length} elements, ${chunked.length} pages.`)

    for (
      let index = 0;
      index < Math.ceil(hashes.length / MAX_PER_BATCH);
      index++
    ) {
      const currentChunk = chunked[index]

      const response = await this.main.batch.getBatchAttributes({
        elements: currentChunk,
        metadata: projection, //empty array gets all attributes
      })

      if (!response.ok || !response.data) {
        throw new Error(
          'Unable to load batch metadata. You can retry this action.',
        )
      }

      const elementsP = Object.values(response.data.elements).map(
        ({ element: elementData, children }) => {
          const element = this.instantiateElement(
            elementData.hash,
            elementData,
            false,
            { setToMemory: options.setToMemory },
          )

          if (!element) {
            return
          }

          if (children) {
            element.childrenData = children
          }

          result.push(element)

          return this.main.elementStore.saveElementToStorage(element)
        },
      )

      await Promise.all(elementsP)
    }

    return result
  }

  applyPatchToElement(element: Element, operations: Operation[]) {
    if (!element.data) {
      return
    }

    // console.time('applyPatchToElement')

    // console.time('dehydrate')
    const parsedElement = Element.dehydrateDataAndUnwrapValues(element.data)

    if (element.type === Ticket.TYPE) {
      // This is needed as a backware compatibility for old tickets
      Object.assign(
        parsedElement,
        Ticket.dehydrateTicketData((element as Ticket).ticketData),
      )
    }
    // console.timeEnd('dehydrate')

    // console.time('getPatchedElementFromOperations')
    const patchedElement = getPatchedElementFromOperations(
      operations,
      parsedElement as unknown as ElementFormData,
    )
    // console.timeEnd('getPatchedElementFromOperations')

    const autoSave = element.autoSave
    element.autoSave = false

    // console.time('setValues')
    const newElementData = pick(
      patchedElement.element,
      uniq(
        operations.map((operation) => getAttributeNameFromOperation(operation)),
      ),
    )
    element.setAttributes(newElementData)
    // console.timeEnd('setValues')

    if (element.data) {
      // console.time('cloneElementData originalData')
      element.originalData = cloneElementData(element.data)
      // console.timeEnd('cloneElementData originalData')
    }

    element.updateDataHash()
    element.autoSave = autoSave

    // console.time('saveElementToStorage')
    this.saveElementToStorage(element)
    // console.timeEnd('saveElementToStorage')

    // console.timeEnd('applyPatchToElement')
  }

  subscribeToElementUpdates(element: Element): (() => void) | undefined {
    const topic = element.getChangeListenerTopic()

    if (!topic) {
      log.warn(`tried to subscribe to element ${element.hash} without topic`)
      return noop
    }

    const ref = this.main.notificationStore.subscribe(
      topic,
      (data: Operation[]) => {
        const id = data.find((op) => op.path === '/id')

        // Prevent processing duplicate events
        if (id && id.op === 'replace' && id.value) {
          if (this.socketEventIds.includes(id.value as string)) {
            log.debug(`skipping element change notification ${topic}`)
            return
          } else {
            this.socketEventIds.push(id.value as string)
          }
        }

        const onlyElementOperations = data.filter(
          (op) => op.path && op.path.startsWith('/element'),
        )

        // log.debug(`received element change notification ${topic}`)
        this.applyPatchToElement(element, onlyElementOperations)
      },
    )

    return ref
      ? () => this.main.notificationStore.unsubscribe(topic, ref)
      : undefined
  }

  computeElementDataHash(data: ElementData) {
    const modified = Element.dehydrateData(data)
    const newHash = CryptoJS.MD5(JSON.stringify(modified)).toString()

    return newHash
  }

  getFilesWithUniqNames(attributeValue: AttributeFileData) {
    const [remoteFiles, localFiles] = partition(attributeValue, isRemoteFile)
    const localFileNames = localFiles.map(({ data }) =>
      'file' in data ? data.file.name : data.name,
    )

    const { added, conflictHashes } = findFileNameConflicts(
      this.main.userStore.organization.id,
      remoteFiles,
      localFileNames,
    )

    return {
      localFiles: localFiles.map((file, index) =>
        'file' in file.data
          ? set(
              file,
              'data.file',
              new File([file.data.file], added[index], {
                type: file.data.file.type,
              }),
            )
          : set(file, 'data.name', added[index]),
      ),
      conflictHashes,
    }
  }
}

export const getTemplateId = (
  schemaId: SchemaId,
  templateId = DEFAULT_TEMPLATE_ID,
): $SchemaIdTemplate => {
  return `#${schemaId}/${templateId}`
}