// DOM MANIPULATION TO DYNAMICALLY RENDER COMMENTS SCOPES IN TEXT 

// cf. http://www.quirksmode.org/dom/w3c_core.html#nodemanipulation (informative!)

// classes :

// c-s is for 'textnode wrapper span'

// c-c is a comment marker

paintCommentScope = function(comment) {

		var selection = { 	'start' : { 'elt' : document.getElementById("sv_"+comment['start_wrapper']), 'offset' : comment['start_offset'] },

							'end' : { 'elt' : document.getElementById("sv_"+comment['end_wrapper']), 'offset' : comment['end_offset'] }

						} ;

			warn_server({'from':'paintCommentScope', 'start_wrapper':comment['start_wrapper']}) ;

		else {

			if (document.getElementById("sv_"+comment['end_wrapper'])== null)

				warn_server({'from':'paintCommentScope', 'end_wrapper':comment['end_wrapper']}) ;

			else {

			    selection['start'] = _convertSelectionFromCSToCC(selection['start']) ;

			    selection['end'] = _convertSelectionFromCSToCC(selection['end']) ;

			    renderComment(selection, comment['id']) ;

			}

		}

	}

} ;

getCommentIdsFromClasses = function (elt) {

	var commentIds = [] ;

	var classes = elt['className'].split(" ") ;

	for (var i = 0, ilen = classes.length ; i < ilen ; i++) {

		if (classes[i].indexOf('c-id-') == 0) {

			commentIds.push(parseInt(classes[i].substring('c-id-'.length))) ;

		}

	}

	return commentIds ;

} ;

renderComment = function (selection, commentId) {

	var startOffset = selection['start']['offset'] ;

	var endOffset = selection['end']['offset'] ;

	var startElt = selection['start']['elt'] ;

	var endElt = selection['end']['elt'] ;

    if ((startElt != null) && (endElt != null) && _getTextNodeContent(startElt) != '' && _getTextNodeContent(endElt) != ''){

// log('startElt.id : ' + startElt.id) ;

// log('endElt.id : ' + endElt.id) ;

//    	log('startElt.innerHTML : ' + startElt.innerHTML) ;

//    	log('endElt.innerHTML : ' + endElt.innerHTML) ;

	    markWholeNodesAsComments(startElt, endElt, commentId) ;

	    markEndsAsComments(startElt, startOffset, endElt, endOffset, commentId) ;

	}

} ;

markWholeNodesAsComments = function (startElt, endElt, commentId) {

    var commonAncestor = _findCommonAncestor(startElt, endElt) ;

    _dynSpanToAnc(startElt, commonAncestor, commentId, false) ;

    _dynSpanToAnc(endElt, commonAncestor, commentId, true) ;

    _dynSpanInBetween(commonAncestor, startElt, endElt, commentId) ;

} ;

_setTextNodeContent = function(txtNodeParent, contentString) {

    CY.DOM.setText(txtNodeParent, contentString);

} ;

_getTextNodeContent = function(txtNodeParent) {

    return CY.DOM.getText(txtNodeParent);

} ;

