
define([ 'mmirf/parserModule','mmirf/parsingResult','mmirf/templateProcessor'
		,'mmirf/templateLexer','mmirf/ES3Lexer','mmirf/ES3Parser','mmirf/contentLexer','mmirf/contentParser'
		,'mmirf/scriptLexer','mmirf/scriptParser','mmirf/antlr3'
	],

	/**
	 * A Utility class for parsing (eHTML) templates.<br>
	 * Utility functions for parsing templates (and template elements, e.g. JS-parts of template expressions)
	 *
	 * @class
	 * @name ParserUtils
	 * @memberOf mmir.parser
	 * @static
	 * @hideconstructor
	 *
	 * @public
	 * @example mmir.require('mmirf/parseUtils').parse(str, view)
	 */
	function( parser, ParsingResult, templateProcessor
		, MmirTemplateLexer, ES3Lexer, ES3Parser, MmirScriptContentLexer, MmirScriptContentParser
		, MmirScriptLexer, MmirScriptParser, org
){

	/**
	 * add extend-function for MmirTemplateLexer objects:
	 *  attaches the main processing functionality for parsing the template files
	 *
	 *  (NOTE the extend-function is called in the constructor, see MmirTemplate.g and MmirTemplateLexer.js)
	 *
	 * @type Function
	 * @memberOf MmirTemplateLexer.prototype
	 */
	MmirTemplateLexer.__mmirExtend = templateProcessor;

	/**
	 * @memberOf ES3Parser.prototype
	 * @function getVarReferences
	 */
	ES3Parser.prototype.getVarReferences = function(){

		var size = this.ampersatIdentifiers.length;

		if(size === 0){
			return null;
		}

		var varRefs = new Array(size);
		for(var i=0; i < size; ++i){
			var ref = this.ampersatIdentifiers[i];

			var refObj = new ParsingResult(ref);
//			refObj.start = ref.start;

			//correct end-position (token's stop-index is exactly the last char-index, whereas ParsingResult's end-position is token.stopIndex + 1)
			refObj.end = refObj.getEnd() + 1;

			refObj.type = parser.element.VAR_REFERENCE;

			varRefs[i] = refObj;
		}
		return varRefs;
	};

	////////////////////////////////////helper for debugging / printing error details ////////////////////////

	/**
	 * -2: internal debug
	 * -1: interanl info
	 *  0: debug
	 *  1: info
	 *  2: warn
	 *  3: error
	 * TODO make this set-able (export getter/setter? use configurationManager?)
	 *
	 * @private
	 * @memberOf mmir.parser.ParserUtils#
	 */
	var errorLevel = 2;


	/**
	 * HELPER print internal debug messages during parsing (VERY VERBOSE)
	 *
	 * @private
	 * @memberOf mmir.parser.ParserUtils#
	 */
	function _print(msg){//FIXME
		if ( errorLevel <= -2 ) console.log(msg);
	};
	parser.print = _print;

	/**
	 * HELPER print internal, informational messages during parsing (VERBOSE)
	 *
	 * @private
	 * @memberOf mmir.parser.ParserUtils#
	 */
	function _printInfo(prefix, msg){//FIXME
		if (  errorLevel <= -1 ) console.info(parser.parserCreatePrintMessage(prefix,msg));
	};
	parser.printInfo = _printInfo;

	/**
	 * HELPER print debug messages during parsing
	 *
	 * @private
	 * @memberOf mmir.parser.ParserUtils#
	 */
	function _parserPrintDebug(prefix, msg, source){//FIXME
		if (  errorLevel <= 0  ) console.debug(parser.parserCreatePrintMessage(prefix,msg, source));
	};
	parser.parserPrintDebug = _parserPrintDebug;

	/**
	 * HELPER print informational messages during parsing
	 *
	 * @private
	 * @memberOf mmir.parser.ParserUtils#
	 */
	function _parserPrintInfo(prefix, msg, source){//FIXME
		if (  errorLevel <= 1  ) console.info(parser.parserCreatePrintMessage(prefix,msg, source));
	};
	parser.parserPrintInfo = _parserPrintInfo;

	/**
	 * HELPER print warnings during parsing
	 *
	 * @private
	 * @memberOf mmir.parser.ParserUtils#
	 */
	function _parserPrintWarning(prefix, msg, source){//FIXME
		if (  errorLevel <= 2  ) console.warn(parser.parserCreatePrintMessage(prefix,msg, source));
	};
	parser.parserPrintWarning = _parserPrintWarning;

	/**
	 * HELPER print errors during parsing
	 *
	 * @private
	 * @memberOf mmir.parser.ParserUtils#
	 */
	function _parserPrintError(prefix, msg, source){
		if (  errorLevel <= 3  ) console.error(parser.parserCreatePrintMessage(prefix,msg, source));
	};
	parser.parserPrintError = _parserPrintError;

	/**
	 * HELPER: attach internal print-functions to all classes (ie. prototypes) in the list
	 *
	 * @private
	 * @memberOf mmir.parser.ParserUtils#
	 */
	var _attachInternalPrintFunc = function(list){
		var _prototype;
		for(var i=0, size=list.length; i < size; ++i){
			_prototype = list[i].prototype;
			_prototype.printInfo  = parser.printInfo;
			_prototype.printDebug = parser.print;
		}
	};

	//attach the internal debug/print functions to all lexers/parsers:
	// (-> see import-list in define() above)
	_attachInternalPrintFunc([
		MmirTemplateLexer, ES3Lexer, ES3Parser, MmirScriptContentLexer, MmirScriptContentParser
		, MmirScriptLexer, MmirScriptParser
	]);

	/**
	 * @type mmir.view.View
	 * @private
	 * @memberOf mmir.parser.ParserUtils#
	 */
	var _currentParsedView = null;//FIXME make this an argument in the printXXX functions (e.g. the current mechanism will not work, if templates are parsed concurrently/in parallel/using threads)

	/**
	 * Creates a message with parsing-information.
	 *
	 * In case the <code>msg</code> is an error message containing relative/incorrect location information,
	 * an heuristic will be used to fix the location information; in addition the references location
	 * will be extracted from the source-String and a "pointer-String" will be generated, e.g.
	 * <pre>
	 * 	source:   "  	@{  mmmm.['sd']=wer ;}@"
	 * 	pointer:  "  	        ^"
	 * </pre>
	 *
	 * @function
	 * @param {String} prefix
	 * 					a prefix for the message
	 * @param {String} msg
	 * 					the original message (may contain location-information "line <line_i>:<position_j>")
	 * @param {Object} [tokenSource] OPTIONAL
	 * 					the token-source, from where the error/message was triggered
	 * 					If the argument has the field <code>tokenSource.offset</code> (Number)
	 * 					 if will be used to correct/fix the location information in the original message.
	 * 					If the argument has the fields <code>tokenSource.start</code> (Number) and
	 * 					 <code>tokenSource.end</code> (Number), then this will be used to correct/fix
	 * 					 the location information in the original message text.
	 * @param {Object} [viewObj] OPTIONAL
	 * 					currently not used!
	 * 					(will replace _currentParsedView in the future!)
	 *
	 * @private
	 * @memberOf mmir.parser.ParserUtils#
	 */
	var parserCreatePrintMessage = (function(){//return function(prefix, msg, tokenSource, viewObj)

		/**
		 *
		 * Get the index in the String str, where line number lineNo
		 * starts.
		 *
		 * New lines begin after \n, \r\n, or \r.
		 *
		 * If lineNo is <= 1, the function returns always 0.
		 *
		 * If the lineNo is greater than the count of lines in str, the string length itself is returned.
		 *
		 * <p>
		 * NOTE used by {@link #parserCreatePrintMessage}
		 *
		 * @function
		 * @param {String} str the string
		 * @param {Number} lineNo the line number (first line is 1)
		 *
		 * @private
		 * @memberOf mmir.parser.ParserUtils.parserCreatePrintMessage
		 */
		var getIndexForLine = (function(){

			var detectLinebreak = /(\r?\n|\r)/igm;

			return function(str, lineNo){
				if(lineNo <= 1){
					return 0;
				}
				var match;
				var count = 1;
				while(match = detectLinebreak.exec(str)){
					//ASSERT: lineNo >= 2
					if(++count == lineNo){
						break;
					}
				}

				//reset regexpr:
				detectLinebreak.lastIndex = 0;

				if(match){
					return match.index + match[1].length;
				}

				//request line-no. >= 2 AND loop "detect enough" linebreaks => the request line index starts after strings ends => return string's length
				return str.length;
			};
		})();//END getIndexForLine

		/**
		 *
		 * Get the line in the String str, in which the char at index is included.
		 *
		 * New lines begin after \n, \r\n, or \r,
		 * e.g. for line X:
		 * <pre>
		 *  ...\r\n
		 *        ^
		 * </pre>
		 * the line number will be X (i.e. the line-break itself is still included in the current line).
		 * <p>
		 * If index is < 0, the function returns always 1.
		 * <p>
		 * If the index is greater than str.length, -1 is returned.
		 * <p>
		 * NOTE used by {@link #extractErrorPosition}
		 *
		 * @function
		 * @param {String} str the string
		 * @param {Number} index the char index for which to find the line number (first line is 1)
		 *
		 * @private
		 *
		 * @memberOf mmir.parser.ParserUtils.parserCreatePrintMessage
		 *
		 */
		var getLineForIndex = (function(){

			var detectLinebreak = /(\r?\n|\r)/ig;

			return function(str, index){
				if(index < 0){
					return 1;
				}
				if(index >= str.length){
					return -1;
				}
				//ASSERT index is at least within line 1
				var match;
				var count = 1;
				var isNextLineFound = false;
			var currentPos = -1;
			var lastPos = 0;
				while(match = detectLinebreak.exec(str)){
				currentPos = match.index + match[1].length;
					if(currentPos > index){
						isNextLineFound = true;
						break;
					}
				lastPos = currentPos;
					++count;
				}

				//reset regexpr:
				detectLinebreak.lastIndex = 0;

				return {
					line : count,
					index: index - lastPos
				};
			};
		})();//END getLineForIndex

		/**
		 *
		 * NOTE used by {@link #parserCreatePrintMessage}
		 *
		 * @private
		 * @function
		 * @memberOf mmir.parser.ParserUtils.parserCreatePrintMessage
		 */
		var extractErrorPosition = (function(){

			var detectLineNo = /line (\d+):(-?\d+)/i;

			return function extractErrorPositionImpl(msg, offset, originalContent, tokenSource){
//				console.log('\nTEST1_extractErrorPositionImpl with arguments '+arguments.length+'\n');

				var result = detectLineNo.exec(msg);

				//reset regexpr:
				detectLineNo.lastIndex = 0;

//				console.log('\nTEST2_result for "'+msg+'": '+result+'\n');
				var pos = null;
				if(result){

					var line = parseInt(result[1],10);
					var index = parseInt(result[2],10);

					var isCorrected = false;

					if(tokenSource){

						//if we have "invalid" position-info.:
						//  -> the error probably occured at the very beginning of the parsed expression
						//  -> try to extract position from parent parser/lexer
						if(line === 0 || index === -1){
							line  = tokenSource.getLine();
							index = tokenSource.getCharPositionInLine();
						}

						//if there is an offest supplied by the tokenSource -> use it:
						if(tokenSource.offset){

							var iOffset = tokenSource.offset;
//							if(line === 1){
//								//
//								//this position information is derived from a script-eval (-> ConentElement.ScriptEvalError)
//								// -> need to increase offset by 1 or 2, since all script-elements have
//								//    an additional, internal offset of 1 or 2 (this is only an heuristical value...)
//								// e.g. @( ...
//								//      @{ ...
//								//   @for( ...
//								iOffset += 2;
//							}

							var contentOffset = getLineForIndex(originalContent, iOffset);

							//if it is "relatively" the first line, we need to adjust to index
							//   (i.e. the position within the line)
							if(line === 1){
								index += contentOffset.index;
							}

							//adjust the line, i.e. make "relative" -> "absolute" line number
							line += contentOffset.line - 1;

							isCorrected = true;
						}

					}

					pos = {
							line: line,
							index: index
					};
//					console.log('\nTEST3_pos: '+JSON.stringify(pos)+', offset: '+offset+'\n');

					if(offset && offset !== 0){
//						console.log('\nTEST4_offset: '+offset+'\n');

						var newLine = line;
						var newIndex = index;
						if( ! isCorrected){
							var lineOffset = getLineForIndex(originalContent, offset);
							if(line < 2){
								newIndex = lineOffset.index + index;
								pos.originalIndex = index;
								pos.index = newIndex;
							}
							newLine = lineOffset.line + line - 1;
							pos.originalLine = line;
							pos.line = newLine;
						}

						var fixed = msg.substring(0,result.index + 'line '.length) + newLine + ':' + newIndex + msg.substring(result.index + result[0].length);
						pos.text = fixed;
//						pos.originalContent = originalContent;
//						pos.offset = offset + pos.index;
					}
					else {
						pos.text = msg;
					}
				}
				else if(tokenSource && tokenSource.start && tokenSource.end){

					pos = getLineForIndex(originalContent, tokenSource.start);
					pos.text = ' near /';
				}

				return pos;
			};
		})();//END extractErrorPosition

		/**
		 * Create a message for parsing-information.
		 *
		 * In case the <code>msg</code> is an error message containing relative/incorrect location information,
		 * an heuristic will be used to fix the location information; in addition the references location
		 * will be extracted from the source-String and a "pointer-String" will be generated, e.g.
		 * <pre>
		 * 	source:   "  	@{  mmmm.['sd']=wer ;}@"
		 * 	pointer:  "  	        ^"
		 * </pre>
		 *
		 * @private
		 *
		 * @param {String} prefix
		 * 					a prefix for the message
		 * @param {String} msg
		 * 					the original message (may contain location-information "line <line_i>:<position_j>")
		 * @param {Object} [tokenSource] OPTIONAL
		 * 					the token-source, from where the error/message was triggered
		 * 					If the argument has the field <code>tokenSource.offset</code> (Number)
		 * 					 if will be used to correct/fix the location information in the original message.
		 * 					If the argument has the fields <code>tokenSource.start</code> (Number) and
		 * 					 <code>tokenSource.end</code> (Number), then this will be used to correct/fix
		 * 					 the location information in the original message text.
		 * @param {Object} [viewObj] OPTIONAL
		 * 					currently not used!
		 * 					(will replace _currentParsedView in the future!)
		 */
		return function parserCreatePrintMessageImpl(prefix, msg, tokenSource, viewObj){//FIXME
			var currentView = _currentParsedView;
			if(currentView != null){

				var rootView = null;
				var details = '';
				if(currentView.getController){
					details += 'CTRL("' + currentView.getController().getName() + '")';
				}

				if(currentView.getView){
					if(details.length > 0){
						details += '->';
					}
					details += 'VIEW("' + currentView.getView().getName() + '")';
					rootView = currentView.getView();
				}

				if(details.length > 0){
					details += '->';
				}
				details += currentView.constructor.name;

				if(currentView.getName){
					details += '("' + currentView.getName() + '")';
				}

				if(rootView && typeof currentView.getStart !== 'undefined'){

					var pos = extractErrorPosition(msg, currentView.getOffset(), rootView.getDefinition(), tokenSource);
		//			console.log('\nTEST_A_pos: '+JSON.stringify(pos)+', offset: '+currentView.getStart() +'\n');
					if(pos){

						msg = pos.text;

						//msg += '\n\t at line '+pos.line+', index '+pos.index;
						var content = rootView.getDefinition();
						var line = null;
						var offset = currentView.getStart();


						if(content){
							var start = getIndexForLine(content, pos.line);
							var end = start;
							var len = content.length;
							while(end < len && (content[end] != '\r' && content[end] != '\n')){
								++end;
							}

							line = content.substring(start,end);
						}

						if(line){

							//marker for "pointing" the error
							var marker = [];
							for(var i=0; i < pos.index; ++i){
								if(line[i] == '\t'){
									//need to include tabs themselves, since they
									//  take more than 1 char-positions when displayed:
									marker.push('\t');
								}
								else {
									marker.push(' ');
								}
							}
							//add marker symbol, that points to error in the line above:
							marker.push('^');

							msg += ' at line '+pos.line+':';
							msg += '\n "'+line+'"';        //<- the line with the error
							msg += '\n  '+marker.join(''); //<- the marker line (will only be correctly aligned for fixed-width fonts)
						}
					}
				}

				return prefix + 'in ' + details + ' - ' + msg;
			}
			else {
				return prefix+msg;
			}
		};//END parserCreatePrintMessage

	})();//END var parserCreatePrintMessage = ...

	parser.parserCreatePrintMessage = parserCreatePrintMessage;

	//////////////////////////////////// END: helper for debugging, error details etc. ////////////////////////

	/**
	 * Object containing the instance of the class ParserUtils
	 *
	 * @type ParserUtils
	 * @private
	 *
	 * @memberOf mmir.parser.ParserUtils#
	 */
	var instance = null;

	/**
	 * @private
	 * @memberOf mmir.parser.ParserUtils#
	 */
	var isDebug = true;//TODO read/set from configuration

	MmirTemplateLexer.prototype.emitErrorMessage = function(msg) {
		parser.parserPrintError('[ERROR] TemplateLexer: ', msg, this);
	};
//		MmirTemplateParser.prototype.emitErrorMessage = function(msg) {
//			parser.parserPrintError('[ERROR] TemplateParser: ',msg);
//		};

	ES3Lexer.prototype.emitErrorMessage = function(msg) {
		parser.parserPrintError('[ERROR] JavaScriptLexer_ES3: ', msg, this);
	};
	ES3Parser.prototype.emitErrorMessage = function(msg) {
		parser.parserPrintError('[ERROR] JavaScriptParser_ES3: ', msg, this.getTokenStream().getTokenSource());
	};

	MmirScriptLexer.prototype.emitErrorMessage = function(msg) {
		var mode = this.isStatementMode()? 'Statement' : 'Block';
		parser.parserPrintError('[ERROR] Script'+mode+'Lexer: ',msg, this);
	};
	MmirScriptParser.prototype.emitErrorMessage = function(msg) {
		parser.parserPrintError('[ERROR] ScriptParser: ',msg, this.getTokenStream().getTokenSource());
	};

	MmirScriptContentLexer.prototype.emitErrorMessage = function(msg) {
		parser.parserPrintError('[ERROR] ContentLexer: ',msg, this);
	};
	MmirScriptContentParser.prototype.emitErrorMessage = function(msg) {
		parser.parserPrintError('[ERROR] ContentParser: ',msg, this.getTokenStream().getTokenSource());
	};

	/**
	 * @private
	 * @memberOf mmir.parser.ParserUtils#
	 */
	function internalParse(text) {

		var input = new org.antlr.runtime.ANTLRStringStream(text);//FIXME change, how dependency 'mmirf/antlr3' is exported?
		var lexer = new MmirTemplateLexer(input);

		lexer.isDebug = isDebug;

		var tokens = new org.antlr.runtime.CommonTokenStream(lexer);//FIXME change, how dependency 'mmirf/antlr3' is exported?

		var result 				= {};
		result.rawTemplateText 	= tokens.toString();
		result.scripts 			= lexer.includeScripts;
		result.styles 			= lexer.includeStyles;
		result.localizations 	= lexer.locales;
		result.ifs	 			= lexer.ifs;
		result.fors 			= lexer.fors;
		result.yields 			= lexer.yields;
		result.contentFors 		= lexer.yieldContents;
		result.helpers	 		= lexer.helpers;
		result.partials 		= lexer.renderPartials;
		result.escapes	 		= lexer.escape;
		result.scriptStatements	= lexer.scriptStatements;
		result.scriptBlocks		= lexer.scriptBlocks;
		result.vars				= lexer.vars;
		result.comments			= lexer.comments;
		//end: parsing results


		lexer = null;

		return result;
	}

	/**
	 * @private
	 * @memberOf mmir.parser.ParserUtils#
	 */
	function internalParseJS(text, entryRuleName, offset) {

		var input = new org.antlr.runtime.ANTLRStringStream(text);
		var lexer = new ES3Lexer(input);
		lexer.isDebug = isDebug;
		lexer.offset = offset;

		var tokens = new org.antlr.runtime.CommonTokenStream(lexer);
		var parser = new ES3Parser(tokens);
		parser.offset = offset;

		if(!entryRuleName){
//			var parseResult =
			parser.program();//<- parse with main rule 'program' in ES3Parser
		}
		else {
//				var parseResult =
				parser[entryRuleName]();//<- parse with main rule 'program' in ES3Parser
		}
		var result 				= new Object();
		result.rawTemplateText 	= tokens.toString();

		var varRefs = parser.getVarReferences();
		if(varRefs){
			result.varReferences = varRefs;
		} else {
			result.varReferences = [];
		}

		//TODO handle potentially global var-declaration (i.e. assignments without preceding var, where the variable is undefined yet)

		//end: parsing results

		lexer = null;
		parser = null;

		return result;
	}

//		var getVarReferences = function(parser){
//
//			var size = parser.ampersatIdentifiers.length;
//
//			if(size === 0){
//				return null;
//			}
//
//			var varRefs = new Array(size);
//			for(var i=0; i < size; ++i){
//				var ref = parser.ampersatIdentifiers[i];
//
//				var refObj = new mmir.parser.ParsingResult(ref);
////				refObj.start = ref.start;
//
//				//correct end-position (token's stop-index is exactly the last char-index, whereas ParsingResult's end-position is token.stopIndex + 1)
//				refObj.end = refObj.getEnd() + 1;
//
//				refObj.type = parser.element.VAR_REFERENCE;
//
//				varRefs[i] = refObj;
//			}
//			return varRefs;
//		};

		/**
		 * Constructor-Method of Singleton mmir.parser.ParserUtils
		 *
		 * @constructs ParserUtils
		 * @memberOf mmir.parser.ParserUtils.prototype
		 * @private
		 * @ignore
		 *
		 */
		function constructor(){
			//private members (currently none)

			/** @lends mmir.parser.ParserUtils.prototype */
			return {
				//public members:

				/**
				 * Parse a text as view template (e.g. *.ehtml files).
				 *
				 * @param {String} rawTemplateString the text that should be parsed
				 * @param {Object} [view] (optional) the view to which the <tt>rawTemplateString</tt> belongs (only used for error messages)
				 * @returns {mmir.parser.ParsingResult} the parsing result
				 *
				 * @public
				 * @memberOf mmir.parser.ParserUtils.prototype
				 */
				parse: function(rawTemplateString, view){

					if(view){
						_currentParsedView = view;
					}
					else {
						_currentParsedView = null;
					}

					return internalParse(rawTemplateString);
				},

				/**
				 * Parse a text as JavaScript.
				 *
				 * @param {String} rawTemplateString the text that should be parsed
				 * @param {String} [parseEntryRuleName] (optional) specifies the JavaScript element that should be parsed for
				 * @param {Object} [view] (optional) the view to which the <tt>rawTemplateString</tt> belongs (only used for error messages)
				 * @returns {mmir.parser.ParsingResult} the parsing result
				 *
				 * @public
				 * @memberOf mmir.parser.ParserUtils.prototype
				 */
				parseJS: function(rawTemplateString, parseEntryRuleName, view, inViewOffset){

					//in case only 2 or 3 arguments are present: is 2nd the View object?
					if(!inViewOffset && typeof parseEntryRuleName !== 'string' && parseEntryRuleName !== null && typeof parseEntryRuleName === 'object'){

						if(typeof view === 'number'){
							inViewOffset = view;
						}

						view = parseEntryRuleName;
						parseEntryRuleName = null;


					}

					if(view){
						_currentParsedView = view;
					}
					else {
						_currentParsedView = null;
					}

					return internalParseJS(rawTemplateString, parseEntryRuleName, inViewOffset);
				}
			};//END: return{}

		}//END: constructor()

		instance = new constructor();

		//FIXME should the renderer be exported to parser.ParserUtils here?
		parser.ParserUtils = instance;

		return instance;

	});//END define(..., function(){
