import mudder from 'mudder'
import qs from 'query-string'
import sanitizeHtml from 'sanitize-html'
import SDKAdapter from '../core/adapter.js'
import { SDKCollection } from '../core/collection.js'
import { SDKModel } from '../core/model.js'
import { Atleast, Optional, RequiredKeys } from '../utils/typescript.js'
import { SDKModelSchema } from '../core/schema.js'
import { nanoid } from '../core/transport.js'
import versionSchema from '../schemas/version.json' assert { type: 'json' }
import type { SDK } from '../sdk.js'
import * as Style from '../style/index.js'
import { isDeepEquals } from '../utils/object.js'
import type { CollectionModel } from './collections.js'
import type { ComponentModel } from './components.js'
import type { LibraryModel, NanoId } from './libraries.js'
import { DataOptionsById, DatasourceModel } from './datasources.js'
import type { VersionBundle } from './version-bundles.js'

/** Defines the schema for Version. */
export interface Version {
  /** The identifier of the Library that Version belongs to */
  libraryId: NanoId

  /** The reference identifer of the Version */
  id: NanoId

  /** The identifier of the Component that Version belongs to */
  componentId: NanoId

  /**
   * The name of the Version.
   *
   * @minLength 1
   * @maxLength 128
   */
  name: string

  /** Textual description of the Version. */
  description?: string

  /** The status of the Version */
  status: 'published' | 'draft' | 'staged' | 'saved'

  /**
   * The order index of the Version.
   *
   * @minLength 1
   * @maxLength 64
   */
  orderIdx?: string

  /**
   * The numerc revision of the Version.
   *
   * @minimum 0
   * @TJS-type integer
   */
  revision: number

  /** The model presentation of the Version */
  model?: string

  /**
   * The view presentation of the Version.
   *
   * @minLength 1
   */
  view: string

  /** The difference between current and previous version of the Version */
  diff?: object

  /**
   * List of ids of applicable breakpoints. Null if all breakpoints are applicable.
   *
   * @nullable
   */
  breakpointIds?: string[]

  /**
   * The identifiers of the datasources for this Version.
   *
   * @items.type string
   */
  datasourceIds?: string[]

  /** Allow version to be embeddable on its own, not as a part of responsive bundle */
  isEmbeddable?: boolean

  /**
   * Id of a version that was used as a base for the fork.
   *
   * @nullable
   */
  forkOriginId?: NanoId
  /**
   * Revision of a version that was used as a base for the fork.
   *
   * @nullable
   * @minimum 0
   * @TJS-type integer
   */
  forkOriginRevision?: number

  /**
   * Time when the version was first forked.
   *
   * @nullable
   */
  forkedAt?: Date

  /**
   * Array of extra css classes applied to the version.
   *
   * @nullable
   */
  classList?: string[]

  /** The timestamp when the Version was created at */
  createdAt?: Date

  /**
   * The timestamp when the Version was deleted at.
   *
   * @nullable
   */
  deletedAt?: Date

  /** The timestamp when the Version was last modified at */
  modifiedAt?: Date

  /** The User who last modified the Version */
  modifiedBy?: object
}

export interface VersionSnapshot {
  id: VersionModel['id']
  head?: VersionModel
  previous?: VersionModel
  draft?: VersionModel
  saved?: VersionModel
  staged?: VersionModel
  published?: VersionModel
  revisions: VersionModel[]
}

const allowedTags = [
  ...sanitizeHtml.defaults.allowedTags,
  'button',
  'picture',
  'img',
  'svg',
  'g',
  'path',
  'defs',
  'linearGradient',
  'stop',
  'circle',
  'style',
  'feaas-component',
  'feaas-external',
  'feaas-stylesheet'
]

const CustomAttributes = [
  'data',
  'data-attributes',
  'data-embed-html',
  'data-embed-title',
  'data-embed-src',
  'data-embed-as',
  'data-external-id',
  'component',
  'cdn',
  'version',
  'revision',
  'hostname',
  'hidden'
]

const nonBooleanAttributes = [...sanitizeHtml.defaults.nonBooleanAttributes, ...CustomAttributes]

const allowedAttributes = {
  ...sanitizeHtml.defaults.allowedAttributes,
  '*': ['class', 'style', 'id', 'data-*', ...CustomAttributes],
  path: ['d', 'fill', 'fill-rule', 'clip-rule'],
  'feaas-external': ['*'],
  'feaas-component': ['*'],
  'feaas-stylesheet': ['*']
}

