execution.eol

import "logging.eol";
import "common.eol";
import "helper.eol";
import "debug.eol";
import "reusable.eol";

operation TDL!Interaction executeSource() : TTCN!FunctionStatementList {
    var ssl = new TTCN!FunctionStatementList();
    
    var sfs = new TTCN!FunctionStatement();
    sfs.communication = new TTCN!CommunicationStatements();
    sfs.communication.send = new TTCN!SendStatement();
    //sfs.communication.send.port = self.sourceGate.gate.equivalent();
    sfs.communication.send.port = self.sourceGate.equivalent().port;
    sfs.communication.send.send = new TTCN!PortSendOp();
    sfs.communication.send.send.template = new TTCN!InLineTemplate();
    sfs.communication.send.send.template.template = self.argument.getTemplateBody();
    
    ssl.statements.add(sfs);
    ssl.sc.add(";");
    return ssl;
}

operation TDL!Interaction executeTarget(t : TDL!Target) : TTCN!FunctionStatementList {
    var tsl = new TTCN!FunctionStatementList();
    
    var tfs = new TTCN!FunctionStatement();
    tfs.communication = new TTCN!CommunicationStatements();
    tfs.communication.receive = new TTCN!ReceiveStatement();
    tfs.communication.receive.any = new TTCN!PortOrAny();
    //tfs.communication.receive.any.ref = t.targetGate.gate.equivalent();
    tfs.communication.receive.any.ref = t.targetGate.equivalent().port;
    tfs.communication.receive.receive = new TTCN!PortReceiveOp();
    tfs.communication.receive.receive.template = new TTCN!InLineTemplate();
    tfs.communication.receive.receive.template.template = self.argument.getTemplateBody();
    
    if (not t.valueAssignment.isEmpty()) {
        var pr = new TTCN!PortRedirect();
        tfs.communication.receive.receive.redirect = pr;
        pr.value = new TTCN!ValueSpec();
        pr.value.variable = new TTCN!VariableRef();
        pr.value.variable.ref = new TTCN!ReferencedValue();
        pr.value.variable.ref.head = new TTCN!Head();
        pr.value.variable.ref.head.target = t.valueAssignment.get(0).variable.equivalent();
    }
    
    tsl.statements.add(tfs);
    tsl.sc.add(";");
    return tsl;
}

