/*
	Copyright (c) 2006-2007, The Xooki project
	http://xooki.sourceforge.net/

   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.
	
	Some code is largely inspired by code found in the dojo toolkit, 
	see http://dojotoolkit.org/ for more information.
*/

/*
This script can be either embedded in a xooki page for in browser processing, or used in batch using rhino or java 6 javascript tool:
jrunscript path/to/xooki.js inputFileFromXookiSite.html [path/to/dir/to/put/generated/file]

Be sure to be in the directory where the html input to process is when running this command.
 */
var batchMode = (typeof arguments != 'undefined');

var xooki = {};
xooki.console = ""; // used for debugging purpose only, and only when the debug div is not yet created
xooki.config = {};
xooki.c = xooki.config;

function t(msg) {
    // returns the internationalized version of the message, or the message if no translation is available
    // t stands for translate
// FIXME
//    if (typeof xooki.c == "object" 
//        && typeof xooki.c.messages == "object" 
//        && typeof xooki.c.messages[msg] == "string") {
//        msg = xooki.c.messages[msg];
//    }
    var arr = [];
    for (var i=1; i<arguments.length; i++) {
        arr.push(arguments[i]);
    }
    return xooki.string.substituteParams(msg, arr);
}

function css(clss) {
    // returns the css class or id configured, or the given class (or id) if no one is configured
    if (typeof xooki.c.css[clss] != "undefined") {
        return xooki.c.css[clss];
    } else {
        return clss;
    } 
}
function u(path) {
  // convert a path relative to the root to a full URL
  // u stands for Url
  if (batchMode) {
	return xooki.c.relativeRoot+path;
  } else {
	return xooki.c.root + path;
  }
}
function lu(path) {
  // convert a path relative to the local root to a full URL
  // l stands for local, u stands for Url
  if (batchMode) {
	return xooki.c.localRelativeRoot+path;
  } else {
	return xooki.c.localRoot + path;
  }
}
function cu(urlCfgProp) {
  // get a path from a configuration path and convert it to an URL
  // cu stands for Configured Url
  if (typeof xooki.c.path[urlCfgProp] == "undefined") {
    xooki.warn(t("path not configured in xooki: '${0}'", urlCfgProp));
    return "";
  }
  return u(xooki.c.path[urlCfgProp]);
}
function pu(id) {
  // returns the url of the page identified by id
  // pu stands for Page Url
  return u(id+".html");
}
xooki.p = function(path) {
  // get a xooki full path from a xooki relative path
  // p stands for path
  return xooki.c.path.install+"/"+path;
}
xooki.u = function(path) {
  // convert a path relative to the xooki installation dir to a full URL
  return u(xooki.p(path));
}
xooki.cu = function(urlCfgProp) {
  // get a xooki path from a configuration path and convert it to an URL
  if (typeof xooki.c.path[urlCfgProp] == "undefined") {
    xooki.warn(t("path not configured in xooki: '${0}'", urlCfgProp));
  }
  return xooki.u(xooki.c.path[urlCfgProp]);
}

xooki.util = {
    isArray: function(it) {
    	return (it && it instanceof Array || typeof it == "array"); // Boolean
    },
    mix: function(src, into, override) {
        if (typeof override == "undefined") {
            override = true;
        }
        if (typeof into == "undefined") {
            into = {};
        }
        for (var k in src) {
            if (typeof src[k] == "object" && !xooki.util.isArray(src[k])) {
                if (override || typeof into[k] == "object" || typeof into[k] == "undefined") {
                    if (typeof into[k] != "object") {
                        into[k] = {};
                    }
                    xooki.util.mix(src[k], into[k], override);
                }
            } else if (override || typeof into[k] == "undefined") {
                into[k] = src[k];
            }
        }
        return into;
    },
    initArray: function(a) {
        if (this.isArray(a)) return a;
        else return {};
    }
}

xooki.url = {
        newXmlHttpRequest: function() {
        // we first try to use ActiveX, because IE7 has a direct support for XmlHttpRequest object, 
        // but which doesn't work with file urls
        	if(window.ActiveXObject)
        	{
        		try { req = new ActiveXObject("Msxml2.XMLHTTP");
        		} catch(e) {
        			try { req = new ActiveXObject("Microsoft.XMLHTTP");
        			} catch(e) { req = false; }
        		}
        	}
        	else if(window.XMLHttpRequest) {
        		try { req = new XMLHttpRequest();
        		} catch(e) { req = false; }
        	}
        
        	return req;	
        },
                
        loadURL: function( url, warnOnError ) {
        	req = this.newXmlHttpRequest();
        	if(req) {
        		try {
        			req.open("GET", url, false);
        			req.send("");
        	
        			return req.responseText;
        		} catch (e) {
                    if (warnOnError != false)
                        xooki.error(e, t("problem while loading URL ${0}", url));
                    else
                        xooki.debug(t("problem while loading URL ${0}: ${1}", url, e));
                }		
        	}
        	return null;
        },
        
        asyncLoadURL: function( url, callback, obj ) {
        	var req = this.newXmlHttpRequest();
        	if(req) {
        		try {
        			req.open("GET", url, true);
				    req.onreadystatechange=function() {
				        if (req.readyState == 4) {
				           if (req.status == 200 || req.status == 0) {
				              callback(req.responseText, obj);
				           }
				        }
				     };  			
				     req.send("");
        		} catch (e) {
        			xooki.error(e, t("problem while loading URL ${0}", url));
                }		
        	}
        },

        include: function(script_filename) {
            document.write('<' + 'script');
            document.write(' language="javascript"');
            document.write(' type="text/javascript"');
            document.write(' src="' + xooki.u(script_filename) + '">');
            document.write('</' + 'script' + '>');
        },
        
        evalURL: function( url, warnOnErrorUrl ) {
            script = this.loadURL(url, warnOnErrorUrl);
            if (script != null) {
                try {
                    eval(script);
                } catch (e) {
        			xooki.error(e, t("error while executing script from URL ${0}", url));
                }
            }
        },

        action: function(action) {        
            // returns the url for an action on the same page
            loc = batchMode?'':xooki.pageURL;
            if (loc.indexOf("#") != -1) {
                loc = loc.substring(0, loc.indexOf("#"));
            }
            return loc+"?action="+action;
        }

    };
    
