import { IncrementalParseResult } from './../../src/org/subalternproductions/seepResource/dsl/service/ParseResponse';
import { TS_MANIFEST } from './../../src/org/subalternproductions/seepResource/dsl/serialize/MetaGrammarManifest';
import GrammarTestsuiteMgr, { ResourceData } from '../../src/org/subalternproductions/seepResource/dsl/testrunner/GrammarTestsuiteMgr';
import { ITypeManifest, Assert, SimpleTextContent } from '@cafetextual/util';
import ParseServer from '../ParseServer';
import { deserializeResources, splitSrcID } from './parse-service-util';
import GrammarTest from '../../src/org/subalternproductions/seepResource/dsl/testsuite/GrammarTest';
import GrammarTestSrc from '../../src/org/subalternproductions/seepResource/dsl/testsuite/GrammarTestSrc';
import GrammarTestSuite from '../../src/org/subalternproductions/seepResource/dsl/testsuite/GrammarTestSuite';
import GTestContext from '../../src/org/subalternproductions/seepResource/dsl/testrunner/GTestContext';
import { serveStatic } from 'serve-static';
import GSuiteContext from '../../src/org/subalternproductions/seepResource/dsl/testrunner/GSuiteContext';
import ParseResult from '../../src/org/subalternproductions/seepResource/dsl/testsuite/ParseResult';
import ParseResponse from '../../src/org/subalternproductions/seepResource/dsl/service/ParseResponse';
import ParseRequest from '../../src/org/subalternproductions/seepResource/dsl/service/ParseRequest';
import AnyonicIncrementalParser from '../../src/anyonic/AnyonicIncrementalParser';
import SeepGrammar from '../../src/org/subalternproductions/seepResource/dsl/parser/SeepGrammar';
import GRule from '../../src/org/subalternproductions/seepResource/dsl/parser/grammar/GRule';
import IncrementalParseHelper from '../../src/org/subalternproductions/seepResource/dsl/parser/temp/IncrementalParseHelper';


/** 
 *  Temporary, kind of hacked guid 
 * 
 *   https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript
 * 
 */
function uuidv4() {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
      var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
      return v.toString(16);
    });
  }


export function createFromJSON(data:any):ParserService { 
    var resources:Array<{rtype:string, data:any, suri:string}> = deserializeResources(data)

    return new ParserService(resources, data.resources)

} // crateFromJSON



/**
 * 
 * Manage resource structure and external api around a grammar test context
 * 
 * API see: ParseRequest   
 *     
 * 
 */


export default class ParserService {

    constructor(resources:Array<{rtype:string, data:any, suri:string}>,
         rawResources:Array<{rtype:string, data:any, suri:string}>) {

        var manifest:ITypeManifest = TS_MANIFEST
        var parseGrammarLocally:boolean = false  // <--- grammars are pre-parsed, just need to create them from the ast
        this._mgr = new GrammarTestsuiteMgr(resources, rawResources, manifest, parseGrammarLocally )
        
    
    }
    
    rawResourceByDocURI(docURI:string):any {
        return this._mgr.rawResourceByDocURI(docURI)
    }

    allRawTss():Array<ResourceData> {
        return this._mgr.getAllTestsuiteRawResoure()
    }

    private _mgr:GrammarTestsuiteMgr  

    // cache of parser by uri
    private _parsers:{[suri:string]:AnyonicIncrementalParser<string>} = {}


    doParse(req:ParseRequest):ParseResponse {

        //console.log(' parsing data ... ---\n' + req.src.join('\n'));
        


        // --- 1. resolve base document
        var docURI:string = req.docURI   // <--- TODO - handle this, currently we're just hardcoding it
        

        // --- 1. resolve the grammar in which to parse this test
        //        
        
        if (req.href) {

            var href = req.href
           
            if (href == '#') {
                var testParseResult:ParseResult = this.doParseTestcase( req.src )
                
                return ParseResponse.createFromParseResult(docURI, href,  initialVersion, testParseResult, false )

            }

            let {type, childId:grammarId} = splitSrcID(href)

            if (type == 'region-grammar') {
                // parse /w metagrammar
                let  {ok, ts, gctx, gtest} = this.resolveGrammarContext(docURI, href)  
                if (ok) {
                    // parser with metagrammar                   
                    
                    var grammarResult:ParseResult = this._mgr.updateGrammarSrc(ts, gctx, gtest, req.src )
                    //var grammarResult:ParseResult = this._mgr.parseGrammarToAst(gctx, req.src)
                  
                    var newVersion:string = uuidv4()  // <-- in the absence of an op, create a random version number
                    


                    return ParseResponse.createFromParseResult(docURI, href, newVersion, grammarResult, true)
                    
                }  




            } else {
            

                // href refers to a sub-document of the testcase 
                let {ok,  gctx, gtest, src} = this.resolveTestContext(docURI, href)
        

                if (ok) {
                    var result = this.doParse_low(gctx, gtest, src, req.src)
                    var initialVersion:string = uuidv4()
                    return ParseResponse.createFromParseResult(docURI, href,  initialVersion, result, true)

                } else {
                    Assert.fail(" TODO - handle error")
                }

            }
        } else if (req.grammarURI) {  
            console.log(' resolving grammar ' + req.grammarURI)
             var g:SeepGrammar  // = this._mgr.resolveGrammar()
        }

        var out:ParseResult = new ParseResult()
        return null
    }