markEndsAsComments = function(startElt, startOffset, endElt, endOffset, commentId) {

//	alert('starting with: ' + startElt.childNodes.length + 'and a length of : ' + startElt.firstChild.data.length) ; 

//	alert('2 and a length of : ' + CY.DOM.getText(startElt).length) ; 

	var beforeStart = _getTextNodeContent(startElt).substring(0, startOffset) ; 

	var afterStart = _getTextNodeContent(startElt).substring(startOffset) ;

	var beforeEnd = _getTextNodeContent(endElt).substring(0, endOffset) ;

	var afterEnd = _getTextNodeContent(endElt).substring(endOffset) ;

    var sameNode = (startElt === endElt) ;

//    log('beforeStart : ' + beforeStart + ' , afterStart : ' + afterStart + ' , beforeEnd : ' + beforeEnd + ' , afterEnd : ' + afterEnd + ' , sameNode : ' + sameNode) ;

    // taking care of start node : (and 'sameNode' case when start and end lie

	// on same node)

    if (afterStart != "") { // otherwise nothing to do on the start node

    	if (CY.DOM.hasClass(startElt, 'c-c')) {

    		var lastElt = null, afterStartElt = null, afterEndElt = null, beforeStartElt = null ;

        	var btw = (sameNode) ? _getTextNodeContent(startElt).substring(startOffset, endOffset) : afterStart ;

        	if (sameNode && (afterEnd != "")) {

				afterEndElt = startElt ;

				lastElt = afterEndElt ;

			}

	    	if (btw != "") {

	    		if (lastElt == null) {

	    			afterStartElt = startElt ;

	    		}

	    		else {

	    			afterStartElt = _yuiCloneNode(startElt) ;

	    			lastElt.parentNode.insertBefore(afterStartElt, lastElt) ;

	    		}

				lastElt = afterStartElt ;

	    	}

	    	if (beforeStart != "") {

	    		if (lastElt == null) {

	    			beforeStartElt = startElt ;

	    		}

	    		else {

	    			beforeStartElt = _yuiCloneNode(startElt) ;

	    			lastElt.parentNode.insertBefore(beforeStartElt, lastElt) ;

	    		}

				lastElt = beforeStartElt ;

	    	}

			if (afterEndElt != null) {

				_setTextNodeContent(afterEndElt, afterEnd) ;

			}

	    	if (afterStartElt != null) {

				_setTextNodeContent(afterStartElt, btw) ;

	    		_addIdClass(afterStartElt, commentId) ;

	    	}

//	    	alert('beforeStartElt.firstChild.data.length: ' + beforeStartElt.firstChild.data.length);

//	    	alert('beforeStartElt.childNodes.length: ' + beforeStartElt.childNodes.length);

	    	if (beforeStartElt != null) {

				_setTextNodeContent(beforeStartElt, beforeStart) ; 

	    	}

//	    	alert('beforeStartElt.childNodes.length: ' + beforeStartElt.childNodes.length);

	    	//alert('typeof beforeStartElt: ' + typeof beforeStartElt);

//	    	alert('beforeStartElt.lastChild ==  beforeStartElt.firstChild : ' + (beforeStartElt.lastChild == beforeStartElt.firstChild));

//	    	alert('beforeStartElt.firstChild.id : ' + beforeStartElt.firstChild.id);

//	    	alert('beforeStartElt.lastChild.data : ' + beforeStartElt.lastChild.data);

//	    	alert('beforeStartElt.firstChild.data : ' + beforeStartElt.firstChild.data);

//	    	alert('afterStartElt.firstChild.data : ' + afterStartElt.firstChild.data);

//	    	alert('afterEndElt.firstChild.data : ' + afterEndElt.firstChild.data);

       	}

    }

    if ( ( !sameNode ) && ( beforeEnd != "" ) ) { // otherwise nothing to do

													// on the end node

    	if (CY.DOM.hasClass(endElt, 'c-c')) {

    		var lastElt = null, beforeEndElt = null, afterEndElt = null ;

	    	if (afterEnd != "") {

	    		afterEndElt = endElt ;

				lastElt = endElt ;

			}

	    	if (beforeEnd != "") {

	    		if (lastElt == null)

	    			beforeEndElt = endElt ;

	    		else {

	    			beforeEndElt = _yuiCloneNode(endElt) ;

	    			lastElt.parentNode.insertBefore(beforeEndElt, lastElt) ;

	    		}

				lastElt = beforeEndElt ;

	    	}

	    	if (afterEndElt != null) {

	    		_setTextNodeContent(afterEndElt, afterEnd) ;

			}

	    	if (beforeEndElt != null) {

	    		_addIdClass(beforeEndElt, commentId) ;

	    		_setTextNodeContent(beforeEndElt, beforeEnd) ;

	    	}

    	}

    }

} ;

// WARNING (200891108): had to use YUI cloneNode instead of the native cloneNode

// (because of the _yuid that is cloned under IE, cf tests made in textYUIcloneNode.html)

// so code like :

// afterStartElt = startElt.cloneNode(true) ;

// afterStartElt.id = CY.guid() ;

// was replaced with :

// afterStartElt = _yuiCloneNode(startElt) ;

_yuiCloneNode = function (srcElt) {

	var ret = CY.Node.getDOMNode(CY.get('#'+srcElt.id).cloneNode(true)) ;

	ret.id = CY.guid();

	return ret ;

} ;

// will wrap textNodes into c-c spans going up the DOM tree from elt to ancestor

// textNodes impacted here will be those that are :

// the same generation or older than elt (but elt is excluded)

// AND not older than grand children of to

// assumption :

// 1 ancestor is an ancestor of elt (we'll be going up the DOM tree)

// 2 elt is a textNode.

// argumentss :

// prev : will spannify previous siblings if true, next siblings otherwise