xooki.string = {

    substituteParams: function(/*string*/template, /* object - optional or ... */hash) {
    // borrowed from dojo
    // summary:
    //	Performs parameterized substitutions on a string. Throws an exception if any parameter is unmatched.
    //
    // description:
    //	For example,
    //		dojo.string.substituteParams("File '${0}' is not found in directory '${1}'.","foo.html","/temp");
    //	returns
    //		"File 'foo.html' is not found in directory '/temp'."
    //
    // template: the original string template with ${values} to be replaced
    // hash: name/value pairs (type object) to provide substitutions.  Alternatively, substitutions may be
    //	included as an array
    
        var map;
        if (typeof hash == "object" && hash.length) { // array
            map = {};
            for (var i in hash) {
                map[i+""] = hash[i];
            }
        } else {
            map = hash;
        }
    
    	return template.replace(/\$\{(\w+)\}/g, function(match, key){
    		if(typeof(map[key]) != "undefined" && map[key] != null){
    			return map[key];
    		}
    		xooki.warn("Substitution not found: " + key);
    		return key;
    	}); // string
	},
	
	processTemplate: function(/*string*/template, /* object */hash) {
	   if (typeof template.process == "function") {
	       return template.process(hash);
       } else {
            return this.substituteParams(template, hash);
       }
    },

    exceptionText: function(e, message) {
    	var s = e.description ? e.description : e.toString();
    	return message ? message+":\n"+s : s;
    },
    
    findXmlSection: function(str, element, from) {
        return this.findSection(str, new RegExp('<'+element+'(\\s*\\w+="[\\w\\s]*")*>'), new RegExp('</'+element+'>'), from);
    },
    
    find: function(/*string*/str, /*string or regexp*/exp, /*number, optional*/from) {
        // find an expression (string or regexp) in a string, from an optional index
        // the object returned has two properties:
        // begin: the index in str of the matching find
        // end: the index in str of the end of the matching find
        // returns null if no match is found
        if (typeof from != "number") {
            from = 0;
        }
        if (typeof exp == "string") {
            var result = {};
            result.begin = str.indexOf(exp,from);
            if (result.begin >= 0) {
                result.end = result.begin + exp.length;
                return result;
            }
        } else {
            var m;
            if (from > 0) {
                // I haven't found any other way to start from the given index
                m = exp.exec(str.substring(from));
            } else {
                m = exp.exec(str);
            }
            if (m != null) {                
                var result = {};
                result.begin = m.index + from;
                result.end = result.begin + m[0].length;
                return result;
            }
        }
        return null;
    },
    
    findSection: function(/*string*/str, /*string or regexp*/open, /*string or regexp*/close, /*number, optional*/from) {
        // finds a section delimited by open and close tokens in the given string
        // the algorithm looks for matching open and close tokens
        // the returned object has the following properties:
        //   outerStart: the index in str where the first open token was found
        //   innerStart: the index in str just after the found open token
        //   innerEnd: the index in str where the matching close token was found
        //   outerEnd: the index in str just after the matching close token
        //   children: an array of similar objects if nested sections where found
        // if no section is found (no open token, an open token with no matching 
        // close token, or a close token before an open token), null is returned
        //
        // for instance if open=='(' and close==')' then the section will find
        // a section delimited by the first found open parenthesis and the matching
        // close parentethis, taking into account other opening parentethis
        // examples:
        // findSection("a(test)b", "(", ")") == {outerStart: 1, innerStart:2, innerEnd:6, outerEnd:7, children:[]}
        // findSection("a(te(s)(t))b", "(", ")") == {outerStart: 1, innerStart:2, innerEnd:10, outerEnd:11, 
        //      children:[
        //          {outerStart: 4, innerStart:5, innerEnd:6, outerEnd:7, children:[]},
        //          {outerStart: 7, innerStart:8, innerEnd:9, outerEnd:10, children:[]}
        //      ]}
        
        var openResult = this.find(str, open, from);        
        if (openResult == null) {
            return null;
        }
        var closeResult = this.find(str, close, from);        
        if (closeResult == null || closeResult.begin < openResult.end) {
            return null;
        }
        if (openResult.end <= openResult.begin || closeResult.end <= closeResult.begin) {
            // empty match are not allowed
            return null;
        }
        
        var children = [];
        var child = this.findSection(str, open, close, openResult.end);
        while (child != null) {
            if (child.outerEnd > closeResult.begin) {
                closeResult = this.find(str, close, child.outerEnd);        
                if (closeResult == null) {
                    // unmatched open token
                    return null;
                }
            }
            children.push(child);
            child = this.findSection(str, open, close, child.outerEnd);
        }

        return {
            outerStart: openResult.begin,
            innerStart: openResult.end,
            innerEnd: closeResult.begin,
            outerEnd: closeResult.end,
            children: children
        };        
    },
    
    mul: function (/*string*/ s, /*int*/ n) {
        r = '';
        for (var i=0; i < n; i++) {
    		r += s;
    	}
        return r;
    }
};
    