    doParseTestcase(src:Array<string>):ParseResult {

       var g:SeepGrammar = this._mgr.context.getGrammar('grammars/metagrammar/metagrammar-testsuite.grammar' )
       var r:GRule = g.getRule('testsuite')
        Assert.assert(r.isValid())

       var result:ParseResult = IncrementalParseHelper.parseContent( r ,new SimpleTextContent(src.join('\n')) )


        return result
    }





    resolveTestSource(ts:GrammarTestSuite, grammarId:string, srcId:string): {ok:boolean, ts?:GrammarTestSuite, gtest?:GrammarTest, src?:GrammarTestSrc} {

        var suiteURI:string = ts.provUri
        
        var gtest:GrammarTest 
        for (gtest of ts.tests) { 
            var gid:string = gtest.uid.toString()
            if (grammarId == gtest.uid.toString()) { 
            
                if (srcId) {
                    var src:GrammarTestSrc
                    for (src of gtest.inputSources) {
                        var sid:string = src.uid.toString()
                        if (  grammarId == gid    && srcId == sid) {
                            return {ok:true, ts:ts, gtest:gtest, src:src}
                        }

                    }
                } else {
                    return {ok:true, ts:ts, gtest:gtest}
                }
            }
        
        }

        return {ok:false}



    }
    
    
    resolveGrammarContext(docURI:string, href:string):{ok:boolean, ts?:GrammarTestSuite, ctx?:GTestContext, gctx?:GTestContext, gtest?:GrammarTest,  } {
        var o = this.resolveTestContext_low(docURI, href,true);
        return o
    }

    resolveTestContext(docURI:string, href:string):{ok:boolean, ts?:GrammarTestSuite, ctx?:GTestContext, gctx?:GTestContext, gtest?:GrammarTest, src?:GrammarTestSrc} {
        var o = this.resolveTestContext_low(docURI, href, false);

        if (o.ok && o.src) {
            return o
        }
        
        return {ok:false}
    }


  

    resolveTestContext_low(docURI:string, href:string, retrieveGrammar:boolean):{ok:boolean,ts?:GrammarTestSuite, ctx?:GTestContext, gctx?:GTestContext, gtest?:GrammarTest, src?:GrammarTestSrc } {
        var {parentId, type, childId} = splitSrcID(href)


        

            var suiteContext:GSuiteContext = this._mgr.context; // <--- context of all testsuites
            var gctx:GTestContext                        // <-- context of given testsuite
            for (gctx of suiteContext.getTestcontexts()) {
                var ts:GrammarTestSuite = gctx.testSuite
                if (ts.provUri == docURI) {
                        if (retrieveGrammar) {
                            var { ok, gtest, src } = this.resolveTestSource(ts, childId, null)
                            if (ok) {
                                return {ok:true, ts, gctx, gtest}
                            }
                        } else {
                            var { ok, ts,  gtest, src } = this.resolveTestSource(ts, parentId, childId)
                            if (ok) {
                                return {ok:true, ts,gctx, gtest, src }
                            }
                    }
                }
            }


      

        return {ok:false}
    } // resolveTestContext 










    doParse_low(gctx:GTestContext, gtest:GrammarTest, gsrc:GrammarTestSrc, newSrc:Array<string>):ParseResult {

        // --- 1. set new text. No invalidation mechanims or incrmental support yet
        gctx.updateSource(gtest, gsrc, newSrc );

        // --- 2. reparse
        var out = this._mgr.runTest(gctx, gtest, gsrc)

        return out
    }



} // class