import { PElementResult, PRuleResult } from './../parser/PObjectMap';
import GErr from '../parser/GErr';
import { GElement } from '../parser/grammar/GRule';
import Assert from '@cafetextual/util/dist/src/assert/Assert';


export default  class ParserState
{
	
	
	
	rulePos0:number = -1;    // position when rule was started 

	line0:number = -1;
	pos0:number = -1 // lask valid position, including partial matches of elements

	
	p:any    //SeepParser;	    // uses resume, getPos extactabl to an interface but causes problem /w js port
	//breakpoint:number;		

	/**
	 * maintained by debugger only (not cloned) 
	 */
	breakpoint:number; 
	continueFn:Function;
	
	
	clear():void {
		this.p = null;
	}
	
	resume():void {
		this.p.resume(this);
	}



	parent():ParserState {
		return null// abstract
	}

	isElementState():boolean {
		Assert.fail('abstact')
		return false;
	}

	populateElement(e:PElementResult, errCode:number, state:ParserState, element:GElement, valid:boolean = true, err:string = null, childResult:PRuleResult = null):PElementResult {
		e.element = element;
		e.valid = valid;
		e.err = err;
		e.childResult = childResult; 

		e.errCode = errCode;
		Assert.assert(state == this);
		// the awkwardnewss here is that we don't create the element at the bedinning of the match, 
		if (state.isElementState()) {
			var estate:any  = state //ElementState = state as ElementState;                
			e.startIndex = estate.pos0;
			e.startLineIndex = this.p.getCurrentLineIndex();
		} else {
			Assert.assert(!state.isElementState()) // state is IRuleState);
			var rState:any = state // RuleState = state as RuleState;
			
			e.startIndex = rState.posX >= 0 ? rState.posX : rState.pos0;
			e.startLineIndex = this.p.getCurrentLineIndex();    
		}
		Assert.assert(errCode == GErr.NOT_AN_ERROR || !valid);
		return e;
		
	} // populateElement

	
	toTraceString():string {
		return null; // abstract	
	}
	
	clone(fromCurrentElementState:any /*ElementState*/ = null, fromChildRuleState:any/*RuleState*/ = null, fromParentRuleState:any/*RuleState*/ = null,fromParentElementState:any/*ElementState*/=null, stack:Array<ParserState> = null):ParserState {
		// abstract
		return null;
	}
	
	release():void {
		// not yet implemented	
	}
	
	
	
	showItem():string {
		// abstract
		return null
	}

	protected getStack(out:Array<ParserState> = null):Array<ParserState> {
		if (out == null) {
			out = [this];
		}
		var parentState:ParserState = this.parent();
		while (parentState) {
			out.push(parentState);
			parentState = parentState.parent();
		}
		return out.reverse();
		
	}
	
	show():string {
		var stack:Array<ParserState> = this.getStack();
		if (this.isElementState()) {
//				var valid:boolean =  (this as ElementState).elementResult && (this as ElementState).elementResult.isValid();
			var valid:boolean =  (this as any).elementResult && (this as any).elementResult.isValid();
		} else {
			//valid = (this as RuleState).ruleResult && (this as RuleState).ruleResult.isValid();
			valid = (this as any).ruleResult && (this as any).ruleResult.isValid();
		
		}
			
	var out:string = "---- parser state stack  ----  "+  (this.isElementState() /*this is IElementState*/  && !valid ? "": "NOT VALID") + "\n"
		out += "parsed until: \"" + this.p.remainder + "\"\n"; 
		for (var i:number = 0; i < stack.length; i++) {
			out += " " + i.toString() + ". " + (stack[i] as ParserState).showItem() + "\n";
		}
		out += "----------------------------------"
		
		return out;
	}
	
	
	
	
	
} // class