_dynSpanToAnc = function (elt, ancestor, commentId, prev) {

// log('in : _dynSpanToAnc, elt : ' + elt.id) ;

	var c = elt ;

    while ((c != null) && (c !== ancestor) && (c.parentNode !== ancestor)) {

		var c_sib = null ;

		if (prev) {

			c_sib = c.previousSibling ;

		}

		else {

			c_sib = c.nextSibling ;

		}

		if (c_sib == null) {

			c = c.parentNode ;

		}

		else {

			c = c_sib ;			

			_recAddComment(c, commentId) ;

		}

	} ;

} ;

// between elt1 and elt2 (which are excluded)

_dynSpanInBetween = function (anc, elt1, elt2, commentId) {

	var a = elt1 ;

	var elt1Anc = null ;

    while (a) {

        if (a.parentNode === anc) {

        	elt1Anc = a ;

        	break;

        }

        a = a.parentNode;

    }

	if (elt1Anc != null) {

		a = elt2 ;

		var elt2Anc = null ;

	    while (a) {

	        if (a.parentNode === anc) {

	        	elt2Anc = a ;

	        	break;

	        }

	        a = a.parentNode;

	    }

		if (elt2Anc != null) { // found both ancestor, now doing the work

			a = elt1Anc.nextSibling ;

			while ((a != null) && (a !== elt2Anc)) {

				_recAddComment(a, commentId) ;

				a = a.nextSibling ;

			}

		}

	}

} ;

// (copied from YUI dom-base)

_bruteContains = function(element, needle) {

    while (needle) {

        if (element === needle) {

            return true;

        }

        needle = needle.parentNode;

    }

    return false;

},

//elt is supposed to be c-c classed

_addIdClass = function (elt, commentId) {

	CY.DOM.addClass(elt, 'c-id-' + commentId) ;

	_updateCommentCounter(elt) ;

} ;

//elt is supposed to be c-c classed

_removeIdClass = function (elt, commentId) {

	CY.DOM.removeClass(elt, 'c-id-' + commentId) ;

	_updateCommentCounter(elt) ;

} ;

//elt is supposed to be c-c classed

_removeIdClasses = function (elt) {

	var re = _cgetRegExp('(?:^|\\s+)c-id-(?:\\d+)', 'g');

	elt['className'] = elt['className'].replace(re, " ") ;

	_updateCommentCounter(elt) ;

} ;

_recAddComment = function (elt, commentId) {

	if (CY.DOM.hasClass(elt, 'c-c')) {

		_addIdClass(elt, commentId) ;

	}

	else {

		var c = elt.firstChild ;

        while (c != null) {

        	_recAddComment(c, commentId) ;

			c = c.nextSibling ;

        }

    }

} ;

// might be expensive ... (? maybe should use contains when available, instead

// of custom _bruteContains)

_findCommonAncestor = function (elt1, elt2) {

	if (_bruteContains(elt1, elt2))

		return elt1 ;

	else {

		var e = elt2 ;

		while ((e != null) && !_bruteContains(e, elt1)) {

			e = e.parentNode ; 

		}

		return e ;

	}

} ;

_cregexCache = {} ;

// inspired (copied) from dom-base-debug in yui

_cgetRegExp = function(str, flags) {

    flags = flags || '';

    if (!_cregexCache[str + flags]) {

        _cregexCache[str + flags] = new RegExp(str, flags);

    }

    return _cregexCache[str + flags];

} ;

//c-c should be classed with a c-count-x where x is a number for color graduation

//c-c should be classed with many c-id-xid where xid is the comment db id of comment that apply to it

_updateCommentCounter = function (elt) {

	var re = _cgetRegExp('(?:^|\\s+)c-id-(?:\\d+)', 'g');

	var matches = elt['className'].match(re);

	var countIds = (matches == null) ? 0 : matches.length ;

	re = _cgetRegExp('(?:^|\\s+)c-count-(?:\\d+)', 'g');

	elt['className'] = elt['className'].replace(re, " ") ;

	CY.DOM.addClass(elt, 'c-count-'+countIds+' ') ;

} ;

_convertSelectionFromCCToCS = function (sel) {

	var offset = sel['offset'] ;

	var elt = sel['elt'].parentNode ;

	var e = sel['elt'].previousSibling ;

	while (e != null) {

		offset += _getTextNodeContent(e).length ;

		e = e.previousSibling ; // will be a c-c !!

	}

	return  {'elt':elt, 'offset':offset} ;

} ;

_convertSelectionFromCSToCC = function (sel) {

	var ret = {'elt':null, 'offset':-1} ;

	var cc = null ;

	var ccElt = sel['elt'].firstChild ;