xooki.json = {
        evalJson: function (str) {
            try {
                return eval("("+str+")");
            } catch (e) {
                return null;
            }
        },
        
        loadURL: function (url) {
            return this.evalJson(xooki.url.loadURL(url));
        }
    };

// Displays an alert of an exception description with optional message
xooki.warn = function(e, message) {
    xooki.display(xooki.string.exceptionText(e, message), "#eecccc");
}

// Displays an alert of an exception description with optional message
xooki.error = function(e, message) {
    xooki.display(xooki.string.exceptionText(e, message), "#ffdddd");
}

xooki.info = function(message) {
    xooki.display(message, "#ddddff");
}

xooki.display = function(message, background) {
    var messages = document.getElementById('xooki-messages');
    if (messages) {
        messages.innerHTML = '<table width="100%" border="0"><tr><td align="center">'+message+'</td></tr></table>';
        messages.style.background = background;
        messages.style.display = "inline";
    } else {
        alert(message);
    }
}

xooki.debug = function(message) {
    var console = typeof document == 'undefined' ? false : document.getElementById('xooki-console');
    if (console) {
        console.value += message + "\n";
    } else {
        xooki.console += message + "\n";
    }
}

xooki.debugShowDetail = function (message) {
    var detail = typeof document == 'undefined' ? false : document.getElementById('xooki-debug-detail');
    if (detail) {
        detail.value=message;
    } else {
        alert(message);
    }
}


xooki.html = {
    hide: function(divid) {
	   document.getElementById(divid).style.display = 'none';
    },

    show: function (divid) {
	   document.getElementById(divid).style.display = '';
    },
    
    pageLink: function(page) {
    	if (page.isAbstract) {
    		return page.title;
    	} else {
    		return '<a href="'+(page.url != null ? page.url : pu(page.id))+'" '+(page.id == xooki.page.id?'class="current"':'')+'>'+page.title+'</a>';
    	}
    },
	
	// insert  the given  header in the html head
	// can be used only when the browser is still in the head !
	addHeader: function(/* string */ head) {
		document.write(head);
	},
	
	setBody: function( /* string */ body) {
		document.body.innerHTML = body;
	}
};

xooki.component = {
    childrenList: function () {
    	if (xooki.page.children.length > 0) {
    		childrenList = '<ul class="'+css('childrenList')+'">';
    		for (var i in xooki.page.children) {
    			childrenList+='<li>'+xooki.html.pageLink(xooki.page.children[i])+'</li>';
    		}
    		childrenList += "</ul>";
    		return childrenList;
    	} else {
    	   return "";
        }
    },
    
    menu: function () {
    	var menu = '<ul id="'+css("treemenu")+'" class="treeview">';
    	menu += (function (page) {
        	var menu = '';
        	for (var i in page.children) {
                if (typeof page.children[i] == 'object') {
            		smenu = arguments.callee(page.children[i]);
            		if (smenu != '') {
                        menu += '<li id="xooki-'+page.children[i].id+'" class="submenu">'+xooki.html.pageLink(page.children[i]);
            			if (smenu.indexOf('id="xooki-'+xooki.page.id+'"') != -1 
            				|| page.children[i].id == xooki.page.id) {
            				// either a descendant or the node processed is the current page node
            				// we specify that the menu must be opened by default
            				menu += '<ul class="open"';
    	        			menu += '>'+smenu+'</ul>';
            			} else {
    						menu += '<ul class="closed"';
    	        			menu += '>'+smenu+'</ul>';
    					}
            		} else {
                        menu += '<li id="xooki-'+page.children[i].id+'">'+xooki.html.pageLink(page.children[i]);
                    }
            		menu += '</li>';
                }
        	}
        	return menu;
        })(xooki.toc);
    	menu += '</ul>';
    	return menu;
    },
    
    messages: function () {
        return '<div id="xooki-messages" onclick="xooki.html.hide(\'xooki-messages\')" style="zIndex:999;display:none;position:absolute;top:30px;padding:10px;border-style:solid;background:#eeeeee;"></div>';
    },

    debugPanel: function () {
        return '<div id="xooki-debug" style="display:none;margin-top:15px;padding:10px;border-style:solid;background:#eeeeee;"><strong>Xooki Console</strong><br/><textarea cols="100" rows="15" id="xooki-console">'+xooki.console+'</textarea><hr/><a href="javascript:xooki.debugShowDetail(document.getElementById(\'xooki-body\').innerHTML)">content</a> <a href="javascript:xooki.debugShowDetail(xooki.c.body)">xooki body</a> <a href="javascript:xooki.debugShowDetail(document.body.innerHTML)">whole body</a> <a href="javascript:xooki.action.evaluate()">evaluate</a><br/><textarea cols="100" rows="15" id="xooki-debug-detail"></textarea></div>';
    },

    printerFriendlyLocation: function () {
        return xooki.url.action("print");
    },

    printerFriendlyLink: function () {
        return '<a href="'+this.printerFriendlyLocation()+'">'+t('Printer Friendly')+'</a>';
    },

    breadCrumb: function () {
        var breadCrumb = '<span class="breadCrumb">';
		breadCrumb += (function (page) {
        	var breadCrumb = xooki.html.pageLink(page);
			if (page.meta.level >= 1) {
				breadCrumb = arguments.callee(page.meta.parent) + " &gt; " + breadCrumb;
			}
        	return breadCrumb;
        })(xooki.page);
		breadCrumb += '</span>';
		return breadCrumb;
    }
};

