/**
 *    @author   ETSI / STF484
 *    @version  $URL$
 *              $Id$
 *    @desc     Module containing common functions for ITS MAPEM SPATEM
 *
 */
module LibItsMapemSpatem_Functions {
    
    // LibCommon
    import from LibCommon_Sync all;
    import from LibCommon_Time all;
    import from LibCommon_VerdictControl all;
    
    // LibIts
    import from ITS_Container language "ASN.1:1997" all;
    import from DSRC language "ASN.1:1997" all;
    
    // LibItsCommon
    import from LibItsCommon_Functions all;
    import from LibItsCommon_TypesAndValues all;
    
    // LibItsMapemSpatem
    import from LibItsMapemSpatem_TestSystem all;
    import from LibItsMapemSpatem_TypesAndValues all;
    import from LibItsMapemSpatem_Templates all;

    group utFuntions { 
            
        /**
         * @desc    Requests to bring the IUT in an initial state
         * @param   p_init The initialisation to trigger.
         */
        function f_utInitializeIut(template (value) UtInitialize p_init) runs on ItsMapemSpatem {
            
            utPort.send(p_init);
            tc_wait.start;
            alt {
                [] utPort.receive(UtInitializeResult:true) {
                    tc_wait.stop;
                    log("*** " & testcasename() & ": INFO: IUT initialized ***");
                }
                [] tc_wait.timeout {
                    log("*** " & testcasename() & ": INFO: Could not receive expected UT message from IUT in time ***");
                    f_selfOrClientSyncAndVerdict("error", e_timeout);
                }
                [else] { // Shortcut defaults
                    //f_sleep(0.050); // 50 ms
                    repeat; 
                }
            }            
        }
        
        /**
         * @desc    Triggers an event from the application layer
         * @param   p_event The event to trigger.
         */
        function f_utTriggerEvent(
                                  in template (value) UtMapemSpatemTrigger p_event
        ) runs on ItsMapemSpatem {
            var UtMapemSpatemTriggerResult v_result;
            
            utPort.send ( p_event );
            tc_wait.start;
            alt {
                [] utPort.receive ( UtMapemSpatemTriggerResult:? ) -> value v_result {
                    tc_wait.stop;
                    if ( not v_result ) {
                        f_selfOrClientSyncAndVerdict("MapSpat Trigger failed", e_error);
                    }
                        
                }
                [] tc_wait.timeout {
                    log("*** " & testcasename() & ": INFO: Could not receive expected UT message from IUT in time ***");
                    f_selfOrClientSyncAndVerdict("error", e_timeout);
                }
                [else] { // Shortcut defaults
                    //f_sleep(0.050); // 50 ms
                    repeat; 
                }
            }
            
            return;
        }
    } // End of group utFuntions
    
