/*!
 * 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.
 */

function makeVirtualLineView(lineNode) {
  
  // how much to jump forward or backward at once in a charSeeker before
  // constructing a DOM node and checking the coordinates (which takes a
  // significant fraction of a millisecond).  From the
  // coordinates and the approximate line height we can estimate how
  // many lines we have moved.  We risk being off if the number of lines
  // we move is on the order of the line height in pixels.  Fortunately,
  // when the user boosts the font-size they increase both.
  var maxCharIncrement = 20;
  var seekerAtEnd = null;

  function getNumChars() {
    return (lineNode.textContent || lineNode.innerText).length;
  }
  
  function getNumVirtualLines() {
    if (! seekerAtEnd) {
      var seeker = makeCharSeeker();
      seeker.forwardByWhile(maxCharIncrement);
      seekerAtEnd = seeker;
    }
    return seekerAtEnd.getVirtualLine() + 1;
  }

  function getVLineAndOffsetForChar(lineChar) {
    var seeker = makeCharSeeker();
    seeker.forwardByWhile(maxCharIncrement, null, lineChar);
    var theLine = seeker.getVirtualLine();
    seeker.backwardByWhile(8, function() { return seeker.getVirtualLine() == theLine; });
    seeker.forwardByWhile(1, function() { return seeker.getVirtualLine() != theLine; });
    var lineStartChar = seeker.getOffset();
    return {vline:theLine, offset:(lineChar - lineStartChar)};
  }

  function getCharForVLineAndOffset(vline, offset) {
    // returns revised vline and offset as well as absolute char index within line.
    // if offset is beyond end of line, for example, will give new offset at end of line.
    var seeker = makeCharSeeker();
    // go to start of line
    seeker.binarySearch(function() {
      return seeker.getVirtualLine() >= vline;
    });
    var lineStart = seeker.getOffset();
    var theLine = seeker.getVirtualLine();
    // go to offset, overshooting the virtual line only if offset is too large for it
    seeker.forwardByWhile(maxCharIncrement, null, lineStart+offset);
    // get back into line
    seeker.backwardByWhile(1, function() { return seeker.getVirtualLine() != theLine; }, lineStart);
    var lineChar = seeker.getOffset();
    var theOffset = lineChar - lineStart;
    // handle case of last virtual line; should be able to be at end of it
    if (theOffset < offset && theLine == (getNumVirtualLines()-1)) {
      var lineLen = getNumChars();
      theOffset += lineLen-lineChar;
      lineChar = lineLen;
    }
    
    return { vline:theLine, offset:theOffset, lineChar:lineChar };
  }

  return {getNumVirtualLines:getNumVirtualLines, getVLineAndOffsetForChar:getVLineAndOffsetForChar,
          getCharForVLineAndOffset:getCharForVLineAndOffset,
          makeCharSeeker: function() { return makeCharSeeker(); } };

  function deepFirstChildTextNode(nd) {
    nd = nd.firstChild;
    while (nd && nd.firstChild) nd = nd.firstChild;
    if (nd.data) return nd;
    return null;
  }
  
  function makeCharSeeker(/*lineNode*/) {

    function charCoords(tnode, i) {
      var container = tnode.parentNode;

      // treat space specially; a space at the end of a virtual line
      // will have weird coordinates
      var isSpace = (tnode.nodeValue.charAt(i) === " ");
      if (isSpace) {
        if (i == 0) {
          if (container.previousSibling && deepFirstChildTextNode(container.previousSibling)) {
            tnode = deepFirstChildTextNode(container.previousSibling);
            i = tnode.length-1;
            container = tnode.parentNode;
          }
          else {
            return {top:container.offsetTop, left:container.offsetLeft};
          }
        }
        else {
          i--; // use previous char
        }
      }


      var charWrapper = document.createElement("SPAN");

      // wrap the character
      var tnodeText = tnode.nodeValue;
      var frag = document.createDocumentFragment();
      frag.appendChild(document.createTextNode(tnodeText.substring(0, i)));
      charWrapper.appendChild(document.createTextNode(tnodeText.substr(i, 1)));
      frag.appendChild(charWrapper);
      frag.appendChild(document.createTextNode(tnodeText.substring(i+1)));
      container.replaceChild(frag, tnode);
      
      var result = {top:charWrapper.offsetTop,
        left:charWrapper.offsetLeft + (isSpace ? charWrapper.offsetWidth : 0),
        height:charWrapper.offsetHeight};
      
      while (container.firstChild) container.removeChild(container.firstChild);
      container.appendChild(tnode);
      
      return result;
    }

    var lineText = (lineNode.textContent || lineNode.innerText);
    var lineLength = lineText.length;

    var curNode = null;
    var curChar = 0;
    var curCharWithinNode = 0
    var curTop;
    var curLeft;
    var approxLineHeight;
    var whichLine = 0;

    function nextNode() {
      var n = curNode;
      if (! n) n = lineNode.firstChild;
      else n = n.nextSibling;
      while (n && ! deepFirstChildTextNode(n)) {
        n = n.nextSibling;
      }
      return n;
    }
    function prevNode() {
      var n = curNode;
      if (! n) n = lineNode.lastChild;
      else n = n.previousSibling;
      while (n && ! deepFirstChildTextNode(n)) {
        n = n.previousSibling;
      }
      return n;
    }

    var seeker;
    if (lineLength > 0) {
      curNode = nextNode();
      var firstCharData = charCoords(deepFirstChildTextNode(curNode), 0);
      approxLineHeight = firstCharData.height;
      curTop = firstCharData.top;
      curLeft = firstCharData.left;

      function updateCharData(tnode, i) {
        var coords = charCoords(tnode, i);
        whichLine += Math.round((coords.top - curTop) / approxLineHeight);
        curTop = coords.top;
        curLeft = coords.left;
      }

      seeker = {
        forward: function(numChars) {
          var oldChar = curChar;
          var newChar = curChar + numChars;
          if (newChar > (lineLength-1))
            newChar = lineLength-1;
          while (curChar < newChar) {
            var curNodeLength = deepFirstChildTextNode(curNode).length;
            var toGo = curNodeLength - curCharWithinNode;
            if (curChar + toGo > newChar || ! nextNode()) {
              // going to next node would be too far
              var n = newChar - curChar;
              if (n >= toGo) n = toGo-1;
              curChar += n;
              curCharWithinNode += n;
              break;
            }
            else {
              // go to next node
              curChar += toGo;
              curCharWithinNode = 0;
              curNode = nextNode();
            }
          }
          updateCharData(deepFirstChildTextNode(curNode), curCharWithinNode);
          return curChar - oldChar;
        },
        backward: function(numChars) {
          var oldChar = curChar;
          var newChar = curChar - numChars;
          if (newChar < 0) newChar = 0;
          while (curChar > newChar) {
            if (curChar - curCharWithinNode <= newChar || !prevNode()) {
              // going to prev node would be too far
              var n = curChar - newChar;
              if (n > curCharWithinNode) n = curCharWithinNode;
              curChar -= n;
              curCharWithinNode -= n;
              break;
            }
            else {
              // go to prev node
              curChar -= curCharWithinNode+1;
              curNode = prevNode();
              curCharWithinNode = deepFirstChildTextNode(curNode).length-1;
            }
          }
          updateCharData(deepFirstChildTextNode(curNode), curCharWithinNode);
          return oldChar - curChar;
        },
        getVirtualLine: function() { return whichLine; },
        getLeftCoord: function() { return curLeft; }
      };
    }
    else {
      curLeft = lineNode.offsetLeft;
      seeker = { forward: function(numChars) { return 0; },
                 backward: function(numChars) { return 0; },
                 getVirtualLine: function() { return 0; },
                 getLeftCoord: function() { return curLeft; }
               };
    }
    seeker.getOffset = function() { return curChar; };
    seeker.getLineLength = function() { return lineLength; };
    seeker.toString = function() {
      return "seeker[curChar: "+curChar+"("+lineText.charAt(curChar)+"), left: "+seeker.getLeftCoord()+", vline: "+seeker.getVirtualLine()+"]";
    };

    function moveByWhile(isBackward, amount, optCondFunc, optCharLimit) {
      var charsMovedLast = null;
      var hasCondFunc = ((typeof optCondFunc) == "function");
      var condFunc = optCondFunc;
      var hasCharLimit = ((typeof optCharLimit) == "number");
      var charLimit = optCharLimit;
      while (charsMovedLast !== 0 && ((! hasCondFunc) || condFunc())) {
        var toMove = amount;
        if (hasCharLimit) {
          var untilLimit = (isBackward ? curChar - charLimit : charLimit - curChar);
          if (untilLimit < toMove) toMove = untilLimit;
        }
        if (toMove < 0) break;
        charsMovedLast = (isBackward ? seeker.backward(toMove) : seeker.forward(toMove));
      }
    }
    
    seeker.forwardByWhile = function(amount, optCondFunc, optCharLimit) {
      moveByWhile(false, amount, optCondFunc, optCharLimit);
    }
    seeker.backwardByWhile = function(amount, optCondFunc, optCharLimit) {
      moveByWhile(true, amount, optCondFunc, optCharLimit);
    }
    seeker.binarySearch = function(condFunc) {
      // returns index of boundary between false chars and true chars;
      // positions seeker at first true char, or else last char
      var trueFunc = condFunc;
      var falseFunc = function() { return ! condFunc(); };
      seeker.forwardByWhile(20, falseFunc);
      seeker.backwardByWhile(20, trueFunc);
      seeker.forwardByWhile(10, falseFunc);
      seeker.backwardByWhile(5, trueFunc);
      seeker.forwardByWhile(1, falseFunc);
      return seeker.getOffset() + (condFunc() ? 0 : 1);
    }
    
    return seeker;
  }

}