xooki.render = {};
xooki.render.printerFriendlyAsyncLoader = function(source, arr) {
	var root = arr[0];
	var page = arr[1];
    if (source == null) {
        return;
    }
	var level = page.meta.level - root.meta.level + 1;
	
    // compute printer friendly block
    var beginIndex = source.indexOf('<textarea id="xooki-source">');
    beginIndex += '<textarea id="xooki-source">'.length;
    var endIndex = source.lastIndexOf('</textarea>');
    source = source.substring(beginIndex, endIndex);
    
    var printerFriendly = "<h"+level+">"+page.title+"</h"+level+">";
    printerFriendly += xooki.input.format.main(source, level) + "<hr/>";
    // inject block in page
    var pf = document.getElementById('xooki-printerFriendly');
    pf.innerHTML += printerFriendly;    
    
    // continue recursive loading
   	var nextPage = xooki.toc.getNextPage(page, root);
   	if (nextPage != null) {
    	xooki.url.asyncLoadURL(pu(nextPage.id), xooki.render.printerFriendlyAsyncLoader, [root, nextPage]);
   	}
};

xooki.render.printerFriendlyAsync = function() {
	xooki.c.body = xooki.c.messages
	+ "<div id='xooki-printerFriendly'></div>" // div where printer friendly content will be put
    + xooki.c.debugPanel;
    
    document.body.innerHTML = xooki.string.processTemplate(xooki.template.body, xooki.c);
    
    // start async loading of content
    xooki.url.asyncLoadURL(pu(xooki.page.id), xooki.render.printerFriendlyAsyncLoader, [xooki.page, xooki.page]);
};

xooki.render.printerFriendlySync = function() {
	xooki.c.body = xooki.c.messages
    + (function (page, level) {
        var source = xooki.url.loadURL(pu(page.id));
        if (source == null) {
            return "";
        }
        var beginIndex = source.indexOf('<textarea id="xooki-source">');
        beginIndex += '<textarea id="xooki-source">'.length;
        var endIndex = source.lastIndexOf('</textarea>');
        source = source.substring(beginIndex, endIndex);
        
        var printerFriendly = "<div class='toc-title toc-title-"+level+"'>"+page.title+"</div>";
        printerFriendly += xooki.input.format.main(source, level);
        for (var i=0; i <page.children.length; i++) {
            printerFriendly += "<hr/>";
            printerFriendly += arguments.callee(page.children[i], level+1);
        }
        return printerFriendly;
    })(xooki.page, 1);
    
    xooki.html.setBody(xooki.string.processTemplate(xooki.template.body, xooki.c));
};

xooki.render.printerFriendly = function() {
    for (var k in xooki.component) {
        xooki.c[k] = xooki.component[k]();
    }
    
	if (batchMode) {
		xooki.render.printerFriendlySync();
	} else {
		xooki.render.printerFriendlyAsync();
	}
};


xooki.render.page = function() {
    // realize all components available
    for (var k in xooki.component) {
        xooki.c[k] = xooki.component[k]();
    }
    
    xooki.input.source();
    
    if (xooki.c.allowEdit) {
    	xooki.c.body = xooki.c.messages
            + xooki.c.toolbar
            + '<div id="xooki-content">' 
                + '<div id="xooki-body"></div>'
            + '</div>'
            + xooki.c.editZone
            + xooki.c.debugPanel;
    } else {
    	xooki.c.body = xooki.c.messages
            + '<div id="xooki-content">' 
                + '<div id="xooki-body"></div>'
            + '</div>'
            + xooki.c.debugPanel;
    }

    xooki.html.setBody(xooki.string.processTemplate(xooki.template.body, xooki.c));
    
    xooki.input.applyChanges();
};

xooki.render.main = function() {
    if (xooki.c.action == "print") {
        // render the printer friendly version of the page
        this.printerFriendly();
    } else {
        // render the page normally
        this.page();
    }
};