export class Versions extends SDKAdapter<Version> {
  search(version: Pick<VersionParams, 'libraryId'>, query?: any): Promise<Version[]> {
    const { libraryId } = version
    return this.sdk.fetchJSON(`/libraries/${libraryId}/versions?${qs.stringify(query)}`)
  }
  get(
    version: Pick<VersionParams, 'libraryId' | 'collectionId' | 'componentId' | 'id' | 'status' | 'revision'>
  ): Promise<Version> {
    const { libraryId, collectionId, componentId, id, status, revision } = version
    return this.sdk.fetchJSON(
      `/libraries/${libraryId}/collections/${
        collectionId || 'unspecified'
      }/components/${componentId}/versions/${id}?status=${status}&revision=${revision}`
    )
  }
  fetch(version: Pick<VersionParams, 'libraryId' | 'collectionId' | 'componentId'>): Promise<Version[]> {
    const { libraryId, collectionId, componentId } = version
    return this.sdk.fetchJSON(
      `/libraries/${libraryId}/collections/${collectionId || 'unspecified'}/components/${componentId}/versions?` +
        Math.random()
    )
  }
  post(
    version: Optional<Version, 'componentId' | 'id' | 'revision'> &
      Atleast<VersionParams, 'libraryId' | 'collectionId' | 'componentId'>
  ) {
    const { libraryId, collectionId, componentId } = version
    return this.sdk.fetchJSON(
      `/libraries/${libraryId}/collections/${collectionId || 'unspecified'}/components/${componentId}/versions`,
      {
        method: 'POST',
        body: JSON.stringify(version)
      }
    )
  }
  put(
    version: Optional<Version, 'componentId' | 'revision'> &
      Atleast<VersionParams, 'libraryId' | 'collectionId' | 'componentId'>
  ) {
    return this.post(version)
  }
  delete(version: Atleast<VersionParams, 'libraryId' | 'collectionId' | 'componentId'>) {
    const { libraryId, collectionId, componentId, id, status, revision } = version
    return this.sdk.fetchJSON(
      `/libraries/${libraryId}/collections/${
        collectionId || 'unspecified'
      }/components/${componentId}/versions/${id}?status=${status}&revision=${revision}`,
      {
        method: 'DELETE',
        headers: { 'Content-Type': 'text/plain' }
      }
    )
  }
  prune({ libraryId, componentId, id }: Partial<Pick<Version, 'libraryId' | 'componentId' | 'id'>> = {}) {
    // not implemented on clientside
  }
}

function getVersionDefaults(sdk: SDK) {
  const now = new Date()
  return {
    id: nanoid(10),
    orderIdx: '',
    revision: 0,
    createdAt: now,
    modifiedAt: now,
    deletedAt: null as Date,
    modifiedBy: sdk?.auth?.getUser() || {},
    datasourceIds: [] as Style.RuleId[],
    breakpointIds: null as Style.RuleId[],
    classList: ['-theme--default'] as string[],
    view: '<section class="-section -grid--custom"></section>',
    model: '',
    diff: {},
    status: 'draft'
  }
}
export type VersionMinimal<T extends keyof Version = never> = RequiredKeys<Version, typeof getVersionDefaults, T>
export interface VersionImplicit {
  library?: LibraryModel
  libraryId: LibraryModel['id']
  collectionId?: CollectionModel['id']
  collection?: CollectionModel
  componentId: ComponentModel['id']
  component?: ComponentModel
  bundle?: VersionBundle
  bundleId?: VersionBundle['id']
}
export interface VersionParams extends Version, VersionImplicit {}
export interface VersionModel extends VersionParams {}
export class VersionModel extends SDKModel<Version, VersionMinimal, VersionImplicit> implements VersionParams {
  error?: Error
  get adapter() {
    return this.sdk.Versions
  }
  getId() {
    return this.componentId + ':' + this.id + ':' + this.revision + ':' + this.status
  }

  getHiddenProps(): string[] {
    return ['library', 'collectionId', 'collection', 'component']
  }
  getDefaults(sdk: SDK) {
    return getVersionDefaults(sdk)
  }

  getThumbnailURL() {
    return `${this.sdk.cdn}/thumbnails/${this.libraryId}/${this.componentId}/${this.id}.jpg`
  }

  defineProperties() {
    super.defineProperties()
    this.sdk.utils.defineAccessor(this, 'view', {}, this.getHiddenProps())
  }

