/**
 * Copyright 2009 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS-IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.etherpad;

object Easysync2Support {

  def numToString(d: Int): String = java.lang.Integer.toString(d.toInt, 36); // lowercase
  def stringToNum(s: String): Int = java.lang.Integer.parseInt(s, 36);
  
  def opAssembler() = new OpAssembler();
  
  class OpAssembler() {
    val buf = new StringBuilder(1000);
    def append(op: Op) {
      append(op.opcode, op.chars, op.lines, op.attribs);
    }
    def append(opcode: String, chars: Int, lines: Int, attribs: String) {
      buf.append(attribs);
      if (lines > 0) {
        buf.append('|');
        buf.append(numToString(lines));
      }
      buf.append(opcode);
      buf.append(numToString(chars));
    }
    override def toString(): String = buf.toString;
    def clear() { buf.clear; }
  }

  def isAlphanum(c: Char) = (c >= '0' && c <= '9' || c >= 'a' && c <= 'z');

  case object OpParseError extends Error;  
  
  def nextOpInString(str: String, startIndex: Int): Object = {
    var i = startIndex;

    try {
      def lookingAt(c: Char) = (i < str.length && str.charAt(i) == c);
      def lookingAtAlphanum() = (i < str.length && isAlphanum(str.charAt(i)));
      def atEnd() = (i >= str.length);
      def readAlphanum(): Int = {
        if (! lookingAtAlphanum()) {
          throw OpParseError;
        }
        val start = i;
        while (lookingAtAlphanum()) {
          i += 1;
        }
        val end = i;
        stringToNum(str.substring(start, end));
      }
      
      while (lookingAt('*')) {
        i += 1;
        if (! lookingAtAlphanum()) {
          throw OpParseError;
        }
        while (lookingAtAlphanum()) {
          i += 1;
        }
      }
      val attribsEnd = i;
      
      var lines_ = 0;
      if (lookingAt('|')) {
        i += 1;
        lines_ = readAlphanum();
      }
      
      if (lookingAt('?')) {
        return new { val opcode = "?"; }
      }
      if (! (lookingAt('+') || lookingAt('-') || lookingAt('='))) {
        throw OpParseError;
      }
      val opcode_ = str.substring(i, i+1);
      i += 1;
      val chars_ = readAlphanum();

      return new Op(opcode_, chars_, lines_, str.substring(startIndex, attribsEnd)) {
        val lastIndex = i;
      };
    }
    catch { case OpParseError => null }
  }

  case class Op(var opcode: String, var chars: Int, var lines: Int, var attribs: String);
  def newOp() = Op("", 0, 0, "");
  def clearOp(op: Op) { op.opcode = ""; op.chars = 0; op.lines = 0; op.attribs = ""; }
  
  // ported from easysync2.js
  class MergingOpAssembler {
    val assem = opAssembler();
    var bufOp = newOp();

    var bufOpAdditionalCharsAfterNewline = 0;

    def flush(isEndDocument: Boolean) {
      if (bufOp.opcode.length > 0) {
        if (isEndDocument && bufOp.opcode == "=" && bufOp.attribs.length == 0) {
          // final merged keep, leave it implicit
        }
        else {
          assem.append(bufOp);
          if (bufOpAdditionalCharsAfterNewline > 0) {
            bufOp.chars = bufOpAdditionalCharsAfterNewline;
            bufOp.lines = 0;
            assem.append(bufOp);
            bufOpAdditionalCharsAfterNewline = 0;
          }
        }
        bufOp.opcode = "";
      }
    }
    def append(opcode: String, chars: Int, lines: Int, attribs: String) {
      if (chars > 0) {
        if (bufOp.opcode == opcode && bufOp.attribs == attribs) {
	  if (lines > 0) {
	    // bufOp and additional chars are all mergeable into a multi-line op
	    bufOp.chars += bufOpAdditionalCharsAfterNewline + chars;
	    bufOp.lines += lines;
	    bufOpAdditionalCharsAfterNewline = 0;
	  }
	  else if (bufOp.lines == 0) {
	    // both bufOp and op are in-line
	    bufOp.chars += chars;
	  }
	  else {
	    // append in-line text to multi-line bufOp
	    bufOpAdditionalCharsAfterNewline += chars;
	  }
        }
        else {
	  flush(false);
          bufOp = Op(opcode, chars, lines, attribs);
        }
      }
    }
    def endDocument() {
      flush(true);
    }
    override def toString() = {
      flush(false);
      assem.toString();
    }
    def clear() {
      assem.clear();
      clearOp(bufOp);
    }
  }

  def mergingOpAssembler() = new MergingOpAssembler();
}