import GrammarTest from "../../src/org/subalternproductions/seepResource/dsl/testsuite/GrammarTest";
import GrammarTestSrc from "../../src/org/subalternproductions/seepResource/dsl/testsuite/GrammarTestSrc";
import ParseResult from "../../src/org/subalternproductions/seepResource/dsl/testsuite/ParseResult";
import GRule from "../../src/org/subalternproductions/seepResource/dsl/parser/grammar/GRule";
import IncrementalParseHelper from "../../src/org/subalternproductions/seepResource/dsl/parser/temp/IncrementalParseHelper";
import STest, { CompareResult } from "../../src/testdata/TestHelpers";
import { IIterator, ArrayIterator, SimpleTextContent } from "@cafetextual/util";
import Assert from "@cafetextual/util/dist/src/assert/Assert";
import GTestContext from "../../src/org/subalternproductions/seepResource/dsl/testrunner/GTestContext";
import GSuiteContext from "../../src/org/subalternproductions/seepResource/dsl/testrunner/GSuiteContext";
import SeepGrammar from "../../src/org/subalternproductions/seepResource/dsl/parser/SeepGrammar";

export default class GrammarTestsuiteRunner
{
    
    
    /**
     * Iterates over testsuites, grammar, tests performing the parsings
     * 
     * 
     * @param asReference - when true, doesn't perform assertions, but treats the parsing as a gold standard for future unit tests 
     * 
     */
    static runAllTestSuites(suiteContext:GSuiteContext, asReference:boolean):void {
        var it:IIterator<GTestContext> = suiteContext.it();
        
        while (it.hasNext()) {
            var testContext:GTestContext = it.next();
            var suiteIt:IIterator<GrammarTest> = testContext.it();
            while (suiteIt.hasNext()) {
                
                var gtest:GrammarTest = suiteIt.next();
                if (gtest.grammarParseResult.ok) { 
                    var g:SeepGrammar = testContext.grammarByTest(gtest);
                    var srcIt:IIterator<GrammarTestSrc> = new ArrayIterator<GrammarTestSrc>(gtest.inputSources);
                    
                    while (srcIt.hasNext()) {
                        var src:GrammarTestSrc = srcIt.next();
                        var result:ParseResult  = this.runTest(src, g, testContext);  // <-- performs the parsing, not assertions
                        if (asReference) {
                            
                            src.parseResult = result;         // <--- and here's the point: add the parsed results to the origional data stucture 
                            
                            var matchesExpected:Boolean = this.assertParse(gtest, src, testContext);
                            
                        } else {
                            if (result.ok) {
                                var foundData:any = result.data;
                                var foundAST:any = result.ast;
                                var expectedData:any = src.parseResult.data;
                                var expectedAST:any = src.parseResult.ast;
                                STest.stripPs(foundData);
                                STest.stripPs(foundAST);
                                var result1:CompareResult = STest.compareObjects(foundData, expectedData);
                                console.log(result1.show());

                                var result2:CompareResult = STest.compareObjects(foundAST, expectedAST)
                                console.log(result2.show());
                                
                                
                            }

                        }
                        
                        
                        
                    } // itteration over input souces
                    
                }
                        
            } // iteration over test of grammar tests 
            
        
            
        } // iteration over testsuites
        
                        
            
        
        
    }
    
    
    
    
    
    
    public static runTest(testSrc:GrammarTestSrc, grammar:SeepGrammar, ctx:GTestContext):ParseResult {
        
        Assert.assert(grammar != null  && grammar.isValid())  // TODO - register as an error annotation 
        
        var tid:string = testSrc.inputID;
        var src:string = testSrc.inputText.join("\n");
        ctx.logStart(testSrc); 
        
        var content:SimpleTextContent = new SimpleTextContent(src);
        
        var ruleName:string =  testSrc.ruleName
        if (ruleName) {
            var rule:GRule = grammar.getRule(ruleName)
        
            if (!rule) {
                ctx.log(" cannot find rule  :" +  ruleName)
            }
        } else {
            rule = grammar.getDefaultRule();

        }
        Assert.assert(rule != null);			
        var result:ParseResult = IncrementalParseHelper.parseContent(rule, content, ctx);
        
        ctx.logResult(result)
        
        return result
            
        
        //assertParseResult(result, testSrc)
        
        
    }
    

    static  assertParseResult(result:ParseResult, test:GrammarTestSrc):void {
        
        if (!result.ok) {
            console.log("====*** failed")
            console.log(result.errMessage)
            if (result.errLocation) {
                console.log(result.errLocation.show()) 
                // TODO - show source ... 
            }
        }
        
        var data:any = result.data
        data["__cls"] = "Object"  
        STest.stripPs(data)
        var ast:Object = result.ast
        
        // may need to string some __uid  etc
        
        if (test.parseResult) {
            var expectedData:Object = test.parseResult.data;  //  <--- TODO - add serialization 
            STest.stripPs(expectedData);
            
            var expectedAst:Object = test.parseResult.ast

            var dataCmp:CompareResult = STest.compareObjects(expectedData, data);
            var dataCmp:CompareResult = STest.compareObjects(expectedAst, ast);
        }
        
    }
    
    
    
    static assertParse(gtest:GrammarTest, src:GrammarTestSrc, testContext:GTestContext):Boolean {
        if (src.outputText) {
            var jsonTxt:string = src.outputText.join("\n");
            try {
                // TO_CONSIDER - alternate formats, json is a pain 
                var expectedData:Object = JSON.parse(jsonTxt);
                
            } catch (e) {
                Assert.fail(" unable to parse json ---\n" + jsonTxt);
            }
            
            var data:any = src.parseResult.data;
            var ok:CompareResult = STest.compareObjects(" CP ", expectedData, data);
        
           // var ok:CompareResult = STest.compareObjects(" CP ", expectedAst, ast);

            testContext.logTestDataResult(gtest, src, true);
                            
        }
        
        return true;
        
        
    } // asserParsers
}