/* eslint-disable
    no-cond-assign,
    no-return-assign,
    no-undef,
    no-unused-vars,
*/
// TODO: This file was created by bulk-decaffeinate.
// Fix any style issues and re-enable lint.
/*
 * decaffeinate suggestions:
 * DS101: Remove unnecessary use of Array.from
 * DS102: Remove unnecessary code created because of implicit returns
 * DS103: Rewrite code to no longer use __guard__
 * DS205: Consider reworking code to avoid use of IIFEs
 * DS207: Consider shorter variations of null checks
 * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
 */
// A TP2 implementation of text, following this spec:
// http://code.google.com/p/lightwave/source/browse/trunk/experimental/ot/README
//
// A document is made up of a string and a set of tombstones inserted throughout
// the string. For example, 'some ', (2 tombstones), 'string'.
//
// This is encoded in a document as: {s:'some string', t:[5, -2, 6]}
//
// Ops are lists of components which iterate over the whole document.
// Components are either:
//   N:         Skip N characters in the original document
//   {i:'str'}: Insert 'str' at the current position in the document
//   {i:N}:     Insert N tombstones at the current position in the document
//   {d:N}:     Delete (tombstone) N characters at the current position in the document
//
// Eg: [3, {i:'hi'}, 5, {d:8}]
//
// Snapshots are lists with characters and tombstones. Characters are stored in strings
// and adjacent tombstones are flattened into numbers.
//
// Eg, the document: 'Hello .....world' ('.' denotes tombstoned (deleted) characters)
// would be represented by a document snapshot of ['Hello ', 5, 'world']

let append, appendDoc, takeDoc;
var type = {
  name: 'text-tp2',
  tp2: true,
  create() { return {charLength:0, totalLength:0, positionCache:[], data:[]}; },
  serialize(doc) {
    if (!doc.data) { throw new Error('invalid doc snapshot'); }
    return doc.data;
  },
  deserialize(data) {
    const doc = type.create();
    doc.data = data;
    
    for (const component of Array.from(data)) {
      if (typeof component === 'string') {
        doc.charLength += component.length;
        doc.totalLength += component.length;
      } else {
        doc.totalLength += component;
      }
    }
    
    return doc;
  }
};


const checkOp = function(op) {
  if (!Array.isArray(op)) { throw new Error('Op must be an array of components'); }
  let last = null;
  return (() => {
    const result = [];
    for (const c of Array.from(op)) {
      if (typeof(c) === 'object') {
        if (c.i !== undefined) {
          if (((typeof(c.i) !== 'string') || !(c.i.length > 0)) && ((typeof(c.i) !== 'number') || !(c.i > 0))) { throw new Error('Inserts must insert a string or a +ive number'); }
        } else if (c.d !== undefined) {
          if ((typeof(c.d) !== 'number') || !(c.d > 0)) { throw new Error('Deletes must be a +ive number'); }
        } else {
          throw new Error('Operation component must define .i or .d');
        }
      } else {
        if (typeof(c) !== 'number') { throw new Error('Op components must be objects or numbers'); }
        if (!(c > 0)) { throw new Error('Skip components must be a positive number'); }
        if (typeof(last) === 'number') { throw new Error('Adjacent skip components should be combined'); }
      }

      result.push(last = c);
    }
    return result;
  })();
};

// Take the next part from the specified position in a document snapshot.
// position = {index, offset}. It will be updated.
type._takeDoc = (takeDoc = function(doc, position, maxlength, tombsIndivisible) {
  if (position.index >= doc.data.length) { throw new Error('Operation goes past the end of the document'); }

  const part = doc.data[position.index];
  // peel off data[0]
  const result = typeof(part) === 'string' ?
    maxlength !== undefined ?
      part.slice(position.offset, (position.offset + maxlength))
    :
      part.slice(position.offset)
  :
    (maxlength === undefined) || tombsIndivisible ?
      part - position.offset
    :
      Math.min(maxlength, part - position.offset);
  
  const resultLen = result.length || result;

  if (((part.length || part) - position.offset) > resultLen) {
    position.offset += resultLen;
  } else {
    position.index++;
    position.offset = 0;
  }
  
  return result;
});

