import ParseStackItem from "../org/subalternproductions/seepResource/dsl/parsertooling/ParseStackItem";
import RuleState from "../org/subalternproductions/seepResource/dsl/parsertooling/RuleState";
import ElementState from "../org/subalternproductions/seepResource/dsl/parsertooling/ElementState";
import ParserState from "../org/subalternproductions/seepResource/dsl/parsertooling/ParserState";
import { int } from "@cafetextual/nlist/dist/src/ntree/types";
import Assert from "@cafetextual/util/dist/src/assert/Assert";
import ParserDebug from "../org/subalternproductions/seepResource/dsl/parsertooling/ParserDebug";
import { GElement } from "../org/subalternproductions/seepResource/dsl/parser/grammar/GRule";

export default class StackUtil
{
    
    
    static filter(stack:Array<ParseStackItem>, includeRules:boolean, includeElement:boolean, includeNamedRules:boolean = true):Array<ParseStackItem> {
        var out:Array<ParseStackItem> = []

        var state:ParseStackItem
        for (state of stack) {
            var rstate:RuleState = (state.state instanceof RuleState) ? state.state as RuleState : null
            var estate:ElementState = (state.state instanceof ElementState) ?  state.state as ElementState : null
            
            
            if (rstate) {
                state.label = rstate.rule.name ? rstate.rule.name : rstate.rule.tr();
            }
            if (estate) {
                state.label = estate.element.tr();
            }
            
            if ((rstate  && (includeRules  || rstate.rule.name && includeNamedRules   ))
                ||  (estate && includeElement) ) {
                out.push(state);
            }
        }
        return out;
    }
    
    static toDetailStr(state:ParserState, breakpoint:int = -1):string {
        var out:string = "";
        
        if (state instanceof RuleState) {
            var rstate:RuleState = state as RuleState;
            out = "rule:   " + (rstate.rule.name ? (rstate.rule.name + ": " ) : "" ) +  rstate.rule.tr();
            
        } else if (state instanceof ElementState) {
            
            
            
            var estate:ElementState = state as ElementState; 
            var parent:RuleState = estate.parentRuleState;
            Assert.assert(estate == parent.currentElementState);
            //out += "parent " + parent.rule.tr() + "\n"
            
            //out += labels[breakpoint]; "\n" 
            
            //out += "  " + elementToString(estate) + "\n\n"
            
            out += "element: " + estate.element.tr() + "\n\n"
            
            if (estate.element.prefixTokenValue) {
                if (breakpoint == -1) {
                    out += "  matched prefix " + estate.element.prefixTokenValue;
                } else if (breakpoint == ParserDebug.ELEMENT_FAIL) {
                    if (estate.elementResult.tokenPrefixIndex < 0) {
                        out += "  failed to match prefix \"" +  estate.element.prefixTokenValue + "\"\n"
                    }
                }
            } 
            
            
            // --- tokens
            var e:GElement = estate.element;
            out += "possibleNextTokens:"  

            if (e.possibleNextTokens) {
                out +=  "[ "
                var t:string
                for  (t of e.possibleNextTokens) {
                    out += "\"" + t + "\" , ";
                }
                out += "]";
            }
            out += "\n";
            out += "nextElementTokens: " 
            if (e.nextElementTokens) {
                out += " [ " 
                for (t of e.nextElementTokens) {
                    out += "\"" + t + "\" , ";
                }
                out += "]"
            }
            
            out += "\n" 

            
        
        }
        return out;
    }

}