module MainModule {
    import from TraceParserSystem all;

    function f_rsuBehaviour() runs on RsuType {
        var address v_ts := 0;
        var integer v_startTS := 0;
        var template (present) LinkId v_linkId := ?;
        var boolean v_receivedLinkId := false;
        var boolean v_actionAtOBU := false;
        var PayloadStructure v_receivedMsg;
        
        var VerdictStructure v_vs;

        transactionRSUTimer.start;
        alt {
            [v_startTS==0] rsuPort.receive(mw_rsuBroadCastMsg) -> sender v_ts value v_receivedMsg{ 
                // when the first broadcast message is received then take it's time stamp
                transactionRSUTimer.stop;
                //---
                commonOBURSUPort.send(v_receivedMsg);
                //---
                v_startTS := v_ts;
                transactionRSUTimer.start;
                compPort.send(true);
                repeat; 
            }
            [] compPort.receive(v_linkId) -> value v_linkId{
                transactionRSUTimer.stop;
                v_receivedLinkId := true;
                transactionRSUTimer.start;
                repeat;
            }
            [] compPort.receive(true){
                v_actionAtOBU := true;
                repeat;
            }
            [v_startTS!=0 and v_receivedLinkId == true] rsuPort.receive(mw_releaseMsg(v_linkId)) -> sender v_ts value v_receivedMsg{ 
                // when the release message was received take it's time stamp and calculate the transaction time
                // inform the rsu component 
                transactionRSUTimer.stop;
                //---
                commonOBURSUPort.send(v_receivedMsg);
                //---

	            compPort.send(m_stop);
                transactionRSUTimer.start;
                
                alt{
                    [] compPort.receive(NrOfEmptyMsg :?) -> value v_vs.nrOfEmptyMsg;
                    
                    [] compPort.receive {
                        transactionRSUTimer.stop;
                        setverdict(inconc, "Unexpected message received");
                        stop;
                    }
                    [] transactionRSUTimer.timeout {
                        setverdict (inconc, "No NrOfEmptyMsg was received from RSU");
                        stop;
                    }                    
                }
                
//                p_tranDuration := v_ts - v_startTS;
//                if (p_tranDuration <= 100000 and p_nrOfEmptyMsg <= PX_MAX_NUM_EMPTY_UPLINK_FRAMES){
//                    setverdict (pass, "Transaction finished in " & int2str(p_tranDuration) & " microsec." & " The Number of empty messages received is : " & int2str(p_nrOfEmptyMsg));
//                }
//                else if(p_tranDuration > 100000){
//                    setverdict (fail, "Transaction finished in more than 100ms (" & int2str(p_tranDuration) & " micro s "  &")");
//                }else if(p_nrOfEmptyMsg > PX_MAX_NUM_EMPTY_UPLINK_FRAMES){
//                    setverdict (fail, "Maximum number of received empty frames exceeded! (" 
//                                                         & int2str(p_nrOfEmptyMsg) & " > " & int2str(PX_MAX_NUM_EMPTY_UPLINK_FRAMES) & ")");
//                }
//                p_transVerdict := getverdict;
                v_vs.tranDuration := v_ts - v_startTS;
                if (v_vs.tranDuration <= 100000 and v_vs.nrOfEmptyMsg <= PX_MAX_NUM_EMPTY_UPLINK_FRAMES){
                    setverdict (pass, "Transaction finished in " & int2str(v_vs.tranDuration) & " microsec." & " The Number of empty messages received is : " & int2str(v_vs.nrOfEmptyMsg));
                }
                else if(v_vs.tranDuration > 100000){
                    setverdict (fail, "Transaction finished in more than 100ms (" & int2str(v_vs.tranDuration) & " micro s "  &")");
                }else if(v_vs.nrOfEmptyMsg > PX_MAX_NUM_EMPTY_UPLINK_FRAMES){
                    setverdict (fail, "Maximum number of received empty frames exceeded! (" 
                                                         & int2str(v_vs.nrOfEmptyMsg) & " > " & int2str(PX_MAX_NUM_EMPTY_UPLINK_FRAMES) & ")");
                }
                verdictPort.send(m_verdictStructure(getverdict, v_vs.tranDuration, v_vs.nrOfEmptyMsg));
                stop;
            }
            [v_startTS!=0 and v_receivedLinkId == true] rsuPort.receive(mw_msg_withLinkId(v_linkId))-> value v_receivedMsg{
                transactionRSUTimer.stop;
                //---
                commonOBURSUPort.send(v_receivedMsg);
                //---
                transactionRSUTimer.start;
                repeat;
            }
            [v_startTS!=0 and v_receivedLinkId == true] rsuPort.receive(mw_rsuBroadCastMsg) -> value v_receivedMsg{ 
                //If another broadcast is received than ignore
                transactionRSUTimer.stop;
                //---
                commonOBURSUPort.send(v_receivedMsg);
                //---
                transactionRSUTimer.start;
                repeat;
            }
            [v_startTS!=0 and v_receivedLinkId == true] rsuPort.receive {
                transactionRSUTimer.stop;
                setverdict(inconc, "Unexpected message received");
                compPort.send(m_stop);
                verdictPort.send(m_verdictStructure(getverdict));
                stop;                
            }
            [] transactionRSUTimer.timeout {
                if(v_actionAtOBU)
                    {setverdict (fail, "Transaction incomplete!");}
                else
                    {if(v_startTS==0)
                        {setverdict (fail, "Transaction empty!");}
                     else
                        {setverdict (fail);}
                    }
               	compPort.send(m_stop);
               	
                verdictPort.send(m_verdictStructure(getverdict));
                stop;
            }
        }
    }
    