// Append a part to the end of a document
type._appendDoc = (appendDoc = function(doc, p) {
  if ((p === 0) || (p === '')) { return; }

  if (typeof p === 'string') {
    doc.charLength += p.length;
    doc.totalLength += p.length;
  } else {
    doc.totalLength += p;
  }

  const {
    data
  } = doc;
  if (data.length === 0) {
    data.push(p);
  } else if (typeof(data[data.length - 1]) === typeof(p)) {
    data[data.length - 1] += p;
  } else {
    data.push(p);
  }
});

// Apply the op to the document. The document is not modified in the process.
type.apply = function(doc, op) {
  if ((doc.totalLength === undefined) || (doc.charLength === undefined) || (doc.data.length === undefined)) {
    throw new Error('Snapshot is invalid');
  }

  checkOp(op);

  const newDoc = type.create();
  const position = {index:0, offset:0};

  for (const component of Array.from(op)) {
    var part, remainder;
    if (typeof(component) === 'number') {
      remainder = component;
      while (remainder > 0) {
        part = takeDoc(doc, position, remainder);
        
        appendDoc(newDoc, part);
        remainder -= part.length || part;
      }

    } else if (component.i !== undefined) {
      appendDoc(newDoc, component.i);
    } else if (component.d !== undefined) {
      remainder = component.d;
      while (remainder > 0) {
        part = takeDoc(doc, position, remainder);
        remainder -= part.length || part;
      }
      appendDoc(newDoc, component.d);
    }
  }
  
  return newDoc;
};

// Append an op component to the end of the specified op.
// Exported for the randomOpGenerator.
type._append = (append = function(op, component) {
  if ((component === 0) || (component.i === '') || (component.i === 0) || (component.d === 0)) {
    
  } else if (op.length === 0) {
    return op.push(component);
  } else {
    const last = op[op.length - 1];
    if ((typeof(component) === 'number') && (typeof(last) === 'number')) {
      return op[op.length - 1] += component;
    } else if ((component.i !== undefined) && (last.i != null) && (typeof(last.i) === typeof(component.i))) {
      return last.i += component.i;
    } else if ((component.d !== undefined) && (last.d != null)) {
      return last.d += component.d;
    } else {
      return op.push(component);
    }
  }
});
  
// Makes 2 functions for taking components from the start of an op, and for peeking
// at the next op that could be taken.
const makeTake = function(op) {
  // The index of the next component to take
  let index = 0;
  // The offset into the component
  let offset = 0;

  // Take up to length maxlength from the op. If maxlength is not defined, there is no max.
  // If insertsIndivisible is true, inserts (& insert tombstones) won't be separated.
  //
  // Returns null when op is fully consumed.
  const take = function(maxlength, insertsIndivisible) {
    let current;
    if (index === op.length) { return null; }

    const e = op[index];
    if ((typeof((current = e)) === 'number') || (typeof((current = e.i)) === 'number') || ((current = e.d) !== undefined)) {
      let c;
      if ((maxlength == null) || ((current - offset) <= maxlength) || (insertsIndivisible && (e.i !== undefined))) {
        // Return the rest of the current element.
        c = current - offset;
        ++index; offset = 0;
      } else {
        offset += maxlength;
        c = maxlength;
      }
      if (e.i !== undefined) { return {i:c}; } else if (e.d !== undefined) { return {d:c}; } else { return c; }
    } else {
      // Take from the inserted string
      let result;
      if ((maxlength == null) || ((e.i.length - offset) <= maxlength) || insertsIndivisible) {
        result = {i:e.i.slice(offset)};
        ++index; offset = 0;
      } else {
        result = {i:e.i.slice(offset, offset + maxlength)};
        offset += maxlength;
      }
      return result;
    }
  };
  
  const peekType = () => op[index];
  
  return [take, peekType];
};

// Find and return the length of an op component
const componentLength = function(component) {
  if (typeof(component) === 'number') {
    return component;
  } else if (typeof(component.i) === 'string') {
    return component.i.length;
  } else {
    // This should work because c.d and c.i must be +ive.
    return component.d || component.i;
  }
};

