module MainModule {
	import from TraceParserSystem all;

    function f_obuBehaviour() runs on ObuType {
        var address v_ts := 0;
        var integer v_startTS := 0;
        var template (present) LinkId v_linkId := ?;
        var boolean v_receivedLinkId := false;
        

        transactionOBUTimer.start;
        alt {
            [v_startTS==0] obuPort.receive(mw_obuBroadCastMsg) -> sender v_ts { 
                // when the first broadcast message is received then take it's time stamp
                transactionOBUTimer.stop;
                v_startTS := v_ts;
                transactionOBUTimer.start;
                repeat;
            }
            [] compPort.receive(v_linkId) -> value v_linkId{
                transactionOBUTimer.stop;
                v_receivedLinkId := true;
                transactionOBUTimer.start;
                repeat;
            }
            [v_startTS!=0 and v_receivedLinkId == true] obuPort.receive(mw_releaseMsg(v_linkId)) -> sender v_ts { 
                // when the release message was received take it's time stamp and calculate the transaction time
                // inform the rsu component 
                transactionOBUTimer.stop;
                compPort.send(m_stop);
                if (v_ts - v_startTS <= 100000) {
                    setverdict (pass, "Transaction finished in " & int2str(v_ts - v_startTS) & "µs");
                }
                else {
                    setverdict (fail, "Transaction finished in more than 100ms! (" & int2str(v_ts - v_startTS) & "µs)");
                }
                stop;
            }
            [v_startTS!=0 and v_receivedLinkId == true] obuPort.receive(mw_msg_withLinkId(v_linkId)){
                transactionOBUTimer.stop;
                transactionOBUTimer.start;
                repeat;
            }
            [v_startTS!=0 and v_receivedLinkId == true] obuPort.receive(mw_obuBroadCastMsg){ 
                //If another broadcast is received than ignore
                transactionOBUTimer.stop;
                transactionOBUTimer.start;
                repeat;
            }
            [v_startTS!=0 and v_receivedLinkId == true] obuPort.receive {
                transactionOBUTimer.stop;
                setverdict(fail, "Unexpected message received");
                compPort.send(m_stop);
				stop;                
            }
            [] transactionOBUTimer.timeout {
                setverdict (inconc, "No OBU message was received");
                compPort.send(m_stop);
                stop;
            }
        }
    }
    
    
    function f_rsuBehaviour() runs on RsuType {
        var boolean v_sentLinkId := false;
        var PayloadStructure v_msg;
        var integer v_cntEmpty := 0;
        var template (present) LinkId v_linkId := ?;
        timer t_rsuTimer := 5.0;
        
        t_rsuTimer.start;
        alt{
            []rsuPort.receive(mw_msg_withLinkId(v_linkId)) -> value v_msg{
                t_rsuTimer.stop;
                if (v_sentLinkId == false) {
                       v_linkId := valueof(v_msg.linkMsg.linkId);
                       compPort.send(valueof(v_linkId));
                }
                v_sentLinkId := true;
                t_rsuTimer.start;
                repeat;
            }
            []rsuPort.receive(mw_msg_empty){
                t_rsuTimer.stop;
                v_cntEmpty := v_cntEmpty +1;
                t_rsuTimer.start;
                repeat;
            }
            []rsuPort.receive{
                t_rsuTimer.stop;
                setverdict (fail, "Unexpected message received.");
                stop;
            }
            []compPort.receive(m_stop) {
                if (v_cntEmpty <= PX_MAX_NUM_EMPTY_UPLINK_FRAMES){
                	setverdict (pass, "Number of received empty frames : " & int2str(v_cntEmpty));
                }
                else {
                	setverdict (fail, "Maximum number of received empty frames exceeded! (" 
                					  & int2str(v_cntEmpty) & " > " & int2str(PX_MAX_NUM_EMPTY_UPLINK_FRAMES) & ")");
                }
            }
            []t_rsuTimer.timeout{
                setverdict(inconc, "No RSU messaged received");
                stop;
            }
        }
    }

    testcase TC_Initialization(inout integer p_nrOfTransactions) runs on MtcType system SystemType {
        
        map(mtc:controlPort, system:controlPort);
        
        controlPort.call(setTraceFile:{PX_TRACE_PATH}, 5.0) {
            [] controlPort.getreply(setTraceFile:{-} value true) {
                setverdict (pass);
            }
            [] controlPort.getreply {
                setverdict (fail, "Could not set trace file");
                stop;
            }
            [] controlPort.catch(timeout) {
                setverdict (fail, "Timeout while setting trace file");
                stop;
            }
        };

        controlPort.call(getTransactionCnt:{}, 5.0) {
            [] controlPort.getreply(getTransactionCnt:{} value ?) -> value p_nrOfTransactions {
                setverdict (pass, "Number of Transaction = " & int2str(p_nrOfTransactions));
            }
            [] controlPort.getreply {
                setverdict (fail, "Unexpected reply");
                stop;
            }
            [] controlPort.catch(timeout) {
                setverdict (fail, "Timeout while caling getTransacationCnt");
                stop;
            }
        };
        
    }

    testcase TC_AnalyzesTrace(inout integer p_traceIndex) runs on MtcType system SystemType {
        var ObuType obuComponent := ObuType.create("OBU"); //DL
        var RsuType rsuComponent := RsuType.create("RSU"); //UL
        
        map(mtc:controlPort, system:controlPort);
        map(obuComponent:obuPort, system:msgPort);
        map(rsuComponent:rsuPort, system:msgPort);
        connect(obuComponent:compPort, rsuComponent:compPort);
        
        obuComponent.start(f_obuBehaviour());
        rsuComponent.start(f_rsuBehaviour());
        
        log ("Starting analysis of trace: " & int2str(p_traceIndex));
        
        controlPort.call(startAnalyzeTrace:{p_traceIndex}, 5.0) {
            [] controlPort.getreply(startAnalyzeTrace:{-} value true) {
                setverdict (pass);
            }
            [] controlPort.getreply {
                setverdict (fail, "Could not start analyzing trace");
                stop;
            }
            [] controlPort.catch(timeout) {
                setverdict (fail, "Timeout while start analyzing trace");
                stop;
            }
        };
            
        all component.done;
    }
    
    testcase TC_Trace_File_Summary(inout integer p_traceIndex) runs on MtcType system SystemType {
        var ObuType obuComponent := ObuType.create("OBU"); //DL
        var RsuType rsuComponent := RsuType.create("RSU"); //UL
               
        log ("Summary analysis of all traces in : " & PX_TRACE_PATH);
        
            
    }
    control {
        var integer v_nrOfTransactions := 0;
        execute(TC_Initialization(v_nrOfTransactions));
        for(var integer i:=0; i<v_nrOfTransactions; i:=i + 1) {
            execute(TC_AnalyzesTrace(i));
        }
        execute(TC_Trace_File_Summary(v_nrOfTransactions));
    }
    
}