operation TDL!Interaction execute() {
    //TODO: needs adapting to context
    //      add a statement block stack for each component during transformation?

    //TODO: simplify
    
    //source behaviour
    if ((simulateSUT or self.sourceGate.component.role = TDL!ComponentInstanceRole#Tester)
        and (currentScope.isUndefined() or currentScope = self.sourceGate.component)
    ) {
        var sc = self.getMainContext(self.sourceGate.component);
        var sb = stack.get(sc).last();
        var ssl = self.executeSource();
        sb.stat.add(ssl);
    }

    //TODO: handle multicast?
    //target behaviour
    if ((simulateSUT or self.target.first().targetGate.component.role = TDL!ComponentInstanceRole#Tester)
        and (currentScope.isUndefined() or currentScope = self.target.first().targetGate.component)
    ) {
        var tc = self.getMainContext(self.target.first().targetGate.component);
        var tb = stack.get(tc).last();
        var t = self.target.first();
        var tsl = self.executeTarget(t);
        tb.stat.add(tsl);
    }
    //inlined above
    //self.execute(sb, tb);
}

//TODO: remove? (inlined above)
operation TDL!Interaction execute(sourceContext : TTCN!StatementBlock, targetContext : TTCN!StatementBlock) {
    //source behaviour
    var ssl = self.executeSource();
    sourceContext.stat.add(ssl);
    //TODO: handle multicast?
    //target behaviour
    var t = self.target.first();
    var tsl = self.executeTarget(t);
    targetContext.stat.add(tsl);
}

operation TDL!AlternativeBehaviour execute() {
    if (not transformAlt) return;
    var td = self.getTestDescription();
    //TODO: naive simplified assumption
    var fb = self.block.first().behaviour.first();
    if (fb.isKindOf(TDL!Interaction)) {
        if (simulateSUT or fb.sourceGate.component.role = TDL!ComponentInstanceRole#Tester) {
            var sc = self.getMainContext(fb.sourceGate.component);
            var sb = stack.get(sc).last();
            self.executeSource(sb);
        }

        if (simulateSUT or fb.target.first().targetGate.component.role = TDL!ComponentInstanceRole#Tester) {
            var tc = self.getMainContext(fb.target.first().targetGate.component);
            var tb = stack.get(tc).last();
            self.executeTarget(tb);
        }
    }
    
}

operation TDL!AlternativeBehaviour executeTarget(targetContext : TTCN!StatementBlock) {
    var tsl = self.executeTarget();
    targetContext.stat.add(tsl);
}

operation TDL!AlternativeBehaviour executeSource(sourceContext : TTCN!StatementBlock) {
    //TODO: simple assumption - trigger first
    //TODO: needs to follow path, right now triggers first interactions in other branches as well
    var fb = self.block.first().behaviour.first();
    if (fb.isKindOf(TDL!Interaction)) {
        var ssl = fb.executeSource();
        sourceContext.stat.add(ssl);
    }
}

operation TDL!AlternativeBehaviour checkPath() : Boolean {
    var first = true;
    if (self.eContainer.isDefined()) {
        if (self.eContainer.isKindOf(TDL!Block)) {
            if (self.eContainer.eContainer.isKindOf(TDL!AlternativeBehaviour)) {
                if (self.eContainer.eContainer.block.indexOf(self.eContainer) <> 0) {
                    first = false;
                } else {
                    first = self.eContainer.eContainer.checkPath();
                }
            }
        }
    } 
    
    return first;
}


operation TDL!AlternativeBehaviour executeTarget() : TTCN!FunctionStatementList {
    if (not transformAlt) return;
    //TODO
    
    //target only so far..
    //where should this be placed? in the receiving side?
    //how about source
    //TODO: add explicit scoping
    
    var tsl = new TTCN!FunctionStatementList();
    
    var fs = new TTCN!FunctionStatement();
    fs.behavior = new TTCN!BehaviourStatements();
    fs.behavior.alt = new TTCN!AltConstruct();
    fs.behavior.alt.agList = new TTCN!AltGuardList();
    
    for (block in self.block) {
        var gs = block.executeAltBlock();
        fs.behavior.alt.agList.guardList.add(gs);
    }
    
    tsl.statements.add(fs);
    //tsl.sc.add(";");
    return tsl;
}


operation TDL!Block executeAltBlock() : TTCN!GuardStatement {
    var gs = new TTCN!GuardStatement();
    gs.`guard` = new TTCN!AltGuardChar();
    //TODO: expression

    gs.block = new TTCN!StatementBlock();
    
    //naive assumption
    if (self.behaviour.first().isKindOf(TDL!Interaction)) {
	    var cf = self.behaviour.first().getMainContext(self.behaviour.first().target.first().targetGate.component);
	    stack.get(cf).add(gs.block);
	    
	    var i = 0;
	    for (b in self.behaviour) {
	        if (i==0) {
	            //this should be redundant now
	            if (b.isKindOf(TDL!Interaction)) {
	                gs.op = b.getGuardOp();
	            } else {
	                //TODO: handle other behaviours?    
	            }
	        } else {
	            b.execute();
	        }
	        i = i+1;
	    }
	
	    stack.get(cf).remove(gs.block);
    } else if (self.behaviour.first().isKindOf(TDL!TimeOut)) {
        var cf = self.behaviour.first().getMainContext(self.behaviour.first().componentInstance);
        stack.get(cf).add(gs.block);
        
        var i = 0;
        for (b in self.behaviour) {
            if (i==0) {
                //this should be redundant now
                if (b.isKindOf(TDL!TimeOut)) {
                    gs.op = b.getGuardOp();
                } else {
                    //TODO: handle other behaviours?    
                }
            } else {
                b.execute();
            }
            i = i+1;
        }
    
        stack.get(cf).remove(gs.block);
    
    } else {
        //TODO
    }
    
    //TODO: statement block
    return gs;
}


operation TDL!BoundedLoopBehaviour execute() {
    //TODO: no component?
    for (le in self.numIteration) {
        currentScope = le.scope;
        var sc = self.getMainContext(le.scope);
        var sb = stack.get(sc).last();
    
	    var tsl = new TTCN!FunctionStatementList();
	    sb.stat.add(tsl);
	    
	    var fs = new TTCN!FunctionStatement();
	    fs.basic = new TTCN!BasicStatements();
	    fs.basic.loop = new TTCN!LoopConstruct();
	    fs.basic.loop.forStm = new TTCN!ForStatement();
	
	    tsl.statements.add(fs);
	
	    var init = new TTCN!Initial();
	    fs.basic.loop.forStm.init = init;
	
	    var cv = new TTCN!SingleVarInstance();
	
	    var exp = new TTCN!RelExpression();
	    fs.basic.loop.forStm.expression = exp;
	    
	    //init
	    if (le.expression.isKindOf(TDL!DataInstanceUse)) {
	    
	        cv.name = "cv";
	        cv.ac = ":=";
	        cv.expr = new TTCN!Value();
	        cv.expr.predef = new TTCN!PredefinedValue();
	        cv.expr.predef.integer = "0";
	        
		    init.variable = new TTCN!VarInstance();
	        //TODO: add more comprehensive resolution
		    init.variable.listType = le.expression.dataInstance.dataType.getTTCNType();
		    init.variable.list = new TTCN!VarList();
		    init.variable.list.variables.add(cv);
	    
	        //TODO: the TTCN3 grammar needs to save the operators 
	    
	        //control
	        exp.left = new TTCN!Value();
	        exp.left.ref = new TTCN!ReferencedValue();
	        exp.left.ref.head = new TTCN!Head();
	        exp.left.ref.head.target = cv;
	        
	        exp.right = new TTCN!Value();
	        exp.right.ref = new TTCN!ReferencedValue();
	        exp.right.ref.head = new TTCN!Head();
	        if (le.expression.dataInstance.isValue()) {
	            exp.right.ref.head.target = le.expression.dataInstance.equivalent().defs.list.first();
	        } else {
	            //can it even be template?
		        exp.right.ref.head.target = le.expression.dataInstance.equivalent().base;
	        }
	
	    } else {
	        //TODO:
	    }
	
	    //increment    
	    var assign = new TTCN!Assignment();
	    assign.ref = new TTCN!VariableRef();
	    assign.ref.ref = new TTCN!ReferencedValue();
	    assign.ref.ref.head = new TTCN!Head();
	    assign.ref.ref.head.target = cv;
	    
	    assign.expression = new TTCN!AddExpression();
	    assign.expression.left = new TTCN!Value();
	    assign.expression.left.ref = new TTCN!ReferencedValue();
	    assign.expression.left.ref.head = new TTCN!Head();
	    assign.expression.left.ref.head.target = cv;
	
	    assign.expression.right = new TTCN!Value();
	    assign.expression.right.predef = new TTCN!PredefinedValue();
	    assign.expression.right.predef.integer = "1";
	    
	    fs.basic.loop.forStm.assign = assign;
	    
	    var block = new TTCN!StatementBlock();
	        
	    fs.basic.loop.forStm.statement = block;
	        
	    var cf = self.getMainContext(le.scope);
	    stack.get(cf).add(block);
	    
	    for (b in self.block.behaviour) {
	        b.execute();
	    }
	    
	    stack.get(cf).remove(block);
	    currentScope = null;
    }
    
}

operation TDL!UnboundedLoopBehaviour execute() {
    //TODO
    for (b in self.block.behaviour) {
        b.execute();
    }
}


operation TDL!ConditionalBehaviour execute() {
    var guards = self.block.get(0).`guard`;

    for (le in guards) {
        currentScope = le.scope;
        var sc = self.getMainContext(le.scope);
        var sb = stack.get(sc).last();
    
        var tsl = new TTCN!FunctionStatementList();
        sb.stat.add(tsl);
        
        var sfs = new TTCN!FunctionStatement();
        sfs.basic = new TTCN!BasicStatements();
        sfs.basic.conditional = new TTCN!ConditionalConstruct();
        
        //condition
        sfs.basic.conditional.expression = le.expression.getDataUseValue();
    
        tsl.statements.add(sfs);
    
        //main block    
        var block = new TTCN!StatementBlock();
        sfs.basic.conditional.statement = block;
            
        var cf = self.getMainContext(le.scope);
        stack.get(cf).add(block);
        
        for (b in self.block.get(0).behaviour) {
            b.execute();
        }
        
        stack.get(cf).remove(block);

        //TODO: else ifs
        //else block
        if (self.block.size() > 1) {
	        sfs.basic.conditional.`else` = new TTCN!ElseClause();
	        
	        var eBlock = new TTCN!StatementBlock();
	        sfs.basic.conditional.`else`.statement = eBlock;
	            
	        stack.get(cf).add(eBlock);
            for (b in self.block.last().behaviour) {
                b.execute();
            }
            stack.get(cf).remove(eBlock);
        }

        currentScope = null;
    }
}


operation TDL!tdl::Assignment execute() {
    var ci = self.variable.componentInstance;
    if (simulateSUT or ci.role = TDL!ComponentInstanceRole#Tester) {
        var sc = self.getMainContext(ci);
        var sb = stack.get(sc).last();

        var ssl = new TTCN!FunctionStatementList();
        
        var sfs = new TTCN!FunctionStatement();
        
        sfs.basic = new TTCN!BasicStatements();
        sfs.basic.assign = new TTCN!Assignment();
        sfs.basic.assign.ref = new TTCN!VariableRef();
        sfs.basic.assign.ref.ref = new TTCN!ReferencedValue();
        sfs.basic.assign.ref.ref.head = new TTCN!Head();
        sfs.basic.assign.ref.ref.head.target = self.variable.variable.equivalent();
        
        sfs.basic.assign.expression = self.expression.getDataUseValue();
        
        ssl.statements.add(sfs);
        ssl.sc.add(";");

        sb.stat.add(ssl);
    }
}

operation TDL!Assertion execute() {
    var ci = self.componentInstance;
    if (simulateSUT or ci.role = TDL!ComponentInstanceRole#Tester) {
        var sc = self.getMainContext(ci);
        var sb = stack.get(sc).last();
        var ssl = new TTCN!FunctionStatementList();
        
        var sfs = new TTCN!FunctionStatement();
        sfs.basic = new TTCN!BasicStatements();
        sfs.basic.conditional = new TTCN!ConditionalConstruct();
        
        //condition
        sfs.basic.conditional.expression = self.condition.getDataUseValue();

        //statements - pass
        sfs.basic.conditional.statement = new TTCN!StatementBlock();
        var psl = new TTCN!FunctionStatementList();
        psl.statements.add("pass".getVerdictStatement());
        sfs.basic.conditional.statement.stat.add(psl);
        
        //else - otherwise verdict
        sfs.basic.conditional.`else` = new TTCN!ElseClause();
        sfs.basic.conditional.`else`.statement = new TTCN!StatementBlock();
        var osl = new TTCN!FunctionStatementList();
        if (self.otherwise.isDefined()) {
	        osl.statements.add(self.otherwise.getVerdictStatement());
        } else {
            osl.statements.add("fail".getVerdictStatement());
        } 
        sfs.basic.conditional.`else`.statement.stat.add(osl); 
        
        ssl.statements.add(sfs);
        ssl.sc.add(";");

        sb.stat.add(ssl);
    }
}

operation TDL!ActionReference execute() {
    var ci = self.componentInstance;
    if (simulateSUT or ci.role = TDL!ComponentInstanceRole#Tester) {
        var sc = self.getMainContext(ci);
        var sb = stack.get(sc).last();
        var ssl = new TTCN!FunctionStatementList();
        
        var sfs = new TTCN!FunctionStatement();
        
        sfs.behavior = new TTCN!BehaviourStatements();
        sfs.behavior.`function` = new TTCN!FunctionInstance();
        sfs.behavior.`function`.ref = self.action.equivalent();

        if (not self.actualParameter.isEmpty()) {
            var pl = new TTCN!FunctionActualParList();
            sfs.behavior.`function`.params = pl;  
        
            for (ap in self.actualParameter) {
                var p = new TTCN!FunctionActualPar();
                p.template = new TTCN!InLineTemplate();
                p.template.template = new TTCN!TemplateBody();
                p.template.template.simple = new TTCN!SimpleSpec();
                p.template.template.simple.expr = ap.dataUse.getDataUseValue();
                pl.params.add(p); 
            }
        }        
        
        ssl.statements.add(sfs);
        ssl.sc.add(";");

        sb.stat.add(ssl);
    }
}

operation TDL!TestDescriptionReference execute() {
    //TODO: support parameters (also in initialisation in TD2FD)
    //TODO: support bindings
    for (ci in self.getTestDescription().testConfiguration.componentInstance.select(c|simulateSUT or c.role = TDL!ComponentInstanceRole#Tester)) {
        var sc = self.getMainContext(ci);
        var sb = stack.get(sc).last();

        var tc = self.testDescription.getMainContext(ci);
        var cf = TTCN!FunctionDef.all().select(f|f.name = tc).first();
        if (cf.isDefined()) {
	        var ssl = new TTCN!FunctionStatementList();
	        var s = new TTCN!FunctionStatement();
	        s.behavior = new TTCN!BehaviourStatements();
	        s.behavior.`function` = new TTCN!FunctionInstance();
	        s.behavior.`function`.ref = cf;
	        ssl.statements.add(s);
	        ssl.sc.add(";");
	        sb.stat.add(ssl);
        } else {
            ("  Could not resolve "+tc).log(1);
            //TODO
        }
    }    
}


operation TDL!VerdictAssignment execute() {
    for (ci in self.getTestDescription().testConfiguration.componentInstance.select(c|simulateSUT or c.role = TDL!ComponentInstanceRole#Tester)) {
        var sc = self.getMainContext(ci);
        var sb = stack.get(sc).last();

	    var ssl = new TTCN!FunctionStatementList();
	    
	    var sfs = self.verdict.getVerdictStatement();
        
        ssl.statements.add(sfs);
        ssl.sc.add(";");

        sb.stat.add(ssl);
    }    
}

operation TDL!CompoundBehaviour execute() {
    //TODO
    for (b in self.block.behaviour) {
        b.execute();
    }
}


operation TDL!TimerStart execute() {
    var ci = self.componentInstance;
    if (simulateSUT or ci.role = TDL!ComponentInstanceRole#Tester) {
        var sc = self.getMainContext(ci);
        var sb = stack.get(sc).last();
        var ssl = new TTCN!FunctionStatementList();
        
        var sfs = new TTCN!FunctionStatement();
        
        sfs.timer = new TTCN!TimerStatements();
        sfs.timer.start = new TTCN!StartTimerStatement();
        sfs.timer.start.ref = self.timer.equivalent();
        sfs.timer.start.expr = self.period.getDataUseValue();
        
        ssl.statements.add(sfs);
        ssl.sc.add(";");

        sb.stat.add(ssl);
    }
}

operation TDL!TimerStop execute() {
    var ci = self.componentInstance;
    if (simulateSUT or ci.role = TDL!ComponentInstanceRole#Tester) {
        var sc = self.getMainContext(ci);
        var sb = stack.get(sc).last();
        var ssl = new TTCN!FunctionStatementList();
        
        var sfs = new TTCN!FunctionStatement();
        
        sfs.timer = new TTCN!TimerStatements();
        sfs.timer.stop = new TTCN!StopTimerStatement();
        sfs.timer.stop.ref = new TTCN!TimerRefOrAll();
        sfs.timer.stop.ref.ref = self.timer.equivalent();
        
        ssl.statements.add(sfs);
        ssl.sc.add(";");

        sb.stat.add(ssl);
    }
}

operation TDL!TimeOut execute() {
    //TODO: handle in an alt statement?
    var ci = self.componentInstance;
    if (simulateSUT or ci.role = TDL!ComponentInstanceRole#Tester) {
        var sc = self.getMainContext(ci);
        var sb = stack.get(sc).last();
        var ssl = new TTCN!FunctionStatementList();
        
        var sfs = new TTCN!FunctionStatement();
        
        sfs.timer = new TTCN!TimerStatements();
        sfs.timer.timeout = new TTCN!TimeoutStatement();
        sfs.timer.timeout.ref = new TTCN!TimerRefOrAny();
        sfs.timer.timeout.ref.ref = self.timer.equivalent();
        
        ssl.statements.add(sfs);
        ssl.sc.add(";");

        sb.stat.add(ssl);
    }
}

operation TDL!Behaviour execute() {
    ("  Skipping " +self.type.name+" (not yet supported)").println();
    if (self.type.name = "ParallelBehaviour" and false) {
        (indent+"group Parallel").printlno();
        var i = 0;
        for (block in self.block) {
            for (b in block.behaviour) {
                b.execute(indent+"  ");
            }
            if (i <= block.size()) {
                (indent+"else").printlno();
            }
            i = i+1;
        }
        (indent+"end").printlno();
    }
}