import SeepParser from "../SeepParser";
import GRule from "../grammar/GRule";
import BreakExpression from "../../parsertooling/breakpoint/BreakExpression";
import IncrementalParser from "../IncrementalParser";
import { PRuleResult } from "../PObjectMap";
import ObjectMapper from "../ObjectMapper";
import ParseResult from "../../testsuite/ParseResult";
import { IContentList } from "@cafetextual/util";
import SimpleTypeManifest from "@cafetextual/util/dist/src/manifest/SimpleTypeManifest";
import Assert from "@cafetextual/util/dist/src/assert/Assert";
import SourceLocation from "@cafetextual/util/dist/src/source/SourceLocation";
import GTestContext from "../../testrunner/GTestContext";



export default class IncrementalParseHelper
{
		

	static parseContentNonIncremental(r:GRule, content:IContentList<string>):ParseResult {
		var _p:SeepParser = new SeepParser
		
		_p.autoObjectMap = false;
		
		_p.init(content);
		var result:PRuleResult = _p.rule(r)
		
		if (!result.isValid()) {
			return  ParseResult.createErr(null, "no error message", "");
		}
		var om:ObjectMapper = new ObjectMapper
		om.mapValues(result, result.matchedRule, null, null, true /* isRoot */);

		var data:any = result.data;

		if (result.map.hasError())  {
			return  ParseResult.createErr(null, "TODO-erros in mapping", "");
		}
		
		var ast:any = result.map.toAST(data)

		
		
		
		return ParseResult.createSuccess(data, ast); 

	}

	/**
	 * Break expession here helpful to set breakpoint in parsing, but better /w proper tooling 
	 * 
	 */
	static parseContent(r:GRule, content:IContentList<string>, ctx:GTestContext = null, breakExp:BreakExpression = null):ParseResult {
		var out:ParseResult = IncrementalParseHelper.parseContent_low(r,content, ctx, breakExp) 
		if (ctx) {
			if (out.ok) {
				ctx.log("parse OK")
			} else {
				ctx.log(out.errMessage );
				ctx.log(out.verboseErr );
			}
		}

		return out;	
	}

	private static parseContent_low(r:GRule, content:IContentList<string>, ctx:GTestContext, breakExp:BreakExpression = null):ParseResult { 

	

		var _p:SeepParser = new SeepParser
		var _ip:IncrementalParser = new IncrementalParser;
		
		_p.autoObjectMap = false;
		
		_ip.init(_p, content, r, breakExp);
		var outOb:ParseResult
		while (!_ip.done) {
			if (ctx) {
				ctx.log("parsing: '" + _ip.curentLine() + "'");
			}
			_ip.parseLine();
			if ( _ip.hasErrored() ) {
				var lineNum:number = _ip.erroredAt();
				var errLocation:SourceLocation = _ip.errLocation()
				var msg:string = _ip.errorStr()

				outOb = ParseResult.createErr(errLocation, 
						 "parse error: " + msg,
							" --- failed to parse line: --- \n" + 
						  " line " + lineNum + ": \"" + content.indexToValue(_ip.erroredAt()) + "\"\n" +
						  "\" error message: \"" + _ip.errorStr() + "\"" 
				)
				
				return outOb;
				
			}
			
		}
		
		
		//Assert.assert(_ip.root.isValid());  // error should have been caught in above loop
		
		
		var {ok, data:out, err} = this.doMapping(_ip, true ,true)
		if (!ok) {
			var errMsg = err.toString() + '\n' + err.stack
			return ParseResult.err('map-err', [content.indexToValue(content.first() )], errMsg )
		}


		var ast:Object = _ip.root.map.toAST(out);
		
		if (!_ip.root.isValid() ) {
			var errStr:string = _ip.root.map.toErrString();

			outOb =  ParseResult.createErr(null, "object map error: " + errStr,

						 "failed to Parses " + errStr + "\n" +  
						 "   object mapping error: " +  _ip.root.map.toErrString()
				);
			return outOb
			
		}
		
		if (!out) {
			Assert.fail(" no object")
		}
		
		
		return ParseResult.createSuccess(out,ast);
		
		
	}
	
	
	static doMapping(ip:IncrementalParser, jsonTarget:boolean, addUIDs:boolean):{ok:boolean, data:any, err?:any}{
		try {

			
			if (jsonTarget) {
				SimpleTypeManifest.jsonTarget = jsonTarget;  // ---- mechanism to replace types /w easily json-serializable objects
				SimpleTypeManifest.addUID = addUIDs;
				var o:Object = ip.mapdata();
				
			} else {
				Assert.assert(SimpleTypeManifest.jsonTarget == false);
				o = ip.mapdata();
			}
		
		} catch (e) {
			SimpleTypeManifest.jsonTarget = false
			SimpleTypeManifest.addUID = false
			return {ok:false, data:{}, err:e}
		}

		SimpleTypeManifest.jsonTarget = false
		SimpleTypeManifest.addUID = false
		return { ok:true, data:o}
	}

}