    function f_obuBehaviour() runs on ObuType {
        var boolean v_sentLinkId := false;
        var boolean v_actionAtRSU := false;
        var PayloadStructure v_msg;
        var NrOfEmptyMsg v_cntEmpty := 0;
        var template (present) LinkId v_linkId := ?;
        
        transactionOBUTimer.start;
        alt{
            []obuPort.receive(mw_msg_withLinkId(v_linkId)) -> value v_msg{
                transactionOBUTimer.stop;
                //---
                 commonOBURSUPort.send(v_msg);
                //---
                if (v_sentLinkId == false) {
                       v_linkId := valueof(v_msg.linkMsg.linkId);
                       compPort.send(valueof(v_linkId));
                }
                v_sentLinkId := true;
                transactionOBUTimer.start;
                compPort.send(true);
                repeat;
            }
            []obuPort.receive(mw_msg_empty) ->value v_msg{
                transactionOBUTimer.stop;
                //---
                 commonOBURSUPort.send(v_msg);
                //---
                v_cntEmpty := v_cntEmpty +1;
                transactionOBUTimer.start;
                repeat;
            }
            []obuPort.receive{
                transactionOBUTimer.stop;
                setverdict (inconc, "Unexpected message received.");
                stop;
            }
            [] compPort.receive(true){
                v_actionAtRSU := true;
                repeat;
            }

            []compPort.receive(m_stop) {
                compPort.send(v_cntEmpty);
                stop;
            }
            []transactionOBUTimer.timeout{
                if(v_actionAtRSU)
                    {setverdict(fail, "No OBU message received");}
                else
                    {setverdict(fail);}
                stop;
            }
        }
    }
  
    testcase TC_CheckTracePath(in charstring p_tracePath, out TraceFileList p_traceFileList) runs on MtcType system SystemType {
        map(mtc:controlPort, system:controlPort);
        
        controlPort.call(getTraceFileList:{p_tracePath}, 5.0) {
            [] controlPort.getreply(getTraceFileList:{-} value ?) -> value p_traceFileList {
                if(lengthof(p_traceFileList) != 0){
                    setverdict (pass, "Number of Trace files = " & int2str(lengthof(p_traceFileList)));   
                }else{
                    setverdict (fail, "!!No Trace Files Found!! Please verify the log folder!!");   
                    stop;
                }
            }
            [] controlPort.getreply {
                setverdict (fail, "Unexpected reply");
                stop;
            }
            [] controlPort.catch(timeout) {
                setverdict (fail, "Timeout while caling getTraceFileList");
                stop;
            }
        };
    }
    
