/**
 *    @author     ETSI / STF405
 *    @version    $URL$
 *                $Id$
 *    @desc       Module containing common functions for ITS
 *
 */
 
module LibItsCommon_Functions {

    // LibCommon
    import from LibCommon_Sync all;
    import from LibCommon_VerdictControl all;
    
    // LibIts
    import from DENM_PDU_Descriptions language "ASN.1:1997" all; 
    import from LibItsCommon_Pixits all;
    import from LibIts_Interface all;
    import from LibItsCommon_TypesAndValues all;

    group upperTester {
        
        /**
         * @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 ItsAdapterComponent {
            
            utPort.send(p_init);
            tc_wait.start;
            alt {
                [] utPort.receive(UtResult:true) {
                    tc_wait.stop;
                    log("*** f_utInitializeIut: INFO: IUT initialized ***");
                }
                [] utPort.receive {
                    tc_wait.stop;
                    log("*** f_utInitializeIut: INFO: IUT could not be initialized ***");
                    f_selfOrClientSyncAndVerdict("error", e_error);
                }
                [] tc_wait.timeout {
                    log("*** f_utInitializeIut: INFO: IUT could not be initialized in time ***");
                    f_selfOrClientSyncAndVerdict("error", e_timeout);
                }
                [else] { // Shortcut defaults
                    repeat;	
                }
            }
            
        }
        
        /**
         * @desc    Triggers event from the application layer
         * @param   p_event The event to trigger.
         */
        function f_utTriggerEvent(template (value) UtEvent p_event) runs on ItsAdapterComponent {
            var template (value) UtTrigger v_utMsg := { p_event };
            
            utPort.send(v_utMsg);
            alt {
                [] utPort.receive(UtResult:true) {
                    tc_wait.stop;
                }
                [] utPort.receive {
                    tc_wait.stop;
                }
                [] tc_wait.timeout {
                }
                [else] { // Shortcut defaults
                    repeat; 
                }
            }
        }
        
        /**
         * @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) UtEvent p_event, boolean p_discard) runs on ItsAdapterComponent {
            var template (value) UtCheck v_utMsg := { p_event };
            
            utPort.send(v_utMsg);
            tc_wait.start;
            alt {
                [] utPort.receive(UtResult:true) {
                    tc_wait.stop;
                    if (p_discard == false) {
                        log("*** f_utCheckEvent: INFO: Event correctly indicated at application layer ***");
                    }
                    else {
                        log("*** f_utCheckEvent: ERROR: Event indicated at application layer where it should be discarded ***");
                        f_selfOrClientSyncAndVerdict("error", e_error);
                    }
                }
                [] utPort.receive(UtResult:false) {
                    tc_wait.stop;
                    if (p_discard == false) {
                        log("*** f_utCheckEvent: ERROR: Event not correctly indicated at application layer ***");
                        f_selfOrClientSyncAndVerdict("error", e_error);
                    }
                    else {
                        log("*** f_utCheckEvent: INFO: Event not indicated at application layer***");
                    }
                }
                [] tc_wait.timeout {
                    log("*** f_utCheckEvent: ERROR: Timeout while waiting for event check result ***");
                    f_selfOrClientSyncAndVerdict("error", e_timeout);                    
                }
                [else] { // Shortcut defaults
                    repeat; 
                }
            }
        }
        
    } // end of group upper tester    
    
    group generalFunctions {
        
        /** 
         * @desc    function to generate integer random values
         *            
         * @see        ttcn-3 - rnd()
         * @param     p_lowerbound lowest number in range
         * @param     p_upperbound highest number in range
         * @return     random integer
         *
        */
        function f_random(    in integer p_lowerbound,
                            in integer p_upperbound )
        return integer {
            //Variables
            var integer v_random := 0;
            v_random := float2int(int2float(p_upperbound - p_lowerbound +1)*rnd()) + p_lowerbound;
    
            log("*** f_random: INFO: OK - random value = " & int2str(v_random) & " ***");
            return v_random;
    
        } // end function f_random

        /**
         * @desc    Computes the absolute value of an integer 
         * @param   p_number    the number
         * @return  Absolute value of the number
         */
        function f_abs(in integer p_number) 
        return integer {
            
            if(p_number < 0) {
            	return 0 - p_number;
            }
            return p_number;	
        }

        /** 
         * @desc    Removes unsignificant right-most 0 bits of a bitstring
         *            
         * @param     p_bitstring Bitstring to be reduced
         * @return    Reduced bitstring
         *
        */    
        function f_removeUnsignificantBits(in bitstring p_bitstring)
        return bitstring {
        	var integer i, len;
        	
        	len := lengthof(p_bitstring);
        	for(i:=len-1; i >=0 and p_bitstring[i] == '0'B; i:=i-1) {}
        	return substr(p_bitstring, 0, i + 1);
        } 
    
        /**
         * @desc    Gets the current time
         * @return  Timestamp - current time in Epoch format
         */
        function f_getCurrentTime() return TimeStamp {
            var TimeStamp v_timeStamp := 0;
            
            log("*** f_getCurrentTime: INFO: calling fx_getCurrentTime() ***");
            v_timeStamp := fx_getCurrentTime();
            
            return v_timeStamp;
        }
           
    } // end generalFunctions  
       
    group itsFunctions { 

        /** 
         * @desc    Gets the station identifier of test system
         * @return  Test system's station ID
         * @see     PX_TESTER_STATION_ID
         */
        function f_getTsStationId()
        return StationID {
            
            return PX_TESTER_STATION_ID;
                
        } // end f_getTsStationId
        
        /**
         * @desc    Gets the current position of test system
         * @return  Test system's position
         */
        function f_getTsCurrentPosition() return ReferencePosition {
            
            /* TODO: consider getting position from TA (as it is done for GN) */
            return PX_TS_POSITION;
            
        } // end f_getTsCurrentPosition
                
    } // end itsFunctions       
  
    group externalFunctions {
        
        /**
         * @desc    This external function gets the current time    
         * @return  Timestamp - current time in Epoch format
         */
        external function fx_getCurrentTime() return TimeStamp;
        
    } // end externalFunctions


} // end of module