  /** View needs to be wrapped into <section> */
  _view: string
  get view() {
    return this._view
  }

  isViewEmpty() {
    return this.view.match(/^<section[^>]*><\/section>$/i)
  }

  /** Normalizes html, extracts used datasources */
  set view(value: string) {
    if (typeof value == 'string') {
      value = this.normalizeView(value)
      this.datasourceIds = this.getDatasourcesFromView(value)
    }
    this._view = value
  }

  /** Extract all datasource ids from view used in data-path-* attributes */
  getDatasourcesFromView(view: string) {
    const set = new Set<string>()
    view.replace(/(data-path[a-z-]*)="([a-z0-9-_]+)[^"]*"/gi, (m, attribute, datasourceId) => {
      if (attribute != 'data-path-placeholder') set.add(datasourceId)
      return m
    })
    return Array.from(set)
      .filter((v) => Boolean(v))
      .sort()
  }

  /**
   * Transform view minimally to help reduce amount of revisions. It tries to bring HTML to a canonical version, so that
   * things like different order of classes will not be considered a different version
   */
  normalizeView(view: string) {
    // ensure there's wrapping section element
    if (!view.match(/^[\s\n]*(<section|<style)/i) && this.id != 'responsiv') {
      view = `<section class="-section">${view}</section>`
    }
    return this.sdk.normalizeHTML(view)
  }

  /** Combine view, classes and themes */
  getHTML(extraClasses: string[] = []) {
    return `<div class="${[...this.classList, ...extraClasses].join(' ')}">${this.view}</div>`
  }

  /** Get latest revisions of a version matching given statuses (or first) */
  getCurrent(statuses?: Version['status'][] | Version['status']) {
    return this.component.findVersion(this.id, [statuses || []].flat())
  }

  /** Get settings for all datasoruces used in version */
  getDataSettings(): DataOptionsById | null {
    return DatasourceModel.getSettingsFromDatasources(this.datasourceIds, this.sdk.datasources)
  }

  /** Get current draft or create a new one */
  getDraft() {
    const current = this.getCurrent()
    if (current.status == 'draft') {
      return current
    } else {
      return current.produceNewVersion({
        ...current,
        modifiedBy: this.sdk.auth.getUser() || current.modifiedBy,
        modifiedAt: new Date(),
        revision: current.revision + 1,
        deletedAt: null,
        status: 'draft'
      })
    }
  }

  /**
   * Use current revision as a basis to create an entirely new one-off version. Used for for in-place editing of
   * components.
   */
  fork(id = this.sdk.nanoid()) {
    if (this.forkOriginId) {
      return this
    }
    return this.produceNewVersion({
      id: id,
      forkedAt: new Date(),
      forkOriginId: this.id,
      forkOriginRevision: this.revision,
      modifiedBy: this.sdk.auth.getUser()
    })
  }

  /** Return to the shared version of a component. The fork will be marked as deleted. */
  unfork() {
    if (!this.forkOriginId) {
      return this
    }
    return this.archive()
  }

  /** Create new version based on the current with new ID */
  produceNewVersion(data?: Partial<Version>) {
    const { modifiedBy, ...rest } = this
    return this.component.versions.add({
      ...rest,
      ...data
    })
  }

  /**
   * Creates new instance of a version revision if any data has changed.
   *
   * ! Replaces it in the collection to notify observers
   */
  changeAndNotify(data: Partial<Version>) {
    var start = data.view == null || this.compareProp('view', data.view, this.view) ? this : this.getDraft()
    const changed = start.change(data)
    if (changed != start) {
      this.component.versions.upsertItem(changed)
    }
    return changed
  }

  /** Move version after another matching given id (or to the top if null) */
  move(anchorId: Version['id'], position: 'before' | 'after' = 'before') {
    if (!anchorId) {
      const versions = this.component.getVersions()
      if (position == 'after') {
        anchorId = versions[0]?.id
        position = 'before'
      } else {
        anchorId = versions[versions.length - 1]?.id
      }
    }
    const previous = this.component.findVersion(anchorId)
    const neighbours = this.component.getNeighbourVersions(anchorId)
    const orderIdx =
      position == 'before'
        ? VersionModel.getVersionOrderIdx(neighbours[0], previous)
        : VersionModel.getVersionOrderIdx(previous, neighbours[1])
    return this.getCurrent().changeAndNotify({ orderIdx })
  }

  /** Soft-delete saved version, discards draft */
  archive() {
    const draft = this.getCurrent('draft')
    const saved = this.getCurrent('saved')
    if (draft && (!saved || draft.revision > saved.revision)) {
      draft.discard()
    }
    if (saved) {
      return saved.changeAndNotify({ deletedAt: new Date() })
    }
    return this
  }

  compareProp(property: keyof this, left: any, right: any) {
    if (property == 'view' && left != null && right != null) {
      return this.normalizeView(left) == this.normalizeView(right)
    }
    return super.compareProp(property, left, right)
  }

  /** Soft-undelete version */
  restore() {
    const saved = this.getCurrent('saved') || this.getCurrent('draft')
    return saved.changeAndNotify({ deletedAt: null })
  }

  /** Set version size breakpoints and commit as new revision */
  setBreakpointIds(breakpointIds: Version['breakpointIds']) {
    this.getDraft().changeAndNotify({ breakpointIds })
  }

  /** Creates new version with provided combo */
  setClassList(classList: string[]) {
    return this.getDraft().changeAndNotify({
      classList: classList
    })
  }

  /** Set current view/model data to version. Ensures that there is a draft, in case given data has changes */
  commitData({ view, model }: { view: Version['view']; model: Version['model'] }) {
    if (this.error) return

    const last = this.getCurrent()
    if (last.view != view || last.model != model) {
      return this.getDraft().changeAndNotify({
        modifiedBy: this.sdk.auth.getUser(),
        modifiedAt: new Date(),
        view,
        model
      })
    }
    return this
  }

  /** Commits given data a new saved revision if there were an changes */
  saveData(data?: Atleast<Version, 'view' | 'model' | 'breakpointIds'>) {
    if (this.error) return
    const last = this.getCurrent()
    if (last && last.status == 'draft' && last.deletedAt != null) {
      return
    }
    if (!data) data = last
    const { view: dirtyView, model } = data

    // Pre-process: temporarily replace empty href with a placeholder
    const preprocessed = dirtyView.replace(/href=""/g, 'href="__EMPTY_HREF__"')

    const cleanView = sanitizeHtml(preprocessed, {
      allowedTags,
      nonBooleanAttributes,
      allowedAttributes,
      allowVulnerableTags: true // allow <style> tags in view which are generated by us and contain the CSS
    })

    // Post-process: restore empty href attributes
    const view = cleanView.replace(/href="__EMPTY_HREF__"/g, 'href=""')

    if (
      last &&
      (last.status == 'draft' ||
        last.model != model ||
        !this.compareProp('view', last.view, view) ||
        !isDeepEquals(last.breakpointIds, this.breakpointIds))
    ) {
      last.produceNewVersion({
        view,
        model,
        breakpointIds: !this.breakpointIds?.length ? null : this.breakpointIds,
        revision: last.status == 'draft' ? last.revision : last.revision + 1,
        modifiedBy: this.sdk.auth.getUser(),
        modifiedAt: new Date(),
        status: 'saved'
      })
    }
    return this
  }

  /** Create a separate version starting from first revision, but based on given one */
  duplicate() {
    const version = this.getCurrent()
    const neighbours = this.component.getNeighbourVersions(version.id)
    const now = new Date()
    return version.produceNewVersion({
      name: `${version.name} - Copy`,
      revision: 0,
      id: nanoid(10),
      modifiedBy: this.sdk.auth.getUser(),
      modifiedAt: now,
      createdAt: now,
      status: 'draft',
      orderIdx: VersionModel.getVersionOrderIdx(version, neighbours[1])
    })
  }

  /** Change name of version (does not create new revision) */
  rename(name: Version['name']) {
    this.getCurrent().changeAndNotify({ name })
  }

  setIsEmbeddable(isEmbeddable: Version['isEmbeddable']) {
    this.getCurrent('saved')?.changeAndNotify({ isEmbeddable })
    this.getCurrent('staged')?.changeAndNotify({ isEmbeddable })
    this.getCurrent('published')?.changeAndNotify({ isEmbeddable })
  }

  /** Create a staged revision based on current one. Ensures that it's not soft-deleted */
  stage() {
    var version = this.getCurrent()
    var lastStaged = this.getCurrent('staged')
    if (lastStaged?.revision == version.revision) {
      return lastStaged.changeAndNotify({
        deletedAt: null,
        name: version.name,
        orderIdx: version.orderIdx
      })
    } else {
      return version.produceNewVersion({
        status: 'staged',
        deletedAt: null,
        modifiedBy: this.sdk.auth.getUser()
      })
    }
  }

  /** Soft-deletes staged revision */
  unstage() {
    return this.getCurrent('staged').changeAndNotify({
      deletedAt: new Date()
    })
  }

  /** Create a published revision based on current one */
  /** Ensures that it's not soft-deleted */
  publish() {
    var version = this.getCurrent()
    var lastPublished = this.getCurrent('published')
    if (lastPublished?.revision == version.revision) {
      return lastPublished.changeAndNotify({
        deletedAt: null,
        name: version.name,
        orderIdx: version.orderIdx
      })
    } else {
      return version.produceNewVersion({
        status: 'published',
        deletedAt: null,
        modifiedBy: this.sdk.auth.getUser()
      })
    }
  }

  /** Soft-deletes published revision */
  unpublish() {
    return this.getCurrent('published').changeAndNotify({
      deletedAt: new Date()
    })
  }

  /** Discards the draft, removes it from revision list */
  discard() {
    if (this.status != 'draft') {
      throw new Error('Only drafts can be discarded')
    }
    this.component.versions.removeItem(this)
    return this
  }

  /** Revert current changes to last published/staged one */
  revertTo(revision: VersionModel) {
    const draft = this.getCurrent('draft')
    if (draft) {
      draft.discard()
    }
    const saved = this.getCurrent('saved')
    if (!revision.deletedAt && saved.revision > revision.revision) {
      return saved.getDraft().changeAndNotify(revision.toProperties())
    }
  }

  toProperties() {
    return {
      view: this.view,
      model: this.model,
      breakpointIds: this.breakpointIds
    }
  }

  revert() {
    const draft = this.getCurrent('draft')
    const saved = this.getCurrent('saved')
    if (!draft && !saved) return
    const published = this.getCurrent('published')
    const staged = this.getCurrent('staged')

    if (published?.revision >= staged?.revision) {
      this.revertTo(published)
    } else if (staged) {
      this.revertTo(staged)
    } else {
      return draft.changeAndNotify({
        view: '',
        model: ''
      })
    }
  }

  isDifferentFrom(other: Version) {
    return (
      this.name !== other.name ||
      this.description !== other.description ||
      this.isEmbeddable !== other.isEmbeddable ||
      this.status !== other.status ||
      this.classList?.slice().join(',') !== other.classList?.slice().join(',') ||
      this.orderIdx !== other.orderIdx ||
      this.datasourceIds?.slice().sort().join(',') !== other.datasourceIds?.slice().sort().join(',') ||
      String(this.deletedAt) !== String(other.deletedAt)
    )
  }

  getBreakpoints() {
    const stylesBreakpoints = this.library.stylesheet.rules.filter((s) => s.type == 'breakpoint')
    return (
      this.breakpointIds?.length
        ? stylesBreakpoints.filter((breakpoint) => this.breakpointIds.includes(breakpoint.details.id))
        : stylesBreakpoints
    ).filter(Boolean) as Style.Rule<'breakpoint'>[]
  }

  getDatasources() {
    return this.datasourceIds
      .map((datasourceId) => this.sdk.datasources.find((d) => d.id == datasourceId))
      .filter(Boolean)
  }

  matchBreakpoint(breakpoint: Style.Rule<'breakpoint'>, targetWidth: number) {
    return targetWidth >= breakpoint.props.minWidth && targetWidth <= breakpoint.props.maxWidth
  }

  matchesSearch(search: string) {
    return this.name.toLowerCase().includes(search.toLowerCase())
  }

  static getOrderedBreakpoints(
    targetWidth: number,
    breakpointsArray: Style.RuleWithProps<'breakpoint', { minWidth: number; maxWidth: number; query: string }>[]
  ) {
    const breakpoints = [...breakpointsArray]
    const getBreakpointScore = (b: Style.Rule<'breakpoint'>) =>
      // find distance to closest boundary
      Math.min(Math.abs(targetWidth - b.props.minWidth), Math.abs(targetWidth - b.props.maxWidth)) +
      // prefer breakpoints that fit within the screen
      (b.props.minWidth <= targetWidth ? 0 : 1000)
    return breakpoints.sort((a, b) => getBreakpointScore(a) - getBreakpointScore(b))
  }
  getMatchingBreakpoint(targetWidth: number) {
    const breakpoints = this.getBreakpoints()

    // find corresponding breakpoint for window width
    let match = breakpoints.find((b) => this.matchBreakpoint(b, targetWidth))
    if (match) {
      return match
    }

    // if no breakpoints for current window width, select the closest one
    return VersionModel.getOrderedBreakpoints(targetWidth, breakpoints)[0]
  }

  getUsedComboIds() {
    return this.classList.map((className) => className.replace('-use--', ''))
  }

  getLastPushed() {
    const published = this.getCurrent('published')
    const staged = this.getCurrent('staged')
    return published?.revision > staged?.revision ? published : staged
  }

  needsStaging() {
    const staged = this.getCurrent('staged')
    const current = this.getCurrent()
    return !staged || current.revision > staged.revision || !!staged.deletedAt
  }

  needsPublishing() {
    const published = this.getCurrent('published')
    const current = this.getCurrent()
    return !published || current.revision > published.revision || !!published.deletedAt
  }

  isDeleted() {
    return (this.getCurrent('saved') || this.getCurrent('draft'))?.deletedAt != null
  }

  getThemeSlug() {
    return Style.ClassList.getThemeSlug(this.classList)
  }

  toStyleContext() {
    return {
      name: 'version',
      getAttribute: (name: string) => {
        if (name == 'class') {
          return this.classList.join(' ')
        }
        return null
      }
    }
  }

  static getOrderedVersions(versions: VersionModel[]) {
    return this.reduceVersionRevisions(versions)
      .map((snapshot) => snapshot.head)
      .sort((a, b) => a.sortCompare(b))
  }

  static getVersionOrderIdx(left: Version, right: Version) {
    const leftIdx = left?.orderIdx || ''
    const rightIdx = right?.orderIdx || ''
    return mudder.base62.mudder(leftIdx, rightIdx, 1, undefined, 1000, 4)[0] || ''
  }

  // use orderIdx string for sorting
  sortCompare(other: this): number {
    return this.orderIdx > other.orderIdx ? 1 : this.orderIdx < other.orderIdx ? -1 : 0
  }

  /** Find all unique in html and generate new ones, fix references */
  static getUniqueHTML(view: string, map: Record<string, string> = {}) {
    var replaced = view.replace(/(data-symbol-id|data-instance-id)="([^"]+?)"/g, (m, attribute, id) => {
      map[id] ||= nanoid(10)
      return `${attribute}="${map[id]}"`
    })
    return Object.keys(map).reduce((current, id) => {
      while (true) {
        const replaced = current
          .replace(new RegExp(`"${id}"`), `"${map[id]}"`)
          .replace(new RegExp(`Id: ${id}`), `Id: ${map[id]}`)
        if (replaced == current) {
          break
        }
        current = replaced
      }
      return current
    }, replaced)
  }

  static statuses = ['published', 'staged', 'saved', 'draft']
  static sortVersionRevisions(revisions: VersionModel[]) {
    return revisions.sort((a, b) => {
      return (
        a.id.localeCompare(b.id) ||
        Number(b.revision) - Number(a.revision) /** Higher revision first */ ||
        VersionModel.statuses.indexOf(a.status) -
          VersionModel.statuses.indexOf(b.status) /** Published first, draft last */ ||
        Number(a.createdAt) - Number(b.createdAt)
      )
    })
  }
  static reduceVersionRevisions(revisions: VersionModel[]) {
    return this.sortVersionRevisions(revisions)
      .reduce((snapshots, revision) => {
        var snapshot = snapshots.find((snapshot) => snapshot.id == revision.id)
        if (!snapshot) {
          snapshot = { id: revision.id, revisions: [] }
          snapshots.push(snapshot)
        }

        snapshot.revisions.push(revision)
        if (!snapshot[revision.status]) snapshot[revision.status] = revision
        if (!snapshot.head) snapshot.head = revision
        if (revision.status != 'draft' && !snapshot.previous) snapshot.previous = revision
        return snapshots
      }, [] as VersionSnapshot[])
      .sort((a, b) => a.head.sortCompare(b.head))
  }
  static onCollectionChange(versions: SDKCollection<typeof VersionModel>) {
    return this.sortVersionRevisions(versions)
  }

  getPath() {
    return `/libraries/${this.libraryId}/collections/${this.collectionId}/components/${this.componentId}/versions/${this.id}`
  }

  getSourcePath() {
    return `${this.libraryId}/${this.componentId}/${this.id}/${this.status}.html`
  }

  static get schema(): SDKModelSchema<typeof VersionModel, Version> {
    return new SDKModelSchema(VersionModel, versionSchema)
  }
}