/**
 *    @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 ItsFa {
            
            map(self:utPort, system:utPort);
            map(self:camPort, system:camPort);
            f_connect4SelfOrClientSync();
            
        } // end f_cfUp
        
        /**
         * @desc    Deletes default configuration 
         */
        function f_cfDown() runs on ItsFa {
            
            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_default() runs on ItsFa {
    
            [] camPort.receive(mw_camInd ( mw_camMsg_any )){ 
                f_selfOrClientSyncAndVerdict("error", e_error, "*** a_basicDefault: CAM message received in default ***");
            }
            [] camPort.receive {
                f_selfOrClientSyncAndVerdict("error", e_error, "*** a_basicDefault: event received on CAM port in default ***");
            }
            [] any timer.timeout { 
                f_selfOrClientSyncAndVerdict("error", e_timeout, "*** a_basicDefault: a timer expired in default ***");
            }
            [] a_shutdown() {
                f_poDefault();
                f_cfDown();
                log("*** a_default: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
                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_default());
                      
            f_utInitializeIut(m_camInitialize);
            
        } // end f_prInitialState
    
    } // end of preambles

    group postambles {
        
        /**
         * @desc The default postamble.
         */
        function f_poDefault() runs on ItsNt {
            //empty
        }
        
    } // 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_wait.start;
//            alt {
//                [] utPort.receive(UtCamResult:true) {
//                    tc_wait.stop;
//                    log("*** f_utInitializeIut: IUT initialized ***");
//                }
//                [] utPort.receive {
//                    tc_wait.stop;
//                    f_selfOrClientSyncAndVerdict("error", e_error, "*** f_utInitializeIut: IUT could not be initialized ***");
//                }
//                [] tc_wait.timeout {
//                    f_selfOrClientSyncAndVerdict("error", e_timeout, "*** f_utInitializeIut: IUT could not be initialized in time ***");
//                }
//            }
//            
//        }
//        
//        /**
//         * @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.
//         * @param   p_discard The event should not appear. Default value: FALSE.
//         */
//        function f_utCheckEvent(template (value) CamPdu p_event, boolean p_discard := false) runs on ItsFa {
//            var template (value) UtCamCheck v_utMsg := { p_event };
//            
//            utPort.send(v_utMsg);
//            tc_wait.start;
//            alt {
//                [] utPort.receive(UtCamResult:true) {
//                    tc_wait.stop;
//                    if (p_discard == false) {
//                        log("*** f_utCheckEvent: Event correctly indicated at application layer ***");
//                    }
//                    else {
//                        f_selfOrClientSyncAndVerdict("error", e_error, "*** f_utCheckEvent: Event indicated at application layer where it should be discarded ***");
//                    }
//                }
//                [] utPort.receive {
//                    tc_wait.stop;
//                    if (p_discard == false) {
//                        f_selfOrClientSyncAndVerdict("error", e_error, "*** f_utCheckEvent: Event not correctly indicated at application layer ***");
//                    }
//                    else {
//                        log("*** f_utCheckEvent: Another event indicated at application layer, repeating check ***");
//                        repeat;
//                    }
//                }
//                [] tc_wait.timeout {
//                    if (p_discard == false) {
//                        f_selfOrClientSyncAndVerdict("error", e_timeout, "*** f_utCheckEvent: Timeout while waiting for event check result ***");
//                    }
//                    else {
//                        log("*** f_utCheckEvent: Event not indicated at application layer ***");
//                    }
//                }
//            }
//        }
//        
//    } // 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