    group altsteps {
        
        /**
         * @desc Default handling cf01 de-initialisation.
         */
        altstep a_cf01Down() runs on ItsMapemSpatem {
            [] a_shutdown() {
                f_poDefault();
                f_cfDown();
                log("*** a_cf01Down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
                stop;
            }
        }
        
        /**
         * @desc The base default.
         */
        altstep a_default() runs on ItsMapemSpatem {
            [] mapemSpatemPort.receive(mw_mapemInd(mw_mapemPdu(mw_defaultMapem))) { 
                log("*** " & testcasename() & ": INFO: MAPEM received in default ***");
                vc_mapemReceived := true;
                repeat;
            }
            [] mapemSpatemPort.receive(mw_spatemInd(mw_spatemPdu(mw_defaultSpatem))) { 
                log("*** " & testcasename() & ": INFO: MAPEM received in default ***");
                vc_spatemReceived := true;
                repeat;
            }
            [] mapemSpatemPort.receive {
                log("*** " & testcasename() & ": ERROR: Received an unexpected message ***");
                f_selfOrClientSyncAndVerdict("error", e_error);
            }
            [] any timer.timeout {
                log("*** " & testcasename() & ": INCONC: Timeout while awaiting the reception of a message ***");
                f_selfOrClientSyncAndVerdict("error", e_timeout);
            }
            [] a_shutdown() {
                f_poDefault();
                f_cfDown();
                log("*** " & testcasename() & ": INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
                stop;   
            }
        }
        
        /**
         * @desc The default for handling upper tester messages.
         */
        altstep a_utDefault() runs on ItsMapemSpatem {
            var UtMapemEventInd v_mapemevent;
            var UtSpatemEventInd v_spatemevent;
            [] utPort.receive(UtMapemEventInd:?) -> value v_mapemevent {
                //store every upper tester indication received
                vc_utMapemEvents[lengthof(vc_utMapemEvents)] := v_mapemevent;
                repeat;
            }
            [] utPort.receive(UtSpatemEventInd:?) -> value v_spatemevent {
                //store every upper tester indication received
                vc_utSpatemEvents[lengthof(vc_utSpatemEvents)] := v_spatemevent;
                repeat;
            }
            [] utPort.receive {
                log("*** " & testcasename() & ": INFO: Received unhandled/unknown UT message from IUT ***");
                repeat;
            }
        }
        
    } // End of group altsteps

    group mapSpatConfigurationFunctions {
        
        /**
         * @desc    Setups default configuration   
         */
        function f_cfUp() runs on ItsMapemSpatem {
            
            map(self:utPort, system:utPort);
            map(self:mapemSpatemPort, system:mapemSpatemPort);
            
            // Connect
            f_connect4SelfOrClientSync();
            activate(a_cf01Down());
            
            //Initialze the IUT
            f_prInitialState();
            
        } // End of f_cfUp
        
        /**
         * @desc    Deletes default configuration 
         */
        function f_cfDown() runs on ItsMapemSpatem {
            
            unmap(self:utPort, system:utPort);
            unmap(self:mapemSpatemPort, system:mapemSpatemPort);
            
            f_disconnect4SelfOrClientSync();
        } // End of f_cfDown
        
    } // End of of mapSpatConfigurationFunctions
    
    group preambles {
        
        /**
         * @desc The default preamble.
         */
        function f_prDefault() runs on ItsMapemSpatem {
            vc_default := activate(a_default());
            activate(a_utDefault());
        }
        
        /**
         * @desc Brings the IUT into an initial state.
         * @return FncRetCode 
         */
        function f_prInitialState() runs on ItsMapemSpatem return FncRetCode {
            var FncRetCode v_ret := e_success;
            
            f_utInitializeIut(m_mapemSpatemInitialize);
            f_prDefault();
            return v_ret;
        }
        
    } // End of group preambles

    group postambles {
        
        /**
         * @desc The default postamble.
         */
        function f_poDefault() runs on ItsMapemSpatem {
            //empty
        }
        
    } // End of group postambles
        
    group receiveFunctions {
        
        /**
         * @desc Awaits a SPATE message and returns it
         * @param p_rcvMsg The expected message to be received.
         * @param p_rcvdMsg The received message - OUT.
         */
        function f_awaitSpateMessage(in template (present) SpatemInd p_rcvMsg, out SpatemInd p_rcvdMsg) runs on ItsMapemSpatem {
            
            tc_ac.start;
            alt {
                [] mapemSpatemPort.receive(p_rcvMsg) -> value p_rcvdMsg {
                    tc_ac.stop;
                }
                [] tc_ac.timeout {
                    log("*** " & testcasename() & ": INFO: Timeout while awaiting the reception of a message ***");
                    f_selfOrClientSyncAndVerdict("error", e_timeout);
                }
            }
        }
        
        /**
         * @desc Awaits a MAPE message and returns it
         * @param p_rcvMsg The expected message to be received.
         * @param p_rcvdMsg The received message - OUT.
         */
        function f_awaitMapeMessage(in template (present) MapemInd p_rcvMsg, out MapemInd p_rcvdMsg) runs on ItsMapemSpatem {
            
            tc_ac.start;
            alt {
                [] mapemSpatemPort.receive(p_rcvMsg) -> value p_rcvdMsg {
                    tc_ac.stop;
                }
                [] tc_ac.timeout {
                    log("*** " & testcasename() & ": INFO: Timeout while awaiting the reception of a message ***");
                    f_selfOrClientSyncAndVerdict("error", e_timeout);
                }
            }
        }
        
    } // End of receiveFunctions
    
} // End of module LibItsMapemSpatem_Functions