import { GElement, GRuleMultiline, GImport } from './../parser/grammar/GRule';
import GPrecedenceTokens from "../parser/grammar/GPrecedenceTokens";

import GRule from "../parser/grammar/GRule";
import GTypeDescriptor from '../parser/grammar/GTypeDescriptor';
import SeepGrammar from '../parser/SeepGrammar';
import GRuleToken, { GNodeToken } from '../parser/grammar/GRuleToken';
import SeepParser from '../parser/SeepParser';
import IncrementalParseHelper from '../parser/temp/IncrementalParseHelper';
import STest from '../../../../../testdata/TestHelpers';
import G from '@cafetextual/util/dist/src/type/G';
import SimpleTypeManifest from '@cafetextual/util/dist/src/manifest/SimpleTypeManifest';
import PRuleTokenFilter from '../parser/grammar/PRuleTokenFilter';

require('source-map-support').install();





		
 var stripPs =  ( o1:any, ignore:{[name:string]:any} = null) =>   {
                
        ignore = ignore || {"__uid":true};

        if (G.isStr(o1)) {
            // no action
        } else if (G.isBool(o1)) {
            // no action
        } else if (G.isNum(o1)) {

        } else if (G.isArr(o1)) {
            var arr1:Array<any> = o1 as Array<any>
            for (var i:number = 0; i < arr1.length; i++) {
                var v1:any = o1[i];
                stripPs( v1, ignore); 
            }
        } else if (G.isObj(o1)) {
            var key:string
            for (key in o1) {
                if (key in ignore) {
                    delete o1[key];
                } else  {
                    var v2:any = o1[key]
                    stripPs(v2, ignore);
                }
            }
            
            
        }
        
        
    }	



describe("grammar deserializer" ,  () => {
    //from metagrammar_low
    // 		[GRule, GElement, GRuleMultiline, GRuleToken, GPrecedenceTokens, GNodeToken, GTypeDescriptor, GSwitchItem, GSwitchRule] 
    //[ TypeDef, PropertyDef, SimpleTypeManifest ]  + styles 
    //[GImport, SeepGrammar]
    
    
    it("deserializes all grammar", () => {
	
		var manifest = new SimpleTypeManifest({
            GRuleToken:GRuleToken,
            PRuleTokenFilter:PRuleTokenFilter,
            GRule:GRule,
            GElement:GElement,
            GRuleMultiline:GRuleMultiline,
            GPrecedenceTokens:GPrecedenceTokens,
            GNodeToken:GNodeToken,
            GTypeDescriptor:GTypeDescriptor,
            GImport:GImport, 
            SeepGrammar:SeepGrammar
            //,
            //GSwitchItem:GSwitchItem,
            //GSwitchRule:GSwitchRule,
 
        })
    

/*
        var tests:GrammarTestManager = GrammarTestManager.getInstance()


		var deserializer = new ArchiveDeserializer(manifest)

        var it:IIterator<grammarTestSuite> = tests.it();
        
        while (it.hasNext()) {
            var ts:grammarTestSuite = it.next()
            var grammarSrc:string = ts.grammarSrc;
            var gid:string = ts.grammarID
            var inIt:IIterator<parseTest> = tests.srcIt(ts)

            testGrammar(ts)
        }

       // var test = ALL_TESTS.tests[0];
        //var serializedGrammar = test.grammarAST.data
        //var serializedTokens = serializedGrammar.tokens
        
		//var serializedRules = serializedGrammar.rules


        function testGrammar(ts:grammarTestSuite) {
            console.log("-- deserializing grammar " + ts.grammarID)
            console.log(ts.grammarSrc )

            var grammarAST:any = ts.grammarAST.data
		    var grammar:SeepGrammar = deserializer.deserialize(grammarAST);
            grammar.parentManifest = manifest;
            grammar.init()  
            
            if (!grammar.isValid()) {
                console.log(" failed to parse deserialize  ")

                console.log(grammar.toErrorString())

            }
            expect(grammar.isValid()).toBe(true)

            var ptest:parseTest

            for (ptest of ts.inputSources) {
                testParse(ptest, grammar)
            
            }


        }
        
        function testParse(ptest:parseTest, grammar:SeepGrammar):void {
            var srcID:string = ptest.srcID;
            var inputSrc:string = ptest.inputSrc;
            var ruleName:string = ptest.rule;
            console.log('===== parsing /w rule .' + ruleName)
            console.log(inputSrc)
            console.log('====')
            
            var r:GRule = grammar.getRule(ruleName)

            expect(r.isValid()).toBe(true);
            if (true) {
                var result:parseTestResult = IncrementalParseHelper.parseContentNonIncremental(r, new SimpleTextContent(inputSrc))
            }
            //var result:parseTestResult = IncrementalParseHelper.parseContent(r, new SimpleTextContent(inputSrc))
            


            if (!result.ok) {
                console.log("====*** failed")
                console.log(result.errMessage)
                if (result.errLocation) {
                    console.log(result.errLocation.show()) 
                    // TODO - show source ... 
                }
            }
            expect(result.ok).toBe(true)

            var data:any = result.data
            data["__cls"] = "Object"  
            stripPs(data)
            var ast:any = result.ast

            var expectedData =ptest.parseResult.data;
            stripPs(expectedData);
            // may need to string some __uid  etc
            var expectedAst = ptest.parseResult.ast
            
            STest.assertObject(" CP ", expectedData, data);
            STest.assertObject(" CP ", expectedAst, ast)
            //expect(expectedData).toEqual(data);
            //expect(expectedAst).toEqual(ast)


        }
         
        




            
        
    
    


*/
    } )
    
    



})