xooki.input = {
    source: function() {
        if (typeof document != 'undefined' && document.getElementById('xooki-source') != null) {
            this._source = document.getElementById('xooki-source').value;
        }
        return this._source;
    },
    processed: function() {
        return this.format.main(this.source());
    },
    
    format: {
        getInputFilters: function (inputFormat) {
            return xooki.c[inputFormat+"InputFormat"];
        },
        define: function (inputFormat, filters) {
            // define a new inputFormat
            // inputFormat: the new input format name
            // filters: an array of input filter names
            xooki.c[inputFormat+"InputFormat"] = filters;
        },
        main: function(source, level) {
            // formats an input source
            if (xooki.c.inputFormat && typeof this.getInputFilters(xooki.c.inputFormat) != "undefined") {
                format = xooki.c.inputFormat;
            } else {
                format = xooki.c.defaultInputFormat;
            }
            filters = this.getInputFilters(format);
            for (var i in filters) {
                if (typeof filters[i] == 'string') {
    				xooki.debug('processing filter '+filters[i]);
                    f = xooki.input.filters[filters[i]];
                    if (typeof f == "function") {
                    	try {
                        	source = f(source, level); // process filter
                        } catch (e) {
    	                    xooki.error(e, t("error occurred while processing filter ${0}", filters[i]));
                        }
                    } else {
                        xooki.error(t("unknown filter ${0} used in input format ${1}", filters[i], format));
                    }
                }
            }
            return source;
        }
    }, 
    
    filters: {
        url: function (input) {
            // handle urls
            return input.replace(new RegExp("(?:file|http|https|mailto|ftp):[^\\s'\"]+(?:/|\\b)", "g"), function (str, offset, s) {
                var before = s.substring(0,offset);
                if (before.match(/(href|src)="$/)) {
                    return str;
                } else {
                    return '<a href="'+str+'">'+str+'</a>';
                }
            });
        },
        
        shortcuts: function (input) {
            // handle shortcut links like this:
            //    [[svn:build.xml]] => <a href="https://xooki.svn.sourceforge.net/svnroot/xooki/trunk/build.xml">build.xml</a>
            //    [[svn:test/example.js a good example]] => <a href="https://xooki.svn.sourceforge.net/svnroot/xooki/trunk/test/example.js">a good example</a>
            // needs to be configured in xooki config like this
            //      xooki.c.shortcuts.<any shortcut>.url = base url of the shortcut. 
            //      ex: xooki.c.shortcuts.svn.url = https://xooki.svn.sourceforge.net/svnroot/xooki/trunk/
            return input.replace(new RegExp("\\[\\[([^:\n]+):([^\\]\n]+)\\]\\]", "g"), function (str, prefix, code, offset, s) {
            	if (typeof xooki.c.shortcuts == "undefined" || typeof xooki.c.shortcuts[prefix] == "undefined") {
                    xooki.debug('unknown shortcut '+prefix);
            		return str;
            	}
                var index = code.indexOf(' ');
                var path = index>0?code.substring(0,index):code;
                
                var title = index>0?code.substring(index+1):path;
                var pre = typeof xooki.c.shortcuts[prefix].pre == "undefined"?'':xooki.c.shortcuts[prefix].pre;
                var post = typeof xooki.c.shortcuts[prefix].post == "undefined"?'':xooki.c.shortcuts[prefix].post;
                return '<a href="'+pre+path+post+'">'+title+'</a>';
            });
        },
        
        xookiLinks: function (input) {
            // handle xooki links like this:
            //    [[page/id]]
            //    [[page/id My Title]]
            return input.replace(new RegExp("\\[\\[([^\\]]+)\\]\\]", "g"), function (str, code, offset, s) {
                var index = code.indexOf(' ');
                var id = (index>0?code.substring(0,index):code);
                
                var title;
                var url;
                var invalid = false;
                
                if (typeof xooki.toc.pages[xooki.toc.importRoot + id] != "undefined") {
               	    title = xooki.toc.pages[xooki.toc.importRoot + id].title;
                    url = pu(xooki.toc.importRoot + id);
               	} else if (xooki.toc.importRoot.length > 0 && typeof xooki.toc.pages[id] != "undefined") {
               	    title = xooki.toc.pages[id].title;
                    url = pu(id);
               	} else {
                    invalid = true;
               		title = code;
               		url = u(id);
               	}
                if (index>0) {
                	title = code.substring(index+1);
                }
                if (invalid) {
                    if (batchMode) {
                        // do not output invalid links as links in batch mode
                        return title;
                    } else {
                        return title+'<a href="'+url+'">?</a>';
                    }
                } else {
                    return '<a href="'+url+'">'+title+'</a>';
                }
            });
        },
        
        wikiMarkup: function (input) { 
            // handle bold
            input = input.replace(new RegExp("\\*([^\n]+)\\*", "g"), "<b>$1</b>");
            
            // handle italic
            input = input.replace(new RegExp("\\_([^\n]+)\\_", "g"), "<em>$1</em>");
            
            return input;
        },
        
        jira: function (input) { 
            // auto replace jira issue ids (like IVY-12) by a link to the issue
            // needs to be configured in xooki config like this
            //      xooki.c.jira.ids = an array of jira projects ids (ex: ["IVY", "ANT"])
            //      xooki.c.jira.url = the url of the jira server (ex: "http://issues.apache.org/jira")
            if (typeof xooki.c.jira != "object") {
                return input;
            }
            input = input.replace(new RegExp("(("+xooki.c.jira.ids.join("|")+")-\\d+)([^\"\\d])", "g"), '<a href="'+xooki.c.jira.url+'/browse/$1">$1</a>$3');
            
            return input;
        },
        
        code: function (input) {
            codeSection = xooki.string.findXmlSection(input, "code");
            from = 0;
            while (codeSection != null) {
                processedSection = "<pre>" 
                    + input.substring(codeSection.innerStart, codeSection.innerEnd).replace(/</g, "&lt;").replace(/>/g, "&gt;") // .replace(/\n/g, "<br/>")
                    + "</pre>";
                input = input.substring(0, codeSection.outerStart)
                    + processedSection
                    + input.substring(codeSection.outerEnd);
                from = codeSection.outerStart + processedSection.length;
    
                codeSection = xooki.string.findXmlSection(input, "code", from);
            }
            return input;
        },
        
        lineBreak: function (input) {
            return input.replace(new RegExp("\r?\n", "g"), function (str, offset, s) {
                var before = s.substring(0,offset);
                var after = s.substring(offset+str.length);
                if (after.match(/^<\/?(ul|table|li|pre|div)(\s*\w+="[^"]+")*\s*>/i) || (before.match(/<\/?\w+(\s*\w+="[^"]+")*\s*\/?>\s*$/i) && !before.match(/<\/?(a|b|strong|em|i|big|br class="xooki-br")(\s*\w+="[^"]+")*\s*\/?>\s*$/i))) { 
                    return '\n';
                } else {
                    return '<br class="xooki-br"/>'; // the class is not really necessary but allow to distinguish generated br from input one
                }
            });
        },
        
        includes: function (input) {
	        //[<url>] replaced by the content of the url
	        result = "";
	        lastStart = 0;
	        nextPos = input.indexOf("[<" , lastStart);
	        while( nextPos > 0 ) {
		        result = result + input.slice(lastStart,nextPos);
		        lastStart = nextPos;
		        nextPos = input.indexOf(">]" , lastStart);
		        result = result + xooki.url.loadURL(lu(input.slice(lastStart+2,nextPos)));
		        lastStart = nextPos + 2;
		        nextPos = input.indexOf("[<" , lastStart);
	        }
            return result + input.slice(lastStart);
        },

        printFormatImgFix: function (input, level) {
			if (level == undefined || level < 3) {
				return input;
			}
			return input.replace(new RegExp('<img +src *= *\\"([^\\"]*)\\"', "g"), function (str, img, offset, s) {
				l = level;
				while (l > 2) {
					if (img.indexOf("../") >= 0) {
						img = img.substring(3);
					} else {
						break;
					}
					l--;
				}
				return '<img src="'+img+'"';
			});
		}
    },
    
    
    applyChanges: function() {
    	document.getElementById('xooki-body').innerHTML = xooki.input.processed();
    }
};


xooki.postProcess = function() {
	xooki.render.main();
	window.onkeypress = keyCtrl;
};


if (typeof xooki.io == "undefined") {
    xooki.io = {};
}


xooki.action = {}
xooki.action.toggleDebug = function() {
    if (xooki.c.debug) {
    	if (document.getElementById('xooki-debug').style.display == 'none') {
    		xooki.html.show('xooki-debug');
    	} else {
    		xooki.html.hide('xooki-debug');
    	}
	}
}
xooki.action.evaluate = function () {
    var exp = prompt("Please enter javascript expression to evaluate");
    xooki.debugShowDetail(eval(exp));
}

// TODO, review use registration
function keyCtrl(evt) {
	var code = xooki.c.browser.NS ? evt.which : event.keyCode;
	var ctrl = xooki.c.browser.NS ? evt.ctrlKey : event.ctrlKey;
  	var key = String.fromCharCode(code);
	if (xooki.c.debug && ctrl && "d" == key) {
		xooki.action.toggleDebug();
		return false;
	}
	if (xooki.c.allowEdit && ctrl && "s" == key) {
		xooki.action.saveChanges();
		return false;
	}
	if (xooki.c.allowEdit && ctrl && "e" == key) {
		xooki.action.toggleEdit();
		return false;
	}
}

// xooki engine init function
xooki.init = function() {
    ////////////////////////////////////////////////////////////////////////////
    ////////////////// config init
    ////////////////////////////////////////////////////////////////////////////
    initConfigProperty = function(prop, value, defaultValue) {
        if (typeof this[prop] == "undefined") {
            if (typeof value == "undefined") {
                this[prop] = defaultValue;
            } else if (typeof value == "function") {
                this[prop] = value();
            } else {
                this[prop] = value;
            }
        }
    };
    if (typeof xookiConfig != "undefined") {xooki.util.mix(xookiConfig, xooki.config);}
    xooki.c.initProperty = initConfigProperty;
    xooki.c.computeRoot = function() {
    	root = xooki.pageURL;
    	// remove trailing parts of the URL to go the root depending on level
    	for (var i=0; i < xooki.c.level + 1; i++) {
    		root = root.substring(0, root.lastIndexOf('/'));
    	}
    	return root + '/';
    };
    xooki.c.computeRelativeRoot = function() {
    	return xooki.string.mul('../', xooki.c.level);
    };
    xooki.c.setImportLevel = function(level) {
        // compute roots with old level value, for paths relative to the local (non imported) root
        this.localRoot = this.computeRoot();
        this.localRelativeRoot = this.computeRelativeRoot();
        // change level and update roots
        this.level+=level;
        this.root = this.computeRoot();
        this.relativeRoot = this.computeRelativeRoot();
    };
    xooki.c.initProperty("level", 0);
    xooki.c.initProperty("root", xooki.c.computeRoot);
    xooki.c.initProperty("relativeRoot", xooki.c.computeRelativeRoot);
    xooki.c.initProperty("localRoot", xooki.c.root);
    xooki.c.initProperty("localRelativeRoot", xooki.c.relativeRoot);
    globalConfig = xooki.url.loadURL(u("config.json"), false);
    if (globalConfig != null && globalConfig.length != 0) {
        globalConfig = eval('('+globalConfig+')');
        xooki.util.mix(globalConfig, xooki.c, false);
    }
    xooki.url.evalURL(u("config.js"), false);
    xooki.url.evalURL(u("config.extra.js"), false);


    xooki.c.initProperty("defaultInputFormat", "xooki");
    xooki.c.initProperty("xookiInputFormat", ["xooki"]);
    xooki.c.initProperty("allowEdit", !batchMode && xooki.pageURL.substr(0,5) == "file:");
    
    xooki.input.format.define("xooki", ["code", "shortcuts", "url", "xookiLinks", "jira", "lineBreak" , "includes", "printFormatImgFix"]);
    
    xooki.c.path = (typeof xooki.c.path != "undefined")?xooki.c.path:{};
    xooki.c.path.initProperty = initConfigProperty;
    xooki.c.path.initProperty("install", "xooki");
    xooki.c.path.initProperty("messages", xooki.p("messages.json"));
    xooki.c.path.initProperty("template", "template.html");
    xooki.c.path.initProperty("printTemplate", "printTemplate.html");
    xooki.c.path.initProperty("toc", "toc.json");
    xooki.c.path.initProperty("blankPageTpl", xooki.p("blankPageTpl.html"));
    
    
    xooki.c.css = (typeof xooki.c.css != "undefined")?xooki.c.css:{};    
        
    xooki.c.messages = xooki.json.loadURL(cu("messages")); 
	if (!batchMode) {
	    xooki.c.browser = {
	        NS: (window.Event) ? 1 : 0
	    };
    
	    // action
	    if (! xooki.c.action) xooki.c.action = 'render';
	    // TODO: better handle action extraction
		xooki.c.action = window.location.search == '?action=print'?'print':xooki.c.action;
	}
	
	var match = new RegExp("^.*\\/((?:.*\\/){"+xooki.c.level+"}[^\\/]*)(?:\\.\\w+)(?:\\?.+)?$", "g").exec(xooki.pageURL);
	if (match == null || match[1] == '') {
		xooki.c.curPageId = "index";
	} else {
		xooki.c.curPageId = match[1];
	}
    
    ////////////////////////////////////////////////////////////////////////////
    ////////////////// TOC init
    ////////////////////////////////////////////////////////////////////////////
    xooki.toc = xooki.json.loadURL(cu("toc"));
    xooki.toc.url = cu("toc");
    xooki.toc.pages = {}; // to store a by id map of pages objects
    xooki.toc.importRoot = '';
    xooki.toc.actualRoot = xooki.toc; // this is the real root of the TOC, in case of a TOC imported, it will point to the root of the TOC on which import has been performed

	// populate meta data
	(function(page, parent, index, level, prefix) {
        if (prefix.length > 0) {
            page.meta = xooki.util.mix({id: page.id}, page.meta);
            page.id = prefix + page.id;
        }
        xooki.toc.pages[page.id] = page;
        
        page.meta = xooki.util.mix({
            index: index,
            level: level,
            getSerializeValue: function(o, k) {
                if (k == 'id' && typeof this.id != 'undefined') {
                    return this.id;
                } else {
                    return o[k];
                }
            }
        }, page.meta);
        page.meta.parent = parent;
        if (typeof page.importNode != 'undefined' && !page.isImported) {
            // this node requires to import another xooki TOC
            importedTocUrl = u(page.importRoot + '/toc.json');
            importedToc = xooki.json.loadURL(importedTocUrl);
            // look for the imported node in the importedTOC and import it in main TOC
            (function(page, parent, index, level, prefix, importedToc, node, id, populateFunction) {
                if (node.id == id) {
                    xooki.util.mix(node, page, false);
                    page.id = id;
                    page.isImported = true;
                    page.meta = xooki.util.mix({
                        isTransient: function(k) {
                            // only title, importRoot and importNode should be serialized
                            return k != 'title' && k != 'importRoot' && k != 'importNode';
                        }
                    }, page.meta);
                    if (xooki.c.curPageId.indexOf(prefix) == 0) {
                        // the current page is in this imported TOC
                        xooki.toc.actualRoot = importedToc;
                        xooki.toc.url = u(page.importRoot + '/toc.json');
                        xooki.toc.importRoot = prefix;
                    }
                    populateFunction(page, parent, index, level, prefix);
                    return true;
                } else if (typeof node.children != 'undefined') {
                    for (var i=0; i<node.children.length; i++) {
                        if (arguments.callee(page, parent, index, level, prefix, importedToc, node.children[i], id, populateFunction)) {
                            return true;
                        }
                    }
                }
                return false;
            })(page, parent, index, level, page.importRoot+'/', importedToc, importedToc, page.importNode, arguments.callee);
        }
        if (typeof page.children == 'undefined') {
            page.children = [];
        } else {
            for (var i=0; i<page.children.length; i++) {
                arguments.callee(page.children[i], page, i, level+1, prefix); // recurse
            }
        }
    })(xooki.toc, null, 0, -1, '');
    
    xooki.toc.getNextPage = function(page, root) {
        if (page.children.length > 0) {
        	return page.children[0];
        } else if (page.meta.parent != null) {
        	var cur = page;
        	var next = xooki.toc.getNextSibling(cur);
        	while (next == null) {
        		cur = cur.meta.parent;
        		if (cur == null || cur == root) {
        			return null;
        		}
        		next = xooki.toc.getNextSibling(cur);
        	}
       		return next;
        } else {
        	return null;
        }
    };
    xooki.toc.getNextSibling = function(page) {
    	if (page.meta.parent == null) {
    		return null;
    	}
       	if (page.meta.parent.children.length > page.meta.index) {
       		return page.meta.parent.children[page.meta.index+1];
       	} else {
       		return null;
       	}
    };
	xooki.page = xooki.toc.pages[xooki.c.curPageId];

	if (xooki.page == null) {
		xooki.warn(t('page id not found in TOC: ${0}',xooki.c.curPageId));
		xooki.page = xooki.toc.children[0];
	} 
	if (typeof xooki.config.title == 'undefined') {
		xooki.config.title = xooki.page.title;
	}		
	xooki.config.page = xooki.page;
	
    ////////////////////////////////////////////////////////////////////////////
    ////////////////// main template loading + head output
    ////////////////////////////////////////////////////////////////////////////
	xooki.template = {};
    xooki.template.source = xooki.url.loadURL(xooki.c.action == "print"?cu("printTemplate"):cu("template"));
	if(xooki.template.source != null) {
		xooki.template.head = xooki.template.source.match(/<head>([^�]*)<\/head>/im)[1];
		var root = batchMode?xooki.c.relativeRoot:xooki.c.root;
		
        var head = xooki.string.processTemplate(xooki.template.head, xooki.config);
		head = head.replace(/href="([^\\$:"]+)"/g, 'href="'+root+'$1"');
		head = head.replace(/src="([^\\$:"]+)"/g, 'src="'+root+'$1"');
		xooki.html.addHeader(head);

		var body = xooki.template.source.match(/<body>([^�]*)<\/body>/im)[1];
		body = body.replace(/href="([^\\$:"]+)"/g, 'href="'+root+'$1"');
		xooki.template.body = body.replace(/src="([^\\$:"]+)"/g, 'src="'+root+'$1"');		
	}
	

    ////////////////////////////////////////////////////////////////////////////
    ////////////////// includes
    ////////////////////////////////////////////////////////////////////////////
	if (batchMode) {
		xooki.html.addHeader('<script language="javascript" type="text/javascript">xooki = {u: function(url) {return "'+xooki.c.relativeRoot+'xooki/"+url;}};</script>');
	}
    if (xooki.c.allowEdit) {
        xooki.url.include("xookiEdit.js");
    }

    for (var k in xooki.c) {
        if (typeof xooki.c[k] == "string" || typeof xooki.c[k] == "number" || typeof xooki.c[k] == "boolean") {
            xooki.debug(k+": "+xooki.c[k]);
        }
    }
};