    /**
     * @desc This test case is seting the trace file and counts the number of transaction 
     */
    testcase TC_Initialization(in charstring p_traceFile, out integer p_nrOfTransactions) runs on MtcType system SystemType {
        
        map(mtc:controlPort, system:controlPort);
        
        parseFileName(p_traceFile, v_PowerLevel, v_OBUName, v_DutyCycle, v_RepNo);
        
        controlPort.call(setTraceFile:{p_traceFile}, 5.0) {
            [] controlPort.getreply(setTraceFile:{-} value true) {
                setverdict (pass, "  PowerLevel = " & v_PowerLevel&
                                  "  OBUName = " & v_OBUName & 
                                  "  DutyCycle = " & v_DutyCycle &
                                  "  RepNo = " &  v_RepNo );
            }
            [] 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 {
                if(p_nrOfTransactions != 0){
                    setverdict (pass, "Number of Transaction = " & int2str(p_nrOfTransactions));   
                }else{
                    setverdict (fail, "!!Log file does not contain any transactions !! Please verify the log file!!");   
                    stop;
                }
            }
            [] controlPort.getreply {
                setverdict (fail, "Unexpected reply");
                stop;
            }
            [] controlPort.catch(timeout) {
                setverdict (fail, "Timeout while caling getTransacationCnt");
                stop;
            }
        };
        
        controlPort.call(writeCSVITSParams:{PX_CSV_FILE, v_PowerLevel, v_OBUName, v_DutyCycle, v_RepNo}, 5.0) {
            [] controlPort.getreply(writeCSVITSParams:{-, -, -, -, -} value true) {
                setverdict (pass, "Success when writing in the csv file " & PX_CSV_FILE);
            }
            [] controlPort.getreply {
                setverdict (fail, "Problem occured when writing the ITS parameters in the csv file " & PX_CSV_FILE);
                stop;
            }
            [] controlPort.catch(timeout) {
                setverdict (fail, "Timeout while writing the ITS parameters in the  csv file "  & PX_CSV_FILE);
                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, inout integer p_nrOfEmptyMsg, inout verdicttype p_transVerdict) runs on MtcType system SystemType {
        var RsuType rsuComponent := RsuType.create("RSU"); //DL
        var ObuType obuComponent := ObuType.create("OBU"); //UL
        var VerdictStructure v_vs;
        
        map(mtc:controlPort, system:controlPort);
        map(rsuComponent:rsuPort, system:msgPort);
        map(obuComponent:obuPort, system:msgPort);
        connect(rsuComponent:compPort, obuComponent:compPort);
        connect(rsuComponent:commonOBURSUPort, obuComponent:commonOBURSUPort);
        
        connect(mtc:verdictPort, rsuComponent:verdictPort);
        
        rsuComponent.start(f_rsuBehaviour());
        obuComponent.start(f_obuBehaviour());
        
        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;
        
        transactionTimer.start;
        alt {
            [] verdictPort.receive(VerdictStructure:?) -> value v_vs {
                transactionTimer.stop;
                p_transVerdict := v_vs.transVerdict;
                p_tranDuration := v_vs.tranDuration;
                p_nrOfEmptyMsg := v_vs.nrOfEmptyMsg;
            }
            [] transactionTimer.timeout {
            }
        }
         
        controlPort.call(writeCSVTransaction:{PX_CSV_FILE, p_tranDuration, p_nrOfEmptyMsg}, 5.0) {
            [] controlPort.getreply(writeCSVTransaction:{-, -, -} value true) {
                setverdict (pass);
            }
            [] controlPort.getreply {
                setverdict (fail, "Problem occured when writing the ITS parameters in the csv file " & PX_CSV_FILE);
                stop;
            }
            [] controlPort.catch(timeout) {
                setverdict (fail, "Timeout while writing the ITS parameters in the  csv file "  & PX_CSV_FILE);
                stop;
            }
        };
        
    }
    
    testcase TC_LogAnalyzesTrace(inout integer p_averageTranDuration,
                                 inout integer p_shortestTransDuration,
                                 inout integer p_shortestTransIndex,
                                 inout integer p_longestTransDuration,
                                 inout integer p_longestTransIndex ,
                                 inout integer p_nrOfTransactions,
                                 inout integer p_failTran,
                                 inout integer p_inconcTran, 
                                 inout integer p_passTran) runs on MtcType system SystemType {        
        map(mtc:controlPort, system:controlPort);

        controlPort.call(writeCSVMinMaxErrorRate:{PX_CSV_FILE, p_shortestTransDuration,
                                                p_shortestTransIndex, p_longestTransDuration,
                                                p_longestTransIndex,  p_averageTranDuration,
                                                p_nrOfTransactions, 
                                                ((p_failTran + p_inconcTran) * 100) / p_nrOfTransactions}, 5.0) {
            [] controlPort.getreply(writeCSVMinMaxErrorRate:{-, -, -,-, -, -,-, -} value true) {
                setverdict (pass);
            }
            [] controlPort.getreply {
                setverdict (fail, "Problem occured when writing the error rate in the csv file " & PX_CSV_FILE);
                stop;
            }
            [] controlPort.catch(timeout) {
                setverdict (fail, "Timeout while writing the error rate in the  csv file "  & PX_CSV_FILE);
                stop;
            }
        };
                                
        setverdict(pass, "The average transaction duration is: " & int2str(p_averageTranDuration) & " micro s." & 
                         " The shortest transaction was transaction: " & int2str(p_shortestTransIndex) & 
                         " and took " & int2str(p_shortestTransDuration) & " micro s."  & 
                         " The longest transaction was transaction: " & int2str(p_longestTransIndex) & 
                         " and took " & int2str(p_longestTransDuration)& " micro s." &
                         " Transaction Erorr Rate: " & int2str(((p_failTran + p_inconcTran) * 100) / p_nrOfTransactions)
                         ) ;
                         
         unmap(mtc:controlPort, system:controlPort);            
    } 
    
    control {
        var integer v_nrOfTransactions := 0;
        var integer v_nrOfRelevantTransactions := 0;
        var integer v_nrOfEmptyTransactions := 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;
        var integer v_failTran := 0;
        var integer v_inconcTran := 0;
        var integer v_passTran := 0;
        var verdicttype v_transVerdict := fail;
        var TraceFileList v_traceFileList;
        
        execute(TC_CheckTracePath(PX_TRACE_PATH, v_traceFileList));
        
        for(var integer j:=0; j<lengthof(v_traceFileList); j:=j + 1) {
            v_nrOfTransactions := 0;
            v_nrOfRelevantTransactions := 0;
            v_nrOfEmptyTransactions := 0;
            v_longestTransDuration := 0;
            v_longestTransIndex := 0;
            v_shortestTransDuration := 0;
            v_shortestTransIndex := 0;
            v_tranDuration := 0;
            v_cumulativeTranDuration := 0;
            v_averageTranDuration := 0;
            v_transVerdict := fail;
            v_failTran := 0;
            v_inconcTran := 0;
            v_passTran := 0;
            
            execute(TC_Initialization(v_traceFileList[j], v_nrOfTransactions));
            v_nrOfRelevantTransactions := v_nrOfTransactions;
            
            for(var integer i:=0; i<v_nrOfTransactions; i:=i + 1) {
                execute(TC_AnalyzesTrace(i, v_tranDuration, v_nrOfEmptyTransactions, v_transVerdict));
                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 +1; // for a better understanding when reading the statistic (instead of starting counting from 0 it starts from 1)
                }
                else if(v_longestTransDuration < v_tranDuration){
                    log("Long v_tranDuration " & int2str(v_tranDuration));
                    v_longestTransDuration := v_tranDuration;
                    v_longestTransIndex := i +1; // for a better understanding when reading the statistic (instead of starting counting from 0 it starts from 1)
                }
                
                select(v_transVerdict){
                    case(inconc){
                        v_inconcTran := v_inconcTran +1:
                    }
                    case(fail){
                        v_failTran := v_failTran +1;
                    }
                    case(pass){
                        v_passTran := v_passTran +1;
                    }
                }
                
                
            };
            
            if(v_nrOfRelevantTransactions != 0){
                v_averageTranDuration := float2int(int2float(v_cumulativeTranDuration) / int2float(v_nrOfRelevantTransactions));
                execute(TC_LogAnalyzesTrace(v_averageTranDuration,
                                            v_shortestTransDuration,
                                            v_shortestTransIndex,
                                            v_longestTransDuration,
                                            v_longestTransIndex,
                                            v_nrOfTransactions,
                                            v_failTran,
                                            v_inconcTran,
                                            v_passTran
                                            ));
            }
        }
    }    
}