// Normalize an op, removing all empty skips and empty inserts / deletes. Concatenate
// adjacent inserts and deletes.
type.normalize = function(op) {
  const newOp = [];
  for (const component of Array.from(op)) { append(newOp, component); }
  return newOp;
};

// This is a helper method to transform and prune. goForwards is true for transform, false for prune.
const transformer = function(op, otherOp, goForwards, side) {
  let component;
  checkOp(op);
  checkOp(otherOp);
  const newOp = [];

  const [take, peek] = Array.from(makeTake(op));

  for (component of Array.from(otherOp)) {
    var chunk;
    let length = componentLength(component);

    if (component.i !== undefined) { // Insert text or tombs
      if (goForwards) { // transform - insert skips over inserted parts
        if (side === 'left') {
          // The left insert should go first.
          while (__guard__(peek(), x => x.i) !== undefined) { append(newOp, take()); }
        }

        // In any case, skip the inserted text.
        append(newOp, length);

      } else { // Prune. Remove skips for inserts.
        while (length > 0) {
          chunk = take(length, true);

          if (chunk === null) { throw new Error('The transformed op is invalid'); }
          if (chunk.d !== undefined) { throw new Error('The transformed op deletes locally inserted characters - it cannot be purged of the insert.'); }

          if (typeof chunk === 'number') {
            length -= chunk;
          } else {
            append(newOp, chunk);
          }
        }
      }

    } else { // Skip or delete
      while (length > 0) {
        chunk = take(length, true);
        if (chunk === null) { throw new Error('The op traverses more elements than the document has'); }

        append(newOp, chunk);
        if (!chunk.i) { length -= componentLength(chunk); }
      }
    }
  }
  
  // Append extras from op1
  while (component = take()) {
    if (component.i === undefined) { throw new Error(`Remaining fragments in the op: ${component}`); }
    append(newOp, component);
  }

  return newOp;
};

// transform op1 by op2. Return transformed version of op1.
// op1 and op2 are unchanged by transform.
// side should be 'left' or 'right', depending on if op1.id <> op2.id. 'left' == client op.
type.transform = function(op, otherOp, side) {
  if ((side !== 'left') && (side !== 'right')) { throw new Error(`side (${side}) should be 'left' or 'right'`); }
  return transformer(op, otherOp, true, side);
};

// Prune is the inverse of transform.
type.prune = (op, otherOp) => transformer(op, otherOp, false);

// Compose 2 ops into 1 op.
type.compose = function(op1, op2) {
  let component;
  if ((op1 === null) || (op1 === undefined)) { return op2; }

  checkOp(op1);
  checkOp(op2);

  const result = [];

  const [take, _] = Array.from(makeTake(op1));

  for (component of Array.from(op2)) {

    var chunk, length;
    if (typeof(component) === 'number') { // Skip
      // Just copy from op1.
      length = component;
      while (length > 0) {
        chunk = take(length);
        if (chunk === null) { throw new Error('The op traverses more elements than the document has'); }

        append(result, chunk);
        length -= componentLength(chunk);
      }

    } else if (component.i !== undefined) { // Insert
      append(result, {i:component.i});

    } else { // Delete
      length = component.d;
      while (length > 0) {
        chunk = take(length);
        if (chunk === null) { throw new Error('The op traverses more elements than the document has'); }

        const chunkLength = componentLength(chunk);
        if (chunk.i !== undefined) {
          append(result, {i:chunkLength});
        } else {
          append(result, {d:chunkLength});
        }

        length -= chunkLength;
      }
    }
  }
    
  // Append extras from op1
  while (component = take()) {
    if (component.i === undefined) { throw new Error(`Remaining fragments in op1: ${component}`); }
    append(result, component);
  }

  return result;
};

if (typeof WEB !== 'undefined' && WEB !== null) {
  exports.types['text-tp2'] = type;
} else {
  module.exports = type;
}


function __guard__(value, transform) {
  return (typeof value !== 'undefined' && value !== null) ? transform(value) : undefined;
}