if (batchMode) {
	importPackage(java.io);
	
	xooki.io.loadFile = function( url, warnOnError ) {
	  var str = '';
	  try {
      var r = new BufferedReader(new FileReader(url));
	  line = r.readLine();
	  while (line != null) {
		str += line + '\n';
		line = r.readLine();
	  }
	  r.close();
	  } catch (e) {
	  	if (warnOnError) {
	  		throw e;
	  	} else {
	  		xooki.debug("error occurred while loading "+url);
	  	}
	  }
	  return str;
    };
	
	xooki.io.saveFile = function (fileUrl, content) {
		p = new File(fileUrl).getParentFile();
		if (p != null) {
			p.mkdirs();
		}
		pw = new PrintWriter(new FileWriter(fileUrl));
		pw.write(content);
		pw.close();
		return true;
	}

    xooki.url.loadURL = function( url, warnOnError ) {
		return xooki.io.loadFile(url, warnOnError );
	};
	
	xooki.html.addHeader = function (head) {
		xooki.pageContent = xooki.pageContent.replace(/<\/head>/, head+'\n</head>');
	};
	
	xooki.html.setBody = function(body) {
		xooki.pageContent = xooki.pageContent.replace(/<body>(.|[^,])*<\/body>/gm, '<body>'+body+'</body>');
	}
	
	xooki.url.include = function(script_filename) {
		xooki.html.addHeader('<script language="javascript" type="text/javascript" src="'+xooki.c.relativeRoot+'xooki/'+script_filename+'"></script>');
	};
	
	xooki.input.source = function() {
		if (typeof this._source == 'undefined') {
			xooki.debug('searching source');
			var beg = xooki.pageContent.indexOf('<textarea id="xooki-source">');
			beg += '<textarea id="xooki-source">'.length;
			var end = xooki.pageContent.lastIndexOf('</textarea>');
			this._source = xooki.pageContent.substring(beg, end);
			xooki.debug('source found');
		}
		return this._source;
	}
	
	xooki.render.page = function() {
	    // realize all components available
		xooki.debug('realizing components');
	    for (var k in xooki.component) {
	        xooki.c[k] = xooki.component[k]();
	    }
	    
		xooki.debug('processing body');
		xooki.c.body = xooki.input.processed();

		xooki.debug('updating body');
		var body = xooki.string.processTemplate(xooki.template.body, xooki.c);
	    xooki.html.setBody(body);
	};

	xooki.display = function(message, background) {
		print(message);
	};
	
	xooki.debug = function (message) {
		if (xooki.c.debug) {
			print(message+'\n');
		}
	};
	var i=0;
	if (arguments.length > i && arguments[0] == '-debug') {
		xooki.c.debug = true;
		i++;
	} else {
		xooki.c.debug = false;
	}
	
	var file = 'index.html';
	if (arguments.length > i) {
		file = arguments[i];
		i++;
	}
	var generateTo = "gen";
	if (arguments.length > i) {
		generateTo = arguments[i];
		i++;
	}
	xooki.c.action = 'render';
	if (arguments.length > i) {
		xooki.c.action = arguments[i];
		i++;
	}

	xooki.pageURL = new File(file).toURL().toExternalForm();
	
	print('processing '+new File(file).getAbsolutePath()+'...\n');
	xooki.pageContent = xooki.io.loadFile(file);
    
    if (xooki.pageContent.match(/<textarea\s+id="xooki\-source">/) == null) {
        print(file + ' is not a valid xooki source. ignored.');
    } else {	
    	var m = /var\s+xookiConfig\s+=\s+{.*};/.exec(xooki.pageContent);
    	if (typeof m != 'undefined' && m != null) {
    		eval(m[0]);
    	}

        xooki.init();
        
    	xooki.pageContent = xooki.pageContent.replace(/<script type="text\/javascript" src="[^"]*xooki.js"><\/script>/g, '');
    	
    	xooki.render.main();

		var dest = generateTo.endsWith(".html") ? generateTo : generateTo+'/'+file;
    	print('generating to '+dest);
    	xooki.io.saveFile(dest, xooki.pageContent);
    }
} else {
	xooki.pageURL = window.location.toString();
    xooki.init();
}