module MainModule {
    import from TraceParserSystem all;

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

        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);
                
                alt{
                    [] compPort.receive(NrOfEmptyMsg :?) -> value v_nrOfEmptyMsg;
                    
                    [] compPort.receive {
                        transactionOBUTimer.stop;
                        setverdict(fail, "Unexpected message received");
                        stop;
                    }
                    [] transactionOBUTimer.timeout {
                        setverdict (inconc, "No NrOfEmptyMsg was received from RSU");
                        stop;
                    }                    
                }
                
                
                p_tranDuration := v_ts - v_startTS;
                if (p_tranDuration <= 100000) {
                    setverdict (pass, "Transaction finished in " & int2str(p_tranDuration) & " The Number of empty messages received: " & int2str(v_nrOfEmptyMsg));
                }
                else {
                    setverdict (fail, "Transaction finished in more than 100ms (" & int2str(p_tranDuration) & ")");
                }
                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 NrOfEmptyMsg v_cntEmpty := 0;
        var template (present) LinkId v_linkId := ?;
        timer t_rsuTimer := 2.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) {
                compPort.send(v_cntEmpty);
                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) & ")");
                }
                stop;
            }
            []t_rsuTimer.timeout{
                setverdict(inconc, "No RSU messaged received");
                stop;
            }
        }
    }

    /**
     * @desc This test case is seting the trace file and counts the number of transaction 
     */
    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;
            }
        };
        
    }

    /**
     * @desc This test case analizes a transaction, it's duration and the number of empty messages received from RSU 
     */
    testcase TC_AnalyzesTrace(inout integer p_traceIndex, inout integer p_tranDuration) 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(p_tranDuration));
        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_LogAnalyzesTrace(inout integer p_averageTranDuration,
    							 inout integer p_shortestTransDuration,
    							 inout integer p_shortestTransIndex,
    							 inout integer p_longestTransDuration,
    							 inout integer p_longestTransIndex) runs on MtcType system SystemType {
        setverdict(pass, "The average transaction duration is: " & int2str(p_averageTranDuration) & "µs" & 
        				 " The shortest transaction was transaction: " & int2str(p_shortestTransIndex) & 
        				 " and took " & int2str(p_shortestTransDuration) & "µs"  & 
        				 " The longest transaction was transaction: " & int2str(p_longestTransIndex) & 
        				 " and took " & int2str(p_longestTransDuration)& "µs") ;
    } 
    
    control {
        var integer v_nrOfTransactions := 0;
        var integer v_nrOfRelevantTransactions := 0;
        var integer v_longestTransDuration := 0;
        var integer v_longestTransIndex := -1;
        var integer v_shortestTransDuration := 0;
        var integer v_shortestTransIndex := -1;
        var integer v_tranDuration := 0;
        var integer v_cumulativeTranDuration := 0;
        var integer v_averageTranDuration;
        
        execute(TC_Initialization(v_nrOfTransactions));
        v_nrOfRelevantTransactions := v_nrOfTransactions;
        
        for(var integer i := 0; i < v_nrOfTransactions; i := i + 1) {
            execute(TC_AnalyzesTrace(i, v_tranDuration));
            v_cumulativeTranDuration := v_cumulativeTranDuration + v_tranDuration;
            if (v_tranDuration == 0) {
                v_nrOfRelevantTransactions := v_nrOfRelevantTransactions - 1;
            }
            if (v_shortestTransDuration == 0) {
                v_shortestTransDuration := v_tranDuration;
            }
            if(v_shortestTransDuration > v_tranDuration){
                log("Short v_tranDuration " & int2str(v_tranDuration));
                v_shortestTransDuration := v_tranDuration;
                v_shortestTransIndex := i;
            }
            else if(v_longestTransDuration < v_tranDuration){
                log("Long v_tranDuration " & int2str(v_tranDuration));
                v_longestTransDuration := v_tranDuration;
                v_longestTransIndex := i;
            }
        };
        
        v_averageTranDuration := float2int(int2float(v_cumulativeTranDuration) / int2float(v_nrOfRelevantTransactions));
        
        execute(TC_LogAnalyzesTrace(v_averageTranDuration,
        							v_shortestTransDuration,
        							v_shortestTransIndex,
        							v_longestTransDuration,
        							v_longestTransIndex));
    }
    
}