import { ChangeSet, Text } from '@codemirror/state';
import {EditorView} from "codemirror"
import { Update, collab, getSyncedVersion, receiveUpdates, sendableUpdates } from '@codemirror/collab';
import { ViewPlugin, ViewUpdate } from '@codemirror/view';

export class Connection {
  private requestId = 0;
  private resolves: Record<number, (value: any) => void> = {};

  constructor(private client: WebSocket) {
    client.addEventListener('message', (event) => {
      const response = JSON.parse(event.data);
      if ('_request' in response) {
        const resolve = this.resolves[response._request];
        if (resolve) {
          resolve(response.payload);
        } else {
          console.error('Received response for unknown or already used request', response._request);
        }
      } else {
        console.error('Received invalid response', response._request);
      }
    })
  }

  request(body: Record<string, unknown>): Promise<any> {
    body['_request'] = this.requestId;
    this.client.send(JSON.stringify(body));
    return new Promise((resolve) => this.resolves[this.requestId++] = resolve);
  }
}

function pushUpdates(
  connection: Connection,
  version: number,
  fullUpdates: readonly Update[]
): Promise<boolean> {
  // Strip off transaction data
  let updates = fullUpdates.map(u => ({
    clientID: u.clientID,
    changes: u.changes.toJSON()
  }));
  return connection.request({type: "pushUpdates", version, updates});
}

function pullUpdates(
  connection: Connection,
  version: number
): Promise<readonly Update[]> {

  return connection.request({type: "pullUpdates", version})
    .then(updates => updates.map((u: any) => ({
      changes: ChangeSet.fromJSON(u.changes),
      clientID: u.clientID
    })));
}

export function getDocument(
  connection: Connection
): Promise<{version: number, doc: Text}> {

  return connection.request({ type: "getDocument" }).then(data => ({
    version: data.version,
    doc: Text.of(data.doc.split("\n"))
  }));
}

export function peerExtension(startVersion: number, connection: Connection) {
  let plugin = ViewPlugin.fromClass(class {
    private pushing = false
    private done = false

    constructor(private view: EditorView) { this.pull() }

    update(update: ViewUpdate) {
      if (update.docChanged) this.push()
    }

    async push() {
      let updates = sendableUpdates(this.view.state)

      if (this.pushing || !updates.length) return
      this.pushing = true
      let version = getSyncedVersion(this.view.state)
      await pushUpdates(connection, version, updates)
      this.pushing = false
      // Regardless of whether the push failed or new updates came in
      // while it was running, try again if there's updates remaining
      if (sendableUpdates(this.view.state).length)
        setTimeout(() => this.push(), 100)
    }

    async pull() {
      while (!this.done) {
        let version = getSyncedVersion(this.view.state)
        let updates = await pullUpdates(connection, version)
        this.view.dispatch(receiveUpdates(this.view.state, updates))
      }
    }

    destroy() { this.done = true }
  })
  return [collab({startVersion}), plugin]
}