/**
 *    @author     ETSI / STF405
 *    @version    $URL$
 *                $Id$
 *    @desc       Module containing common functions for ITS
 *
 */
module LibItsCam_Functions {
    
    // LibCommon
    import from LibCommon_Sync all;
    import from LibCommon_VerdictControl all;
    
    // LibIts
    import from LibIts_TestSystem all;
    import from LibIts_Interface all; 
    import from LibItsCam_Templates all;
    import from LibItsCam_Pixits all;
    import from LibItsCam_TypesAndValues all;
    import from LibItsCommon_Functions all;
    import from CAM_PDU_Descriptions language "ASN.1:1997" all;
    import from DENM_PDU_Descriptions language "ASN.1:1997" all;    
 
    // LibCommon
    import from LibCommon_VerdictControl all;

    group camConfigurationFunctions {
        
        /**
         * @desc    Setups default configuration   
         */
        function f_cfUp() runs on ItsNt {
            
            map(self:utPort, system:utPort);
            map(self:camPort, system:camPort);
            f_connect4SelfOrClientSync();
            
        } // end f_cfUp
        
        /**
         * @desc    Deletes default configuration 
         */
        function f_cfDown() runs on ItsNt {
            
            unmap(self:utPort, system:utPort);
            unmap(self:camPort, system:camPort);
            f_disconnect4SelfOrClientSync();
            
        } // end f_cfDown
        
    } // end of camConfigurationFunctions
    
    group defaults {
    
        /**
         * @desc    basic default behaviour handling
         */    
        altstep a_basicDefault() runs on ItsFa {
    
            [] camPort.receive(mw_camInd ( mw_camMsg_any )){ 
                setverdict(fail, "*** a_basicDefault: FAIL: CAM message received in default ***");
                stop;
            }
            [] camPort.receive {
                setverdict(fail, "*** a_basicDefault: FAIL: event received on CAM port in default ***");
                stop;
            }
           [] any timer.timeout { 
                setverdict(fail, "*** a_basicDefault: FAIL: a timer expired in default ***");
                stop;
            }
        }//end altstep a_basicDefault
         
         
         
    } // end of defaults  
    
    group preambles {
        
        /**
         * @desc    Initialize the IUT
         * @remark  No specific actions specified in the base standard
         */    
        function f_prInitialState() runs on ItsFa {
            
            // basic default altstep
            activate(a_basicDefault());
                      
            f_utInitializeIut();
            
        } // end f_prInitialState
    
    } // end of preambles

    group postambles {
        
        /**
         * @desc    Global postamble - stops the MTC
         * @remark  No specific actions required so far
         */    
        function f_postamble()  runs on ItsFa {
            
         log("*** f_postamble: INFO: postamble ***");
            
        } // end function f_postamble
        
    } // end group postambles

    group otherFunctions {
            
        /** @desc   function to generate a random bitstring value 
         *          corresponding to 1 bit position set to 1 (eg '00010000', '01000000', ...)
         *  @see    f_random
         *  @param  p_length bitstring length - max 15
         *  @return bitstring
         *
         */
        function f_bitPositionRandom( in integer p_length )
        return bitstring {
            //Variables
            var bitstring v_random := '00000000'B;
            
            v_random := '000000000000001'B << f_random (0, p_length);
            log("*** f_bitPositionRandom: INFO: OK - random value = " & bit2str(v_random) & " ***");
            return v_random;
    
        } // end function f_bitPositionRandom
    
    } // end group otherFunctions

    group upperTester {
    
        /**
         * @desc    Requests to bring the IUT in an initial state
         */
        function f_utInitializeIut() runs on ItsFa {
            
            utPort.send(UtCamInitialize:{});
            tc_ac.start;
            alt {
                [] utPort.receive(UtCamResult:true) {
                    setverdict (pass, "*** f_utInitializeIut: PASS: IUT initialized ***");
                }
                [] utPort.receive {
                    setverdict (inconc, "*** f_utInitializeIut: INCONC: IUT could not be initialized ***");
                    stop;
                }
                [] tc_ac.timeout {
                    setverdict (inconc, "*** f_utInitializeIut: INCONC: IUT could not be initialized in time ***");
                    stop;
                }
            }
            
        }
        
        /**
         * @desc    Triggers event from the application layer
         * @param   p_event The event to trigger.
         */
        function f_utTriggerEvent(template (value) UtCamEvent p_event) runs on ItsFa return FncRetCode {
            var FncRetCode v_ret := e_success;
            var template (value) UtCamTrigger v_utMsg := { p_event };
            
            utPort.send(v_utMsg);
            
            return v_ret;
        }
        
        /**
         * @desc    Checks that the event was indicated at the application layer
         * @param   p_event The event to check.
         */
        function f_utCheckEvent(template (value) CamPdu p_event) runs on ItsFa return FncRetCode {
            var FncRetCode v_ret := e_success;
            var template (value) UtCamCheck v_utMsg := { p_event };
            
            utPort.send(v_utMsg);
            tc_ac.start;
            alt {
                [] utPort.receive(UtCamResult:true) {
                    setverdict (pass, "*** f_utCheckEvent: PASS: Event correctly indicated at application layer ***");
                    v_ret := e_success;
                }
                [] utPort.receive {
                    setverdict (fail, "*** f_utCheckEvent: FAIL: Event not correctly indicated at application layer ***");
                    v_ret := e_error;
                }
                [] tc_ac.timeout {
                    setverdict (inconc, "*** f_utCheckEvent: INCONC: Timeout while waiting for event check result ***");
                    v_ret := e_timeout;
                }
            }
            
            return v_ret;
        }
        
    } // end group upperTester
    
    group getIutFunctions {
          
        /** 
         * @desc    Function to get the PT Line Description
         * @see     PX_PTLINE_COURSE, PX_PTLINE_REF, PX_PTLINE_ROUTE
         */
        function f_getIutPtLineDescription()
        return PTLineDescription {

            var PTLineDescription v_ptLineDescription := {"", "", ""};
            
            v_ptLineDescription := {PX_PTLINE_COURSE, PX_PTLINE_REF, PX_PTLINE_ROUTE}; 

            return v_ptLineDescription ;
    
        } // end function f_getIutPtLineDescription
    
    } // end getIutFunctions
    
    group getTesterFunctions {
        /** 
         * @desc    Gets tester's station characteristics
         * @return  Station characteristics
         * @see     PX_TESTER_IS_MOBILE, PX_TESTER_IS_PRIVATE, PX_TESTER_IS_PHYSICAL_RELEVANT    
        */
        function f_getTesterStationCharacteristics()
        return CoopAwareness.stationCharacteristics {

            var CoopAwareness.stationCharacteristics v_stationCharacteristics := { true, true, true };

            v_stationCharacteristics := {PX_TESTER_IS_MOBILE, PX_TESTER_IS_PRIVATE, PX_TESTER_IS_PHYSICAL_RELEVANT};
            
            return v_stationCharacteristics ;
    
        } // end f_getTesterStationCharacteristics

    } // end getTesterFunctions

} // end LibItsCam_Functions