#!/usr/bin/env python3
#
#   Copyright 2016 - The Android Open Source Project
#
#   Licensed under the Apache License, Version 2.0 (the "License");
#   you may not use this file except in compliance with the License.
#   You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS,
#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#   See the License for the specific language governing permissions and
#   limitations under the License.

import time

from queue import Empty
from datetime import datetime
from acts.controllers.anritsu_lib import band_constants
from acts.controllers.anritsu_lib._anritsu_utils import AnritsuUtils
from acts.controllers.anritsu_lib.md8475a import BtsNumber
from acts.controllers.anritsu_lib.md8475a import BtsNwNameEnable
from acts.controllers.anritsu_lib.md8475a import BtsServiceState
from acts.controllers.anritsu_lib.md8475a import BtsTechnology
from acts.controllers.anritsu_lib.md8475a import CsfbType
from acts.controllers.anritsu_lib.md8475a import ImsCscfCall
from acts.controllers.anritsu_lib.md8475a import ImsCscfStatus
from acts.controllers.anritsu_lib.md8475a import MD8475A
from acts.controllers.anritsu_lib.md8475a import ReturnToEUTRAN
from acts.controllers.anritsu_lib.md8475a import VirtualPhoneStatus
from acts.controllers.anritsu_lib.md8475a import TestProcedure
from acts.controllers.anritsu_lib.md8475a import TestPowerControl
from acts.controllers.anritsu_lib.md8475a import TestMeasurement
from acts.controllers.anritsu_lib.md8475a import Switch
from acts.controllers.anritsu_lib.md8475a import BtsPacketRate
from acts_contrib.test_utils.tel.tel_defines import CALL_TEARDOWN_PHONE
from acts_contrib.test_utils.tel.tel_defines import CALL_TEARDOWN_REMOTE
from acts_contrib.test_utils.tel.tel_defines import MAX_WAIT_TIME_CALL_DROP
from acts_contrib.test_utils.tel.tel_defines import RAT_1XRTT
from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_IN_CALL
from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_IN_CALL_LONG
from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_IN_CALL_FOR_IMS
from acts_contrib.test_utils.tel.tel_defines import EventCmasReceived
from acts_contrib.test_utils.tel.tel_defines import EventEtwsReceived
from acts_contrib.test_utils.tel.tel_defines import EventSmsDeliverSuccess
from acts_contrib.test_utils.tel.tel_defines import EventSmsSentSuccess
from acts_contrib.test_utils.tel.tel_defines import EventSmsReceived
from acts_contrib.test_utils.tel.tel_phone_setup_utils import ensure_phone_idle
from acts_contrib.test_utils.tel.tel_phone_setup_utils import wait_for_droid_not_in_call
from acts_contrib.test_utils.tel.tel_voice_utils import hangup_call
from acts_contrib.test_utils.tel.tel_voice_utils import initiate_call
from acts_contrib.test_utils.tel.tel_voice_utils import wait_and_answer_call

# Timers
# Time to wait after registration before sending a command to Anritsu
# to ensure the phone has sufficient time to reconfigure based on new
# network in Anritsu
WAIT_TIME_ANRITSU_REG_AND_OPER = 10
# Time to wait after registration to ensure the phone
# has sufficient time to reconfigure based on new network in Anritsu
WAIT_TIME_ANRITSU_REG_AND_CALL = 10
# Max time to wait for Anritsu's virtual phone state change
MAX_WAIT_TIME_VIRTUAL_PHONE_STATE = 45
# Time to wait for Anritsu's IMS CSCF state change
MAX_WAIT_TIME_IMS_CSCF_STATE = 30
# Time to wait for before aSRVCC
WAIT_TIME_IN_ALERT = 5

# SIM card names
P0250Ax = "P0250Ax"
VzW12349 = "VzW12349"
P0135Ax = "P0135Ax"
FiTMO = "FiTMO"
FiSPR = "FiSPR"
FiUSCC = "FiUSCC"

# Test PLMN information
TEST_PLMN_LTE_NAME = "MD8475A_LTE"
TEST_PLMN_WCDMA_NAME = "MD8475A_WCDMA"
TEST_PLMN_GSM_NAME = "MD8475A_GSM"
TEST_PLMN_1X_NAME = "MD8475A_1X"
TEST_PLMN_1_MCC = "001"
TEST_PLMN_1_MNC = "01"
DEFAULT_MCC = "310"
DEFAULT_MNC = "260"
DEFAULT_RAC = 1
DEFAULT_LAC = 1
VzW_MCC = "311"
VzW_MNC = "480"
TMO_MCC = "310"
TMO_MNC = "260"
Fi_TMO_MCC = "310"
Fi_TMO_MNC = "260"
Fi_SPR_MCC = "310"
Fi_SPR_MNC = "120"
Fi_USCC_MCC = "311"
Fi_USCC_MNC = "580"

# IP address information for internet sharing
#GATEWAY_IPV4_ADDR = "192.168.137.1"
#UE_IPV4_ADDR_1 = "192.168.137.2"
#UE_IPV4_ADDR_2 = "192.168.137.3"
#UE_IPV4_ADDR_3 = "192.168.137.4"
#DNS_IPV4_ADDR = "192.168.137.1"
#CSCF_IPV4_ADDR = "192.168.137.1"

# Default IP address in Smart Studio, work for Internet Sharing with and
# without WLAN ePDG server. Remember to add 192.168.1.2 to Ethernet 0
# on MD8475A after turn on Windows' Internet Coonection Sharing
GATEWAY_IPV4_ADDR = "192.168.1.2"
UE_IPV4_ADDR_1 = "192.168.1.1"
UE_IPV4_ADDR_2 = "192.168.1.11"
UE_IPV4_ADDR_3 = "192.168.1.21"
UE_IPV6_ADDR_1 = "2001:0:0:1::1"
UE_IPV6_ADDR_2 = "2001:0:0:2::1"
UE_IPV6_ADDR_3 = "2001:0:0:3::1"
DNS_IPV4_ADDR = "192.168.1.12"
CSCF_IPV4_ADDR = "192.168.1.2"
CSCF_IPV6_ADDR = "2001:0:0:1::2"
CSCF_IPV6_ADDR_2 = "2001:0:0:2::2"
CSCF_IPV6_ADDR_3 = "2001:0:0:3::2"

# Google Fi IP Config:

Fi_GATEWAY_IPV4_ADDR_Data = "100.107.235.94"
Fi_GATEWAY_IPV6_ADDR_Data = "fe80::aef2:c5ff:fe71:4b9"
Fi_GATEWAY_IPV4_ADDR_IMS_911 = "192.168.1.2"
Fi_GATEWAY_IPV6_ADDR_IMS_911 = "2001:0:0:1::2"

Fi_UE_IPV4_ADDR_Data = "100.107.235.81"
Fi_UE_IPV4_ADDR_IMS = "192.168.1.1"
Fi_UE_IPV4_ADDR_911 = "192.168.1.11"
Fi_UE_IPV6_ADDR_Data = "2620::1000:1551:1140:c0f9:d6a8:44eb"
Fi_UE_IPV6_ADDR_IMS = "2001:0:0:1::1"
Fi_UE_IPV6_ADDR_911 = "2001:0:0:2::1"

Fi_DNS_IPV4_ADDR_Pri = "8.8.8.8"
Fi_DNS_IPV4_ADDR_Sec = "8.8.8.4"
Fi_DNS_IPV6_ADDR = "2001:4860:4860::8888"

Fi_CSCF_IPV4_ADDR_Data = "192.168.1.2"
Fi_CSCF_IPV6_ADDR_Data = "2001:0:0:1::2"
Fi_CSCF_IPV4_ADDR_IMS = "192.168.1.2"
Fi_CSCF_IPV6_ADDR_IMS = "2001:0:0:1::3"
Fi_CSCF_IPV4_ADDR_911 = "192.168.1.12"
Fi_CSCF_IPV6_ADDR_911 = "2001:0:0:2::2"

# Default Cell Parameters
DEFAULT_OUTPUT_LEVEL = -30
DEFAULT_1X_OUTPUT_LEVEL = -35
DEFAULT_INPUT_LEVEL = 0
DEFAULT_LTE_BAND = [2, 4]
Fi_LTE_TMO_BAND = [4]
Fi_LTE_SPR_BAND = [25]
Fi_LTE_USCC_BAND = [12]
Fi_GSM_TMO_BAND = band_constants.GSM_BAND_PGSM900
DEFAULT_WCDMA_BAND = 1
DEFAULT_WCDMA_PACKET_RATE = BtsPacketRate.WCDMA_DLHSAUTO_REL7_ULHSAUTO
DEFAULT_GSM_BAND = band_constants.GSM_BAND_GSM850

#Google Fi CDMA Bands

Fi_USCC1X_MCC = 209
Fi_USCC1X_BAND = 1
Fi_USCC1X_CH = 600
Fi_USCC1X_SID = 5
Fi_USCC1X_NID = 21

Fi_SPR1X_MCC = 320
Fi_SPR1X_BAND = 1
Fi_SPR1X_CH = 600
Fi_SPR1X_SID = 4183
Fi_SPR1X_NID = 233

Fi_EVDO_BAND = 1
Fi_EVDO_CH = 625
Fi_EVDO_SECTOR_ID = "00000000,00000000,00000000,00000000"

DEFAULT_CDMA1X_BAND = 0
DEFAULT_CDMA1X_CH = 356
DEFAULT_CDMA1X_SID = 0
DEFAULT_CDMA1X_NID = 65535
DEFAULT_EVDO_BAND = 0
DEFAULT_EVDO_CH = 356
DEFAULT_EVDO_SECTOR_ID = "00000000,00000000,00000000,00000000"
VzW_CDMA1x_BAND = 1
VzW_CDMA1x_CH = 150
VzW_CDMA1X_SID = 26
VzW_CDMA1X_NID = 65535
VzW_EVDO_BAND = 0
VzW_EVDO_CH = 384
VzW_EVDO_SECTOR_ID = "12345678,00000000,00000000,00000000"
DEFAULT_T_MODE = "TM1"
DEFAULT_DL_ANTENNA = 1

# CMAS Message IDs
CMAS_MESSAGE_PRESIDENTIAL_ALERT = hex(0x1112)
CMAS_MESSAGE_EXTREME_IMMEDIATE_OBSERVED = hex(0x1113)
CMAS_MESSAGE_EXTREME_IMMEDIATE_LIKELY = hex(0x1114)
CMAS_MESSAGE_EXTREME_EXPECTED_OBSERVED = hex(0x1115)
CMAS_MESSAGE_EXTREME_EXPECTED_LIKELY = hex(0x1116)
CMAS_MESSAGE_SEVERE_IMMEDIATE_OBSERVED = hex(0x1117)
CMAS_MESSAGE_SEVERE_IMMEDIATE_LIKELY = hex(0x1118)
CMAS_MESSAGE_SEVERE_EXPECTED_OBSERVED = hex(0x1119)
CMAS_MESSAGE_SEVERE_EXPECTED_LIKELY = hex(0x111A)
CMAS_MESSAGE_CHILD_ABDUCTION_EMERGENCY = hex(0x111B)
CMAS_MESSAGE_MONTHLY_TEST = hex(0x111C)
CMAS_MESSAGE_CMAS_EXECERCISE = hex(0x111D)

# ETWS Message IDs
ETWS_WARNING_EARTHQUAKE = hex(0x1100)
ETWS_WARNING_TSUNAMI = hex(0x1101)
ETWS_WARNING_EARTHQUAKETSUNAMI = hex(0x1102)
ETWS_WARNING_TEST_MESSAGE = hex(0x1103)
ETWS_WARNING_OTHER_EMERGENCY = hex(0x1104)

# C2K CMAS Message Constants
CMAS_C2K_CATEGORY_PRESIDENTIAL = "Presidential"
CMAS_C2K_CATEGORY_EXTREME = "Extreme"
CMAS_C2K_CATEGORY_SEVERE = "Severe"
CMAS_C2K_CATEGORY_AMBER = "AMBER"
CMAS_C2K_CATEGORY_CMASTEST = "CMASTest"

CMAS_C2K_PRIORITY_NORMAL = "Normal"
CMAS_C2K_PRIORITY_INTERACTIVE = "Interactive"
CMAS_C2K_PRIORITY_URGENT = "Urgent"
CMAS_C2K_PRIORITY_EMERGENCY = "Emergency"

CMAS_C2K_RESPONSETYPE_SHELTER = "Shelter"
CMAS_C2K_RESPONSETYPE_EVACUATE = "Evacuate"
CMAS_C2K_RESPONSETYPE_PREPARE = "Prepare"
CMAS_C2K_RESPONSETYPE_EXECUTE = "Execute"
CMAS_C2K_RESPONSETYPE_MONITOR = "Monitor"
CMAS_C2K_RESPONSETYPE_AVOID = "Avoid"
CMAS_C2K_RESPONSETYPE_ASSESS = "Assess"
CMAS_C2K_RESPONSETYPE_NONE = "None"

CMAS_C2K_SEVERITY_EXTREME = "Extreme"
CMAS_C2K_SEVERITY_SEVERE = "Severe"

CMAS_C2K_URGENCY_IMMEDIATE = "Immediate"
CMAS_C2K_URGENCY_EXPECTED = "Expected"

CMAS_C2K_CERTIANTY_OBSERVED = "Observed"
CMAS_C2K_CERTIANTY_LIKELY = "Likely"

#PDN Numbers
PDN_NO_1 = 1
PDN_NO_2 = 2
PDN_NO_3 = 3
PDN_NO_4 = 4
PDN_NO_5 = 5

# IMS Services parameters
DEFAULT_VNID = 1
NDP_NIC_NAME = '"Intel(R) 82577LM Gigabit Network Connection"'
CSCF_Monitoring_UA_URI = '"sip:+11234567890@test.3gpp.com"'
TMO_CSCF_Monitoring_UA_URI = '"sip:001010123456789@msg.lab.t-mobile.com"'
CSCF_Virtual_UA_URI = '"sip:+11234567891@test.3gpp.com"'
TMO_CSCF_Virtual_UA_URI = '"sip:0123456789@ims.mnc01.mcc001.3gppnetwork.org"'
CSCF_HOSTNAME = '"ims.mnc01.mcc001.3gppnetwork.org"'
TMO_USERLIST_NAME = "310260123456789@msg.lab.t-mobile.com"
VZW_USERLIST_NAME = "001010123456789@test.3gpp.com"

# Google Fi IMS Services parameters
Fi_CSCF_Monitoring_UA_URI = '"sip:310260971239432@ims.mnc260.mcc310.3gppnetwork.org"'
Fi_CSCF_Virtual_UA_URI = '"sip:0123456789@msg.pc.t-mobile.com"'
Fi_CSCF_HOSTNAME = '"ims.mnc260.mcc310.3gppnetwork.org"'
Fi_USERLIST_NAME = "310260971239432@msg.pc.t-mobile.com"

#Cell Numbers
CELL_1 = 1
CELL_2 = 2

# default ims virtual network id for Anritsu ims call test.
DEFAULT_IMS_VIRTUAL_NETWORK_ID = 1

def cb_serial_number():
    """ CMAS/ETWS serial number generator """
    i = 0x3000
    while True:
        yield i
        i += 1


def set_usim_parameters(anritsu_handle, sim_card):
    """ set USIM parameters in MD8475A simulationn parameter

    Args:
        anritsu_handle: anritusu device object.
        sim_card : "P0250Ax" or "12349"

    Returns:
        None
    """
    if sim_card == P0250Ax:
        anritsu_handle.usim_key = "000102030405060708090A0B0C0D0E0F"
    elif sim_card == P0135Ax:
        anritsu_handle.usim_key = "00112233445566778899AABBCCDDEEFF"
    elif sim_card == VzW12349:
        anritsu_handle.usim_key = "465B5CE8B199B49FAA5F0A2EE238A6BC"
        anritsu_handle.send_command("IMSI 311480012345678")
        anritsu_handle.send_command("SECURITY3G MILENAGE")
        anritsu_handle.send_command(
            "MILENAGEOP 5F1D289C5D354D0A140C2548F5F3E3BA")
    elif sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        anritsu_handle.usim_key = "000102030405060708090A0B0C0D0E0F"


def save_anritsu_log_files(anritsu_handle, test_name, user_params):
    """ saves the anritsu smart studio log files
        The logs should be saved in Anritsu system. Need to provide
        log folder path in Anritsu system

    Args:
        anritsu_handle: anritusu device object.
        test_name: test case name
        user_params : user supplied parameters list

    Returns:
        None
    """
    md8475a_log_folder = user_params["anritsu_log_file_path"]
    file_name = getfilenamewithtimestamp(test_name)
    seq_logfile = "{}\\{}_seq.csv".format(md8475a_log_folder, file_name)
    msg_logfile = "{}\\{}_msg.csv".format(md8475a_log_folder, file_name)
    trace_logfile = "{}\\{}_trace.lgex".format(md8475a_log_folder, file_name)
    anritsu_handle.save_sequence_log(seq_logfile)
    anritsu_handle.save_message_log(msg_logfile)
    anritsu_handle.save_trace_log(trace_logfile, "BINARY", 1, 0, 0)
    anritsu_handle.clear_sequence_log()
    anritsu_handle.clear_message_log()


def getfilenamewithtimestamp(test_name):
    """ Gets the test name appended with current time

    Args:
        test_name : test case name

    Returns:
        string of test name appended with current time
    """
    time_stamp = datetime.now().strftime("%m-%d-%Y_%H-%M-%S")
    return "{}_{}".format(test_name, time_stamp)


def _init_lte_bts(bts, user_params, cell_no, sim_card):
    """ initializes the LTE BTS
        All BTS parameters should be set here

    Args:
        bts: BTS object.
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        None
    """
    bts.nw_fullname_enable = BtsNwNameEnable.NAME_ENABLE
    bts.nw_fullname = TEST_PLMN_LTE_NAME
    bts.mcc = get_lte_mcc(user_params, cell_no, sim_card)
    bts.mnc = get_lte_mnc(user_params, cell_no, sim_card)
    bts.band = get_lte_band(user_params, cell_no, sim_card)
    bts.transmode = get_transmission_mode(user_params, cell_no)
    bts.dl_antenna = get_dl_antenna(user_params, cell_no)
    bts.output_level = DEFAULT_OUTPUT_LEVEL
    bts.input_level = DEFAULT_INPUT_LEVEL


def _init_wcdma_bts(bts, user_params, cell_no, sim_card):
    """ initializes the WCDMA BTS
        All BTS parameters should be set here

    Args:
        bts: BTS object.
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        None
    """
    bts.nw_fullname_enable = BtsNwNameEnable.NAME_ENABLE
    bts.nw_fullname = TEST_PLMN_WCDMA_NAME
    bts.mcc = get_wcdma_mcc(user_params, cell_no, sim_card)
    bts.mnc = get_wcdma_mnc(user_params, cell_no, sim_card)
    bts.band = get_wcdma_band(user_params, cell_no)
    bts.rac = get_wcdma_rac(user_params, cell_no)
    bts.lac = get_wcdma_lac(user_params, cell_no)
    bts.output_level = DEFAULT_OUTPUT_LEVEL
    bts.input_level = DEFAULT_INPUT_LEVEL
    bts.packet_rate = DEFAULT_WCDMA_PACKET_RATE


def _init_gsm_bts(bts, user_params, cell_no, sim_card):
    """ initializes the GSM BTS
        All BTS parameters should be set here

    Args:
        bts: BTS object.
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        None
    """
    bts.nw_fullname_enable = BtsNwNameEnable.NAME_ENABLE
    bts.nw_fullname = TEST_PLMN_GSM_NAME
    bts.mcc = get_gsm_mcc(user_params, cell_no, sim_card)
    bts.mnc = get_gsm_mnc(user_params, cell_no, sim_card)
    bts.band = get_gsm_band(user_params, cell_no, sim_card)
    bts.rac = get_gsm_rac(user_params, cell_no)
    bts.lac = get_gsm_lac(user_params, cell_no)
    bts.output_level = DEFAULT_OUTPUT_LEVEL
    bts.input_level = DEFAULT_INPUT_LEVEL


def _init_1x_bts(bts, user_params, cell_no, sim_card):
    """ initializes the 1X BTS
        All BTS parameters should be set here

    Args:
        bts: BTS object.
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        None
    """
    bts.sector1_mcc = get_1x_mcc(user_params, cell_no, sim_card)
    bts.band = get_1x_band(user_params, cell_no, sim_card)
    bts.dl_channel = get_1x_channel(user_params, cell_no, sim_card)
    bts.sector1_sid = get_1x_sid(user_params, cell_no, sim_card)
    bts.sector1_nid = get_1x_nid(user_params, cell_no, sim_card)
    bts.output_level = DEFAULT_1X_OUTPUT_LEVEL


def _init_evdo_bts(bts, user_params, cell_no, sim_card):
    """ initializes the EVDO BTS
        All BTS parameters should be set here

    Args:
        bts: BTS object.
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        None
    """
    bts.band = get_evdo_band(user_params, cell_no, sim_card)
    bts.dl_channel = get_evdo_channel(user_params, cell_no, sim_card)
    bts.evdo_sid = get_evdo_sid(user_params, cell_no, sim_card)
    bts.output_level = DEFAULT_1X_OUTPUT_LEVEL


def _init_PDN(anritsu_handle,
              sim_card,
              pdn,
              ipv4,
              ipv6,
              ims_binding,
              vnid_number=DEFAULT_VNID):
    """ initializes the PDN parameters
        All PDN parameters should be set here

    Args:
        anritsu_handle: anritusu device object.
        pdn: pdn object
        ip_address : UE IP address
        ims_binding: to bind with IMS VNID(1) or not

    Returns:
        None
    """
    # Setting IP address for internet connection sharing
    # Google Fi _init_PDN
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        pdn.ue_address_ipv4 = ipv4
        pdn.ue_address_ipv6 = ipv6
        if ims_binding:
            pdn.pdn_ims = Switch.ENABLE
            pdn.pdn_vnid = vnid_number
            pdn.pdn_DG_selection = 'USER'
            pdn.pdn_gateway_ipv4addr = Fi_GATEWAY_IPV4_ADDR_IMS_911
            pdn.pdn_gateway_ipv6addr = Fi_GATEWAY_IPV6_ADDR_IMS_911

        else:
            anritsu_handle.gateway_ipv4addr = Fi_GATEWAY_IPV4_ADDR_Data
            anritsu_handle.gateway_ipv6addr = Fi_GATEWAY_IPV6_ADDR_Data
            pdn.primary_dns_address_ipv4 = Fi_DNS_IPV4_ADDR_Pri
            pdn.secondary_dns_address_ipv4 = Fi_DNS_IPV4_ADDR_Sec
            pdn.dns_address_ipv6 = Fi_DNS_IPV6_ADDR
            pdn.cscf_address_ipv4 = Fi_CSCF_IPV4_ADDR_Data
            pdn.cscf_address_ipv6 = Fi_CSCF_IPV6_ADDR_Data
    # Pixel Lab _init_PDN_
    else:
        anritsu_handle.gateway_ipv4addr = GATEWAY_IPV4_ADDR
        pdn.ue_address_ipv4 = ipv4
        pdn.ue_address_ipv6 = ipv6
        if ims_binding:
            pdn.pdn_ims = Switch.ENABLE
            pdn.pdn_vnid = vnid_number
        else:
            pdn.primary_dns_address_ipv4 = DNS_IPV4_ADDR
            pdn.secondary_dns_address_ipv4 = DNS_IPV4_ADDR
            pdn.cscf_address_ipv4 = CSCF_IPV4_ADDR


def _init_IMS(anritsu_handle,
              vnid,
              sim_card=None,
              ipv4_address=CSCF_IPV4_ADDR,
              ipv6_address=CSCF_IPV6_ADDR,
              ip_type="IPV4V6",
              auth=False):
    """ initializes the IMS VNID parameters
        All IMS parameters should be set here

    Args:
        anritsu_handle: anritusu device object.
        vnid: IMS Services object

    Returns:
        None
    """
    # vnid.sync = Switch.ENABLE # supported in 6.40a release
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        vnid.cscf_address_ipv4 = ipv4_address
        vnid.cscf_address_ipv6 = ipv6_address
        vnid.imscscf_iptype = ip_type
        vnid.dns = Switch.DISABLE
        vnid.ndp_nic = NDP_NIC_NAME
        vnid.ndp_prefix = ipv6_address
        if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
            vnid.cscf_monitoring_ua = Fi_CSCF_Monitoring_UA_URI
            vnid.cscf_virtual_ua = Fi_CSCF_Virtual_UA_URI
            vnid.cscf_host_name = Fi_CSCF_HOSTNAME
            vnid.cscf_ims_authentication = "ENABLE"
            if auth:
                vnid.cscf_ims_authentication = "ENABLE"
                vnid.fi_cscf_userslist_add = Fi_USERLIST_NAME
        else:
            vnid.cscf_monitoring_ua = CSCF_Monitoring_UA_URI
        vnid.psap = Switch.ENABLE
        vnid.psap_auto_answer = Switch.ENABLE
    else:
        vnid.cscf_address_ipv4 = CSCF_IPV4_ADDR
        vnid.cscf_address_ipv6 = ipv6_address
        vnid.imscscf_iptype = ip_type
        vnid.dns = Switch.DISABLE
        vnid.ndp_nic = NDP_NIC_NAME
        vnid.ndp_prefix = ipv6_address
        if sim_card == P0135Ax:
            vnid.cscf_monitoring_ua = TMO_CSCF_Monitoring_UA_URI
            vnid.cscf_virtual_ua = TMO_CSCF_Virtual_UA_URI
            vnid.cscf_host_name = CSCF_HOSTNAME
            vnid.cscf_precondition = "ENABLE"
            vnid.cscf_ims_authentication = "DISABLE"
            if auth:
                vnid.cscf_ims_authentication = "ENABLE"
                vnid.tmo_cscf_userslist_add = TMO_USERLIST_NAME
        elif sim_card == VzW12349:
            vnid.cscf_monitoring_ua = CSCF_Monitoring_UA_URI
            vnid.cscf_virtual_ua = CSCF_Virtual_UA_URI
            vnid.cscf_ims_authentication = "DISABLE"
            if auth:
                vnid.cscf_ims_authentication = "ENABLE"
                vnid.vzw_cscf_userslist_add = VZW_USERLIST_NAME
        else:
            vnid.cscf_monitoring_ua = CSCF_Monitoring_UA_URI
        vnid.psap = Switch.ENABLE
        vnid.psap_auto_answer = Switch.ENABLE


def set_system_model_lte_lte(anritsu_handle, user_params, sim_card):
    """ Configures Anritsu system for LTE and LTE simulation

    Args:
        anritsu_handle: anritusu device object.
        user_params: pointer to user supplied parameters

    Returns:
        Lte and Wcdma BTS objects
    """
    anritsu_handle.set_simulation_model(BtsTechnology.LTE,
                                        BtsTechnology.LTE)
    # setting BTS parameters
    lte1_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
    lte2_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
    _init_lte_bts(lte1_bts, user_params, CELL_1, sim_card)
    _init_lte_bts(lte2_bts, user_params, CELL_2, sim_card)
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
        pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
        pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
        pdn4 = anritsu_handle.get_PDN(PDN_NO_4)
        pdn5 = anritsu_handle.get_PDN(PDN_NO_5)

        # Initialize PDN IP address for internet connection sharing
        _init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS,
                  Fi_UE_IPV6_ADDR_IMS,
                  True)
        _init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911,
                  Fi_UE_IPV6_ADDR_911,
                  True)
        vnid1 = anritsu_handle.get_IMS(1)
        vnid2 = anritsu_handle.get_IMS(2)
        # _init_IMS(
        #     anritsu_handle,
        #     vnid1,
        #     sim_card,
        #     ipv4_address=CSCF_IPV4_ADDR,
        #     ipv6_address=CSCF_IPV6_ADDR,
        #     auth=False)
        _init_IMS(
            anritsu_handle,
            vnid1,
            sim_card,
            ipv4_address=Fi_CSCF_IPV4_ADDR_IMS,
            ipv6_address=Fi_CSCF_IPV6_ADDR_IMS,
            auth=True)
        _init_IMS(
            anritsu_handle,
            vnid2,
            sim_card,
            ipv4_address=Fi_CSCF_IPV4_ADDR_911,
            ipv6_address=Fi_CSCF_IPV6_ADDR_911,
            auth=False)
    else:
        _init_lte_bts(lte1_bts, user_params, CELL_1, sim_card)
        _init_lte_bts(lte2_bts, user_params, CELL_2, sim_card)
        pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
        pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
        pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
        # Initialize PDN IP address for internet connection sharing
        _init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
        _init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
        _init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
        vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
        if sim_card == P0135Ax:
            vnid2 = anritsu_handle.get_IMS(2)
            vnid3 = anritsu_handle.get_IMS(3)
            _init_IMS(
                anritsu_handle,
                vnid1,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR,
                auth=True)
            _init_IMS(
                anritsu_handle,
                vnid2,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR_2,
                ip_type="IPV6")
            _init_IMS(
                anritsu_handle,
                vnid3,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR_3,
                ip_type="IPV6")
        elif sim_card == VzW12349:
            _init_IMS(anritsu_handle, vnid1, sim_card, auth=True)
        else:
            _init_IMS(anritsu_handle, vnid1, sim_card)
        return [lte1_bts, lte2_bts]


def set_system_model_wcdma_wcdma(anritsu_handle, user_params, sim_card):
    """ Configures Anritsu system for WCDMA and WCDMA simulation

    Args:
        anritsu_handle: anritusu device object.
        user_params: pointer to user supplied parameters

    Returns:
        Lte and Wcdma BTS objects
    """
    anritsu_handle.set_simulation_model(BtsTechnology.WCDMA,
                                        BtsTechnology.WCDMA)
    # setting BTS parameters
    wcdma1_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
    wcdma2_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
    _init_wcdma_bts(wcdma1_bts, user_params, CELL_1, sim_card)
    _init_wcdma_bts(wcdma2_bts, user_params, CELL_2, sim_card)
    pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
    # Initialize PDN IP address for internet connection sharing
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        _init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data, Fi_UE_IPV6_ADDR_Data,
                  False)
    else:
        _init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
    return [wcdma1_bts, wcdma2_bts]


def set_system_model_lte_wcdma(anritsu_handle, user_params, sim_card):
    """ Configures Anritsu system for LTE and WCDMA simulation

    Args:
        anritsu_handle: anritusu device object.
        user_params: pointer to user supplied parameters

    Returns:
        Lte and Wcdma BTS objects
    """
    anritsu_handle.set_simulation_model(BtsTechnology.LTE, BtsTechnology.WCDMA)
    # setting BTS parameters
    lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
    wcdma_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
    _init_lte_bts(lte_bts, user_params, CELL_1, sim_card)
    _init_wcdma_bts(wcdma_bts, user_params, CELL_2, sim_card)
    pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
    pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
    pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
    # Initialize PDN IP address for internet connection sharing
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
        pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
        pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
        pdn4 = anritsu_handle.get_PDN(PDN_NO_4)
        pdn5 = anritsu_handle.get_PDN(PDN_NO_5)
        # Initialize PDN IP address.
        _init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS,
                  Fi_UE_IPV6_ADDR_IMS,
                  True)
        _init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911,
                  Fi_UE_IPV6_ADDR_911,
                  True)
        vnid1 = anritsu_handle.get_IMS(1)
        vnid2 = anritsu_handle.get_IMS(2)
        _init_IMS(
            anritsu_handle,
            vnid1,
            sim_card,
            ipv4_address=Fi_CSCF_IPV4_ADDR_IMS,
            ipv6_address=Fi_CSCF_IPV6_ADDR_IMS,
            auth=True)
        _init_IMS(
            anritsu_handle,
            vnid2,
            sim_card,
            ipv4_address=Fi_CSCF_IPV4_ADDR_911,
            ipv6_address=Fi_CSCF_IPV6_ADDR_911,
            auth=False)
        return [lte_bts, wcdma_bts]
    else:
        _init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
        _init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
        _init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
        vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
        if sim_card == P0135Ax:
            vnid2 = anritsu_handle.get_IMS(2)
            vnid3 = anritsu_handle.get_IMS(3)
            _init_IMS(
                anritsu_handle,
                vnid1,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR,
                auth=True)
            _init_IMS(
                anritsu_handle,
                vnid2,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR_2,
                ip_type="IPV6")
            _init_IMS(
                anritsu_handle,
                vnid3,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR_3,
                ip_type="IPV6")
        elif sim_card == VzW12349:
            _init_IMS(anritsu_handle, vnid1, sim_card, auth=True)
        else:
            _init_IMS(anritsu_handle, vnid1, sim_card)
    return [lte_bts, wcdma_bts]


def set_system_model_lte_gsm(anritsu_handle, user_params, sim_card):
    """ Configures Anritsu system for LTE and GSM simulation

    Args:
        anritsu_handle: anritusu device object.
        user_params: pointer to user supplied parameters

    Returns:
        Lte and Wcdma BTS objects
    """
    anritsu_handle.set_simulation_model(BtsTechnology.LTE, BtsTechnology.GSM)
    # setting BTS parameters
    lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
    gsm_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
    _init_lte_bts(lte_bts, user_params, CELL_1, sim_card)
    _init_gsm_bts(gsm_bts, user_params, CELL_2, sim_card)
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
        pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
        pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
        pdn4 = anritsu_handle.get_PDN(PDN_NO_4)
        pdn5 = anritsu_handle.get_PDN(PDN_NO_5)
        # Initialize PDN IP address.
        _init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS,
                  Fi_UE_IPV6_ADDR_IMS,
                  True)
        _init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911,
                  Fi_UE_IPV6_ADDR_911,
                  True)
        vnid1 = anritsu_handle.get_IMS(1)
        vnid2 = anritsu_handle.get_IMS(2)
        _init_IMS(
            anritsu_handle,
            vnid1,
            sim_card,
            ipv4_address=Fi_CSCF_IPV4_ADDR_IMS,
            ipv6_address=Fi_CSCF_IPV6_ADDR_IMS,
            auth=True)
        _init_IMS(
            anritsu_handle,
            vnid2,
            sim_card,
            ipv4_address=Fi_CSCF_IPV4_ADDR_911,
            ipv6_address=Fi_CSCF_IPV6_ADDR_911,
            auth=False)
        return [lte_bts, gsm_bts]
    else:
        pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
        pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
        pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
        # Initialize PDN IP address for internet connection sharing
        _init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
        _init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
        _init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
        vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
        if sim_card == P0135Ax:
            vnid2 = anritsu_handle.get_IMS(2)
            vnid3 = anritsu_handle.get_IMS(3)
            _init_IMS(
                anritsu_handle,
                vnid1,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR,
                auth=True)
            _init_IMS(
                anritsu_handle,
                vnid2,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR_2,
                ip_type="IPV6")
            _init_IMS(
                anritsu_handle,
                vnid3,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR_3,
                ip_type="IPV6")
        elif sim_card == VzW12349:
            _init_IMS(anritsu_handle, vnid1, sim_card, auth=True)
        else:
            _init_IMS(anritsu_handle, vnid1, sim_card)
    return [lte_bts, gsm_bts]


def set_system_model_lte_1x(anritsu_handle, user_params, sim_card):
    """ Configures Anritsu system for LTE and 1x simulation

    Args:
        anritsu_handle: anritusu device object.
        user_params: pointer to user supplied parameters

    Returns:
        Lte and 1x BTS objects
    """
    anritsu_handle.set_simulation_model(BtsTechnology.LTE,
                                        BtsTechnology.CDMA1X)
    # setting BTS parameters
    lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
    cdma1x_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
    _init_lte_bts(lte_bts, user_params, CELL_1, sim_card)
    _init_1x_bts(cdma1x_bts, user_params, CELL_2, sim_card)
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
        pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
        pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
        pdn4 = anritsu_handle.get_PDN(PDN_NO_4)
        pdn5 = anritsu_handle.get_PDN(PDN_NO_5)
        # Initialize PDN IP address.
        _init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS,
                  Fi_UE_IPV6_ADDR_IMS,
                  True)
        _init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911,
                  Fi_UE_IPV6_ADDR_911,
                  True)
        vnid1 = anritsu_handle.get_IMS(1)
        vnid2 = anritsu_handle.get_IMS(2)
        _init_IMS(
            anritsu_handle,
            vnid1,
            sim_card,
            ipv4_address=Fi_CSCF_IPV4_ADDR_IMS,
            ipv6_address=Fi_CSCF_IPV6_ADDR_IMS,
            auth=True)
        _init_IMS(
            anritsu_handle,
            vnid2,
            sim_card,
            ipv4_address=Fi_CSCF_IPV4_ADDR_911,
            ipv6_address=Fi_CSCF_IPV6_ADDR_911,
            auth=False)
        return [lte_bts, cdma1x_bts]
    else:
        pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
        pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
        pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
        # Initialize PDN IP address for internet connection sharing
        _init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
        _init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
        _init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
        vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
        if sim_card == P0135Ax:
            vnid2 = anritsu_handle.get_IMS(2)
            vnid3 = anritsu_handle.get_IMS(3)
            _init_IMS(
                anritsu_handle,
                vnid1,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR,
                auth=True)
            _init_IMS(
                anritsu_handle,
                vnid2,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR_2,
                ip_type="IPV6")
            _init_IMS(
                anritsu_handle,
                vnid3,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR_3,
                ip_type="IPV6")
        elif sim_card == VzW12349:
            _init_IMS(anritsu_handle, vnid1, sim_card, auth=True)
        else:
            _init_IMS(anritsu_handle, vnid1, sim_card)
    return [lte_bts, cdma1x_bts]


def set_system_model_lte_evdo(anritsu_handle, user_params, sim_card):
    """ Configures Anritsu system for LTE and EVDO simulation

    Args:
        anritsu_handle: anritusu device object.
        user_params: pointer to user supplied parameters

    Returns:
        Lte and 1x BTS objects
    """
    anritsu_handle.set_simulation_model(BtsTechnology.LTE, BtsTechnology.EVDO)
    # setting BTS parameters
    lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
    evdo_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
    _init_lte_bts(lte_bts, user_params, CELL_1, sim_card)
    _init_evdo_bts(evdo_bts, user_params, CELL_2, sim_card)
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
        pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
        pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
        pdn4 = anritsu_handle.get_PDN(PDN_NO_4)
        pdn5 = anritsu_handle.get_PDN(PDN_NO_5)
        # Initialize PDN IP address.
        _init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn2, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn3, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS,
                  Fi_UE_IPV6_ADDR_IMS,
                  True)
        _init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911,
                  Fi_UE_IPV6_ADDR_911,
                  True)
        vnid1 = anritsu_handle.get_IMS(1)
        vnid2 = anritsu_handle.get_IMS(2)
        _init_IMS(
            anritsu_handle,
            vnid1,
            sim_card,
            ipv4_address=Fi_CSCF_IPV4_ADDR_IMS,
            ipv6_address=Fi_CSCF_IPV6_ADDR_IMS,
            auth=True)
        _init_IMS(
            anritsu_handle,
            vnid2,
            sim_card,
            ipv4_address=Fi_CSCF_IPV4_ADDR_911,
            ipv6_address=Fi_CSCF_IPV6_ADDR_911,
            auth=False)
        return [lte_bts, evdo_bts]
    else:
        pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
        pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
        pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
        # Initialize PDN IP address for internet connection sharing
        _init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
        _init_PDN(anritsu_handle, sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
        _init_PDN(anritsu_handle, sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
        vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
        if sim_card == P0135Ax:
            vnid2 = anritsu_handle.get_IMS(2)
            vnid3 = anritsu_handle.get_IMS(3)
            _init_IMS(
                anritsu_handle,
                vnid1,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR,
                auth=True)
            _init_IMS(
                anritsu_handle,
                vnid2,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR_2,
                ip_type="IPV6")
            _init_IMS(
                anritsu_handle,
                vnid3,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR_3,
                ip_type="IPV6")
        elif sim_card == VzW12349:
            _init_IMS(anritsu_handle, vnid1, sim_card, auth=True)
        else:
            _init_IMS(anritsu_handle, vnid1, sim_card)
    return [lte_bts, evdo_bts]


def set_system_model_wcdma_gsm(anritsu_handle, user_params, sim_card):
    """ Configures Anritsu system for WCDMA and GSM simulation

    Args:
        anritsu_handle: anritusu device object.
        user_params: pointer to user supplied parameters

    Returns:
        Wcdma and Gsm BTS objects
    """
    anritsu_handle.set_simulation_model(BtsTechnology.WCDMA, BtsTechnology.GSM)
    # setting BTS parameters
    wcdma_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
    gsm_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
    _init_wcdma_bts(wcdma_bts, user_params, CELL_1, sim_card)
    _init_gsm_bts(gsm_bts, user_params, CELL_2, sim_card)
    pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
    # Initialize PDN IP address for internet connection sharing
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        _init_PDN(anritsu_handle, sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
    else:
        _init_PDN(anritsu_handle, sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
    return [wcdma_bts, gsm_bts]


def set_system_model_gsm_gsm(anritsu_handle, user_params, sim_card):
    """ Configures Anritsu system for GSM and GSM simulation

    Args:
        anritsu_handle: anritusu device object.
        user_params: pointer to user supplied parameters

    Returns:
        Wcdma and Gsm BTS objects
    """
    anritsu_handle.set_simulation_model(BtsTechnology.GSM, BtsTechnology.GSM)
    # setting BTS parameters
    gsm1_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
    gsm2_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
    _init_gsm_bts(gsm1_bts, user_params, CELL_1, sim_card)
    _init_gsm_bts(gsm2_bts, user_params, CELL_2, sim_card)
    pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
    # Initialize PDN IP address for internet connection sharing
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        _init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
    else:
        _init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
    return [gsm1_bts, gsm2_bts]


def set_system_model_lte(anritsu_handle, user_params, sim_card):
    """ Configures Anritsu system for LTE simulation

    Args:
        anritsu_handle: anritusu device object.
        user_params: pointer to user supplied parameters

    Returns:
        Lte BTS object
    """
    anritsu_handle.set_simulation_model(BtsTechnology.LTE)
    # setting Fi BTS parameters
    lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
    _init_lte_bts(lte_bts, user_params, CELL_1, sim_card)

    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
        pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
        pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
        pdn4 = anritsu_handle.get_PDN(PDN_NO_4)
        pdn5 = anritsu_handle.get_PDN(PDN_NO_5)
    # Initialize PDN IP address.
        _init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle,sim_card, pdn2, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle,sim_card, pdn3, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
        _init_PDN(anritsu_handle, sim_card, pdn4, Fi_UE_IPV4_ADDR_IMS,
                  Fi_UE_IPV6_ADDR_IMS,
                  True)
        _init_PDN(anritsu_handle, sim_card, pdn5, Fi_UE_IPV4_ADDR_911,
                  Fi_UE_IPV6_ADDR_911,
                  True)
        vnid1 = anritsu_handle.get_IMS(1)
        vnid2 = anritsu_handle.get_IMS(2)
        _init_IMS(
            anritsu_handle,
            vnid1,
            sim_card,
            ipv4_address=Fi_CSCF_IPV4_ADDR_IMS,
            ipv6_address=Fi_CSCF_IPV6_ADDR_IMS,
            auth=True)
        _init_IMS(
            anritsu_handle,
            vnid2,
            sim_card,
            ipv4_address=Fi_CSCF_IPV4_ADDR_911,
            ipv6_address=Fi_CSCF_IPV6_ADDR_911,
            auth=False)
        return [lte_bts]
    else:
        # setting BTS parameters
        pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
        pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
        pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
        # Initialize PDN IP address for internet connection sharing
        _init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
        _init_PDN(anritsu_handle,sim_card, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
        _init_PDN(anritsu_handle,sim_card, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
        vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
        if sim_card == P0135Ax:
            vnid2 = anritsu_handle.get_IMS(2)
            vnid3 = anritsu_handle.get_IMS(3)
            _init_IMS(
                anritsu_handle,
                vnid1,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR,
                auth=True)
            _init_IMS(
                anritsu_handle,
                vnid2,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR_2,
                ip_type="IPV6")
            _init_IMS(
                anritsu_handle,
                vnid3,
                sim_card,
                ipv6_address=CSCF_IPV6_ADDR_3,
                ip_type="IPV6")
        elif sim_card == VzW12349:
            _init_IMS(anritsu_handle, vnid1, sim_card, auth=True)
        else:
            _init_IMS(anritsu_handle, vnid1, sim_card)
        return [lte_bts]


def set_system_model_wcdma(anritsu_handle, user_params, sim_card):
    """ Configures Anritsu system for WCDMA simulation

    Args:
        anritsu_handle: anritusu device object.
        user_params: pointer to user supplied parameters

    Returns:
        Wcdma BTS object
    """
    anritsu_handle.set_simulation_model(BtsTechnology.WCDMA)
    # setting BTS parameters
    wcdma_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
    _init_wcdma_bts(wcdma_bts, user_params, CELL_1, sim_card)
    pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
    # Initialize PDN IP address for internet connection sharing
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        _init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
    else:
        _init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
    return [wcdma_bts]


def set_system_model_gsm(anritsu_handle, user_params, sim_card):
    """ Configures Anritsu system for GSM simulation

    Args:
        anritsu_handle: anritusu device object.
        user_params: pointer to user supplied parameters

    Returns:
        Gsm BTS object
    """
    anritsu_handle.set_simulation_model(BtsTechnology.GSM)
    # setting BTS parameters
    gsm_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
    _init_gsm_bts(gsm_bts, user_params, CELL_1, sim_card)
    pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
    # Initialize PDN IP address for internet connection sharing
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        _init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
    else:
        _init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
    return [gsm_bts]


def set_system_model_1x(anritsu_handle, user_params, sim_card):
    """ Configures Anritsu system for CDMA 1X simulation

    Args:
        anritsu_handle: anritusu device object.
        user_params: pointer to user supplied parameters

    Returns:
        Cdma 1x BTS object
    """
    PDN_ONE = 1
    anritsu_handle.set_simulation_model(BtsTechnology.CDMA1X)
    # setting BTS parameters
    cdma1x_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
    _init_1x_bts(cdma1x_bts, user_params, CELL_1, sim_card)
    pdn1 = anritsu_handle.get_PDN(PDN_ONE)
    # Initialize PDN IP address for internet connection sharing
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        _init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
    else:
        _init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
    return [cdma1x_bts]


def set_system_model_1x_evdo(anritsu_handle, user_params, sim_card):
    """ Configures Anritsu system for CDMA 1X simulation

    Args:
        anritsu_handle: anritusu device object.
        user_params: pointer to user supplied parameters

    Returns:
        Cdma 1x BTS object
    """
    PDN_ONE = 1
    anritsu_handle.set_simulation_model(BtsTechnology.CDMA1X,
                                        BtsTechnology.EVDO)
    # setting BTS parameters
    cdma1x_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
    evdo_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
    _init_1x_bts(cdma1x_bts, user_params, CELL_1, sim_card)
    _init_evdo_bts(evdo_bts, user_params, CELL_2, sim_card)
    pdn1 = anritsu_handle.get_PDN(PDN_ONE)
    # Initialize PDN IP address for internet connection sharing
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        _init_PDN(anritsu_handle,sim_card, pdn1, Fi_UE_IPV4_ADDR_Data,
                  Fi_UE_IPV6_ADDR_Data, False)
    else:
        _init_PDN(anritsu_handle,sim_card, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
    return [cdma1x_bts]


def wait_for_bts_state(log, btsnumber, state, timeout=30):
    """ Waits for BTS to be in the specified state ("IN" or "OUT")

    Args:
        btsnumber: BTS number.
        state: expected state

    Returns:
        True for success False for failure
    """
    #  state value are "IN" and "OUT"
    status = False
    sleep_interval = 1
    wait_time = timeout

    if state == "IN":
        service_state = BtsServiceState.SERVICE_STATE_IN
    elif state == "OUT":
        service_state = BtsServiceState.SERVICE_STATE_OUT
    else:
        log.info("wrong state value")
        return status

    if btsnumber.service_state is service_state:
        log.info("BTS state is already in {}".format(state))
        return True

    # set to desired service state
    btsnumber.service_state = service_state

    while wait_time > 0:
        if service_state == btsnumber.service_state:
            status = True
            break
        time.sleep(sleep_interval)
        wait_time = wait_time - sleep_interval

    if not status:
        log.info("Timeout: Expected BTS state is not received.")
    return status


class _CallSequenceException(Exception):
    pass


def call_mo_setup_teardown(
        log,
        ad,
        anritsu_handle,
        callee_number,
        teardown_side=CALL_TEARDOWN_PHONE,
        is_emergency=False,
        wait_time_in_call=WAIT_TIME_IN_CALL_LONG,
        is_ims_call=False,
        ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID):
    """ Makes a MO call and tear down the call

    Args:
        ad: Android device object.
        anritsu_handle: Anritsu object.
        callee_number: Number to be called.
        teardown_side: the side to end the call (Phone or remote).
        is_emergency: is the call an emergency call.
        wait_time_in_call: Time to wait when phone in call.
        is_ims_call: is the call expected to be ims call.
        ims_virtual_network_id: ims virtual network id.

    Returns:
        True for success False for failure
    """

    log.info("Making Call to " + callee_number)
    virtual_phone_handle = anritsu_handle.get_VirtualPhone()

    try:
        # for an IMS call we either check CSCF or *nothing* (no virtual phone).
        if is_ims_call:
            # we only need pre-call registration in a non-emergency case
            if not is_emergency:
                if not wait_for_ims_cscf_status(log, anritsu_handle,
                                                ims_virtual_network_id,
                                                ImsCscfStatus.SIPIDLE.value):
                    raise _CallSequenceException(
                        "Phone IMS status is not idle.")
        else:
            if not wait_for_virtualphone_state(log, virtual_phone_handle,
                                               VirtualPhoneStatus.STATUS_IDLE):
                raise _CallSequenceException("Virtual Phone not idle.")

        if not initiate_call(log, ad, callee_number, is_emergency):
            raise _CallSequenceException("Initiate call failed.")

        if is_ims_call:
            if not wait_for_ims_cscf_status(log, anritsu_handle,
                                            ims_virtual_network_id,
                                            ImsCscfStatus.CALLING.value):
                raise _CallSequenceException(
                    "Phone IMS status is not calling.")
            if not wait_for_ims_cscf_status(log, anritsu_handle,
                                            ims_virtual_network_id,
                                            ImsCscfStatus.CONNECTED.value):
                raise _CallSequenceException(
                    "Phone IMS status is not connected.")
        else:
            # check Virtual phone answered the call
            if not wait_for_virtualphone_state(
                    log, virtual_phone_handle,
                    VirtualPhoneStatus.STATUS_VOICECALL_INPROGRESS):
                raise _CallSequenceException("Virtual Phone not in call.")

        time.sleep(wait_time_in_call)

        if not ad.droid.telecomIsInCall():
            raise _CallSequenceException("Call ended before delay_in_call.")

        if teardown_side is CALL_TEARDOWN_REMOTE:
            log.info("Disconnecting the call from Remote")
            if is_ims_call:
                anritsu_handle.ims_cscf_call_action(ims_virtual_network_id,
                                                    ImsCscfCall.END.value)
            else:
                virtual_phone_handle.set_voice_on_hook()
            if not wait_for_droid_not_in_call(log, ad,
                                              MAX_WAIT_TIME_CALL_DROP):
                raise _CallSequenceException("DUT call not drop.")
        else:
            log.info("Disconnecting the call from DUT")
            if not hangup_call(log, ad, is_emergency):
                raise _CallSequenceException(
                    "Error in Hanging-Up Call on DUT.")

        if is_ims_call:
            if not wait_for_ims_cscf_status(log, anritsu_handle,
                                            ims_virtual_network_id,
                                            ImsCscfStatus.SIPIDLE.value):
                raise _CallSequenceException("Phone IMS status is not idle.")
        else:
            if not wait_for_virtualphone_state(log, virtual_phone_handle,
                                               VirtualPhoneStatus.STATUS_IDLE):
                raise _CallSequenceException(
                    "Virtual Phone not idle after hangup.")
        return True

    except _CallSequenceException as e:
        log.error(e)
        return False
    finally:
        try:
            if ad.droid.telecomIsInCall():
                ad.droid.telecomEndCall()
        except Exception as e:
            log.error(str(e))


def handover_tc(log,
                anritsu_handle,
                wait_time=0,
                s_bts=BtsNumber.BTS1,
                t_bts=BtsNumber.BTS2,
                timeout=60):
    """ Setup and perform a handover test case in MD8475A

    Args:
        anritsu_handle: Anritsu object.
        s_bts: Serving (originating) BTS
        t_bts: Target (destination) BTS
        wait_time: time to wait before handover

    Returns:
        True for success False for failure
    """
    log.info("Starting HO test case procedure")
    log.info("Serving BTS = {}, Target BTS = {}".format(s_bts, t_bts))
    time.sleep(wait_time)
    ho_tc = anritsu_handle.get_AnritsuTestCases()
    ho_tc.procedure = TestProcedure.PROCEDURE_HO
    ho_tc.bts_direction = (s_bts, t_bts)
    ho_tc.power_control = TestPowerControl.POWER_CONTROL_DISABLE
    ho_tc.measurement_LTE = TestMeasurement.MEASUREMENT_DISABLE
    anritsu_handle.start_testcase()
    status = anritsu_handle.get_testcase_status()
    timer = 0
    while status == "0":
        time.sleep(1)
        status = anritsu_handle.get_testcase_status()
        timer += 1
        if timer > timeout:
            return "Handover Test Case time out in {} sec!".format(timeout)
    return status


def make_ims_call(log,
                  ad,
                  anritsu_handle,
                  callee_number,
                  is_emergency=False,
                  check_ims_reg=True,
                  check_ims_calling=True,
                  mo=True,
                  ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID):
    """ Makes a MO call after IMS registred

    Args:
        ad: Android device object.
        anritsu_handle: Anritsu object.
        callee_number: Number to be called.
        check_ims_reg: check if Anritsu cscf server state is "SIPIDLE".
        check_ims_calling: check if Anritsu cscf server state is "CALLING".
        mo: Mobile originated call
        ims_virtual_network_id: ims virtual network id.

    Returns:
        True for success False for failure
    """

    try:
        # confirm ims registration
        if check_ims_reg:
            if not wait_for_ims_cscf_status(log, anritsu_handle,
                                            ims_virtual_network_id,
                                            ImsCscfStatus.SIPIDLE.value):
                raise _CallSequenceException("IMS/CSCF status is not idle.")
        if mo:  # make MO call
            log.info("Making Call to " + callee_number)
            if not initiate_call(log, ad, callee_number, is_emergency):
                raise _CallSequenceException("Initiate call failed.")
            if not wait_for_ims_cscf_status(log, anritsu_handle,
                                            ims_virtual_network_id,
                                            ImsCscfStatus.CALLING.value):
                raise _CallSequenceException(
                    "Phone IMS status is not calling.")
        else:  # make MT call
            log.info("Making IMS Call to UE from MD8475A...")
            anritsu_handle.ims_cscf_call_action(ims_virtual_network_id,
                                                ImsCscfCall.MAKE.value)
            if not wait_for_ims_cscf_status(log, anritsu_handle,
                                            ims_virtual_network_id,
                                            ImsCscfStatus.RINGING.value):
                raise _CallSequenceException(
                    "Phone IMS status is not ringing.")
            # answer the call on the UE
            if not wait_and_answer_call(log, ad):
                raise _CallSequenceException("UE Answer call Fail")

        if not wait_for_ims_cscf_status(log, anritsu_handle,
                                        ims_virtual_network_id,
                                        ImsCscfStatus.CONNECTED.value):
            raise _CallSequenceException(
                "MD8475A IMS status is not connected.")
        return True

    except _CallSequenceException as e:
        log.error(e)
        return False


def tear_down_call(log,
                   ad,
                   anritsu_handle,
                   ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID):
    """ Check and End a VoLTE call

    Args:
        ad: Android device object.
        anritsu_handle: Anritsu object.
        ims_virtual_network_id: ims virtual network id.

    Returns:
        True for success False for failure
    """
    try:
        # end the call from phone
        log.info("Disconnecting the call from DUT")
        if not hangup_call(log, ad):
            raise _CallSequenceException("Error in Hanging-Up Call on DUT.")
        # confirm if CSCF status is back to idle
        if not wait_for_ims_cscf_status(log, anritsu_handle,
                                        ims_virtual_network_id,
                                        ImsCscfStatus.SIPIDLE.value):
            raise _CallSequenceException("IMS/CSCF status is not idle.")
        return True

    except _CallSequenceException as e:
        log.error(e)
        return False
    finally:
        try:
            if ad.droid.telecomIsInCall():
                ad.droid.telecomEndCall()
        except Exception as e:
            log.error(str(e))


# This procedure is for VoLTE mobility test cases
def ims_call_ho(log,
                ad,
                anritsu_handle,
                callee_number,
                is_emergency=False,
                check_ims_reg=True,
                check_ims_calling=True,
                mo=True,
                wait_time_in_volte=WAIT_TIME_IN_CALL_FOR_IMS,
                ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID):
    """ Makes a MO call after IMS registred, then handover

    Args:
        ad: Android device object.
        anritsu_handle: Anritsu object.
        callee_number: Number to be called.
        check_ims_reg: check if Anritsu cscf server state is "SIPIDLE".
        check_ims_calling: check if Anritsu cscf server state is "CALLING".
        mo: Mobile originated call
        wait_time_in_volte: Time for phone in VoLTE call, not used for SRLTE
        ims_virtual_network_id: ims virtual network id.

    Returns:
        True for success False for failure
    """

    try:
        # confirm ims registration
        if check_ims_reg:
            if not wait_for_ims_cscf_status(log, anritsu_handle,
                                            ims_virtual_network_id,
                                            ImsCscfStatus.SIPIDLE.value):
                raise _CallSequenceException("IMS/CSCF status is not idle.")
        if mo:  # make MO call
            log.info("Making Call to " + callee_number)
            if not initiate_call(log, ad, callee_number, is_emergency):
                raise _CallSequenceException("Initiate call failed.")
            if not wait_for_ims_cscf_status(log, anritsu_handle,
                                            ims_virtual_network_id,
                                            ImsCscfStatus.CALLING.value):
                raise _CallSequenceException(
                    "Phone IMS status is not calling.")
        else:  # make MT call
            log.info("Making IMS Call to UE from MD8475A...")
            anritsu_handle.ims_cscf_call_action(ims_virtual_network_id,
                                                ImsCscfCall.MAKE.value)
            if not wait_for_ims_cscf_status(log, anritsu_handle,
                                            ims_virtual_network_id,
                                            ImsCscfStatus.RINGING.value):
                raise _CallSequenceException(
                    "Phone IMS status is not ringing.")
            # answer the call on the UE
            if not wait_and_answer_call(log, ad):
                raise _CallSequenceException("UE Answer call Fail")

        if not wait_for_ims_cscf_status(log, anritsu_handle,
                                        ims_virtual_network_id,
                                        ImsCscfStatus.CONNECTED.value):
            raise _CallSequenceException("Phone IMS status is not connected.")
        log.info(
            "Wait for {} seconds before handover".format(wait_time_in_volte))
        time.sleep(wait_time_in_volte)

        # Once VoLTE call is connected, then Handover
        log.info("Starting handover procedure...")
        result = handover_tc(anritsu_handle, BtsNumber.BTS1, BtsNumber.BTS2)
        log.info("Handover procedure ends with result code {}".format(result))
        log.info(
            "Wait for {} seconds after handover".format(wait_time_in_volte))
        time.sleep(wait_time_in_volte)

        # check if the phone stay in call
        if not ad.droid.telecomIsInCall():
            raise _CallSequenceException("Call ended before delay_in_call.")
        # end the call from phone
        log.info("Disconnecting the call from DUT")
        if not hangup_call(log, ad, is_emergency):
            raise _CallSequenceException("Error in Hanging-Up Call on DUT.")
        # confirm if CSCF status is back to idle
        if not wait_for_ims_cscf_status(log, anritsu_handle,
                                        ims_virtual_network_id,
                                        ImsCscfStatus.SIPIDLE.value):
            raise _CallSequenceException("IMS/CSCF status is not idle.")

        return True

    except _CallSequenceException as e:
        log.error(e)
        return False
    finally:
        try:
            if ad.droid.telecomIsInCall():
                ad.droid.telecomEndCall()
        except Exception as e:
            log.error(str(e))


# This procedure is for SRLTE CSFB and SRVCC test cases
def ims_call_cs_teardown(
        log,
        ad,
        anritsu_handle,
        callee_number,
        teardown_side=CALL_TEARDOWN_PHONE,
        is_emergency=False,
        check_ims_reg=True,
        check_ims_calling=True,
        srvcc=None,
        mo=True,
        wait_time_in_volte=WAIT_TIME_IN_CALL_FOR_IMS,
        wait_time_in_cs=WAIT_TIME_IN_CALL,
        wait_time_in_alert=WAIT_TIME_IN_ALERT,
        ims_virtual_network_id=DEFAULT_IMS_VIRTUAL_NETWORK_ID):
    """ Makes a MO call after IMS registred, transit to CS, tear down the call

    Args:
        ad: Android device object.
        anritsu_handle: Anritsu object.
        callee_number: Number to be called.
        teardown_side: the side to end the call (Phone or remote).
        is_emergency: to make emergency call on the phone.
        check_ims_reg: check if Anritsu cscf server state is "SIPIDLE".
        check_ims_calling: check if Anritsu cscf server state is "CALLING".
        srvcc: is the test case a SRVCC call.
        mo: Mobile originated call
        wait_time_in_volte: Time for phone in VoLTE call, not used for SRLTE
        wait_time_in_cs: Time for phone in CS call.
        ims_virtual_network_id: ims virtual network id.

    Returns:
        True for success False for failure
    """

    virtual_phone_handle = anritsu_handle.get_VirtualPhone()

    try:
        # confirm ims registration
        if check_ims_reg:
            if not wait_for_ims_cscf_status(log, anritsu_handle,
                                            ims_virtual_network_id,
                                            ImsCscfStatus.SIPIDLE.value):
                raise _CallSequenceException("IMS/CSCF status is not idle.")
        # confirm virtual phone in idle
        if not wait_for_virtualphone_state(log, virtual_phone_handle,
                                           VirtualPhoneStatus.STATUS_IDLE):
            raise _CallSequenceException("Virtual Phone not idle.")
        if mo:  # make MO call
            log.info("Making Call to " + callee_number)
            if not initiate_call(log, ad, callee_number, is_emergency):
                raise _CallSequenceException("Initiate call failed.")
        else:  # make MT call
            log.info("Making IMS Call to UE from MD8475A...")
            anritsu_handle.ims_cscf_call_action(ims_virtual_network_id,
                                                ImsCscfCall.MAKE.value)
        # if check ims calling is required
        if check_ims_calling:
            if mo:
                if not wait_for_ims_cscf_status(log, anritsu_handle,
                                                ims_virtual_network_id,
                                                ImsCscfStatus.CALLING.value):
                    raise _CallSequenceException(
                        "Phone IMS status is not calling.")
            else:
                if not wait_for_ims_cscf_status(log, anritsu_handle,
                                                ims_virtual_network_id,
                                                ImsCscfStatus.RINGING.value):
                    raise _CallSequenceException(
                        "Phone IMS status is not ringing.")

            # if SRVCC, check if VoLTE call is connected, then Handover
            if srvcc != None:
                if srvcc == "InCall":
                    if not wait_for_ims_cscf_status(
                            log, anritsu_handle, ims_virtual_network_id,
                            ImsCscfStatus.CONNECTED.value):
                        raise _CallSequenceException(
                            "Phone IMS status is not connected.")
                    # stay in call for "wait_time_in_volte" seconds
                    time.sleep(wait_time_in_volte)
                elif srvcc == "Alert":
                    # ring for WAIT_TIME_IN_ALERT seconds
                    time.sleep(WAIT_TIME_IN_ALERT)
                # SRVCC by handover test case procedure
                srvcc_tc = anritsu_handle.get_AnritsuTestCases()
                srvcc_tc.procedure = TestProcedure.PROCEDURE_HO
                srvcc_tc.bts_direction = (BtsNumber.BTS1, BtsNumber.BTS2)
                srvcc_tc.power_control = TestPowerControl.POWER_CONTROL_DISABLE
                srvcc_tc.measurement_LTE = TestMeasurement.MEASUREMENT_DISABLE
                anritsu_handle.start_testcase()
                time.sleep(5)
        if not mo:
            # answer the call on the UE
            if not wait_and_answer_call(log, ad):
                raise _CallSequenceException("UE Answer call Fail")
        # check if Virtual phone in the call
        if not wait_for_virtualphone_state(
                log, virtual_phone_handle,
                VirtualPhoneStatus.STATUS_VOICECALL_INPROGRESS):
            raise _CallSequenceException("Virtual Phone not in call.")
        # stay in call for "wait_time_in_cs" seconds
        time.sleep(wait_time_in_cs)
        # check if the phone stay in call
        if not ad.droid.telecomIsInCall():
            raise _CallSequenceException("Call ended before delay_in_call.")
        # end the call
        if teardown_side is CALL_TEARDOWN_REMOTE:
            log.info("Disconnecting the call from Remote")
            virtual_phone_handle.set_voice_on_hook()
            if not wait_for_droid_not_in_call(log, ad,
                                              MAX_WAIT_TIME_CALL_DROP):
                raise _CallSequenceException("DUT call not drop.")
        else:
            log.info("Disconnecting the call from DUT")
            if not hangup_call(log, ad, is_emergency):
                raise _CallSequenceException(
                    "Error in Hanging-Up Call on DUT.")
        # confirm if virtual phone status is back to idle
        if not wait_for_virtualphone_state(log, virtual_phone_handle,
                                           VirtualPhoneStatus.STATUS_IDLE):
            raise _CallSequenceException(
                "Virtual Phone not idle after hangup.")
        return True

    except _CallSequenceException as e:
        log.error(e)
        return False
    finally:
        try:
            if ad.droid.telecomIsInCall():
                ad.droid.telecomEndCall()
        except Exception as e:
            log.error(str(e))


def call_mt_setup_teardown(log,
                           ad,
                           virtual_phone_handle,
                           caller_number=None,
                           teardown_side=CALL_TEARDOWN_PHONE,
                           rat=""):
    """ Makes a call from Anritsu Virtual phone to device and tear down the call

    Args:
        ad: Android device object.
        virtual_phone_handle: Anritsu virtual phone handle
        caller_number =  Caller number
        teardown_side = specifiy the side to end the call (Phone or remote)

    Returns:
        True for success False for failure
    """
    log.info("Receive MT Call - Making a call to the phone from remote")
    try:
        if not wait_for_virtualphone_state(log, virtual_phone_handle,
                                           VirtualPhoneStatus.STATUS_IDLE):
            raise Exception("Virtual Phone is not in a state to start call")
        if caller_number is not None:
            if rat == RAT_1XRTT:
                virtual_phone_handle.id_c2k = caller_number
            else:
                virtual_phone_handle.id = caller_number
        virtual_phone_handle.set_voice_off_hook()

        if not wait_and_answer_call(log, ad, caller_number):
            raise Exception("Answer call Fail")

        time.sleep(WAIT_TIME_IN_CALL)

        if not ad.droid.telecomIsInCall():
            raise Exception("Call ended before delay_in_call.")
    except Exception:
        return False

    if ad.droid.telecomIsInCall():
        if teardown_side is CALL_TEARDOWN_REMOTE:
            log.info("Disconnecting the call from Remote")
            virtual_phone_handle.set_voice_on_hook()
        else:
            log.info("Disconnecting the call from Phone")
            ad.droid.telecomEndCall()

    wait_for_virtualphone_state(log, virtual_phone_handle,
                                VirtualPhoneStatus.STATUS_IDLE)
    ensure_phone_idle(log, ad)

    return True


def wait_for_sms_deliver_success(log, ad, time_to_wait=60):
    sms_deliver_event = EventSmsDeliverSuccess
    sleep_interval = 2
    status = False
    event = None

    try:
        event = ad.ed.pop_event(sms_deliver_event, time_to_wait)
        status = True
    except Empty:
        log.info("Timeout: Expected event is not received.")
    return status


def wait_for_sms_sent_success(log, ad, time_to_wait=60):
    sms_sent_event = EventSmsSentSuccess
    sleep_interval = 2
    status = False
    event = None

    try:
        event = ad.ed.pop_event(sms_sent_event, time_to_wait)
        log.info(event)
        status = True
    except Empty:
        log.info("Timeout: Expected event is not received.")
    return status


def wait_for_incoming_sms(log, ad, time_to_wait=60):
    sms_received_event = EventSmsReceived
    sleep_interval = 2
    status = False
    event = None

    try:
        event = ad.ed.pop_event(sms_received_event, time_to_wait)
        log.info(event)
        status = True
    except Empty:
        log.info("Timeout: Expected event is not received.")
    return status, event


def verify_anritsu_received_sms(log, vp_handle, receiver_number, message, rat):
    if rat == RAT_1XRTT:
        receive_sms = vp_handle.receiveSms_c2k()
    else:
        receive_sms = vp_handle.receiveSms()

    if receive_sms == "NONE":
        return False
    split = receive_sms.split('&')
    text = ""
    if rat == RAT_1XRTT:
        # TODO: b/26296388 There is some problem when retrieving message with é
        # from Anritsu.
        return True
    for i in range(len(split)):
        if split[i].startswith('Text='):
            text = split[i][5:]
            text = AnritsuUtils.gsm_decode(text)
            break
    # TODO: b/26296388 Verify Phone number
    if text != message:
        log.error("Wrong message received")
        return False
    return True


def sms_mo_send(log, ad, vp_handle, receiver_number, message, rat=""):
    try:
        if not wait_for_virtualphone_state(log, vp_handle,
                                           VirtualPhoneStatus.STATUS_IDLE):
            raise Exception("Virtual Phone is not in a state to receive SMS")
        log.info("Sending SMS to " + receiver_number)
        ad.droid.smsSendTextMessage(receiver_number, message, False)
        log.info("Waiting for SMS sent event")
        test_status = wait_for_sms_sent_success(log, ad)
        if not test_status:
            raise Exception("Failed to send SMS")
        if not verify_anritsu_received_sms(log, vp_handle, receiver_number,
                                           message, rat):
            raise Exception("Anritsu didn't receive message")
    except Exception as e:
        log.error("Exception :" + str(e))
        return False
    return True


def sms_mt_receive_verify(log, ad, vp_handle, sender_number, message, rat=""):
    ad.droid.smsStartTrackingIncomingMessage()
    try:
        if not wait_for_virtualphone_state(log, vp_handle,
                                           VirtualPhoneStatus.STATUS_IDLE):
            raise Exception("Virtual Phone is not in a state to receive SMS")
        log.info("Waiting for Incoming SMS from " + sender_number)
        if rat == RAT_1XRTT:
            vp_handle.sendSms_c2k(sender_number, message)
        else:
            vp_handle.sendSms(sender_number, message)
        test_status, event = wait_for_incoming_sms(log, ad)
        if not test_status:
            raise Exception("Failed to receive SMS")
        log.info("Incoming SMS: Sender " + event['data']['Sender'])
        log.info("Incoming SMS: Message " + event['data']['Text'])
        if event['data']['Sender'] != sender_number:
            raise Exception("Wrong sender Number")
        if event['data']['Text'] != message:
            raise Exception("Wrong message")
    except Exception as e:
        log.error("exception: " + str(e))
        return False
    finally:
        ad.droid.smsStopTrackingIncomingMessage()
    return True


def wait_for_ims_cscf_status(log,
                             anritsu_handle,
                             virtual_network_id,
                             status,
                             timeout=MAX_WAIT_TIME_IMS_CSCF_STATE):
    """ Wait for IMS CSCF to be in expected state.

    Args:
        log: log object
        anritsu_handle: anritsu object
        virtual_network_id: virtual network id to be monitored
        status: expected status
        timeout: wait time
    """
    sleep_interval = 1
    wait_time = timeout
    while wait_time > 0:
        if status == anritsu_handle.get_ims_cscf_status(virtual_network_id):
            return True
        time.sleep(sleep_interval)
        wait_time = wait_time - sleep_interval
    return False


def wait_for_virtualphone_state(log,
                                vp_handle,
                                state,
                                timeout=MAX_WAIT_TIME_VIRTUAL_PHONE_STATE):
    """ Waits for Anritsu Virtual phone to be in expected state

    Args:
        ad: Android device object.
        vp_handle: Anritus virtual phone handle
        state =  expected state

    Returns:
        True for success False for failure
    """
    status = False
    sleep_interval = 1
    wait_time = timeout
    while wait_time > 0:
        if vp_handle.status == state:
            log.info(vp_handle.status)
            status = True
            break
        time.sleep(sleep_interval)
        wait_time = wait_time - sleep_interval

    if not status:
        log.info("Timeout: Expected state is not received.")
    return status


# There is a difference between CMAS/ETWS message formation in LTE/WCDMA and CDMA 1X
# LTE and CDMA : 3GPP
# CDMA 1X: 3GPP2
# hence different functions
def cmas_receive_verify_message_lte_wcdma(
        log, ad, anritsu_handle, serial_number, message_id, warning_message):
    """ Makes Anritsu to send a CMAS message and phone and verifies phone
        receives the message on LTE/WCDMA

    Args:
        ad: Android device object.
        anritsu_handle: Anritus device object
        serial_number =  serial number of CMAS message
        message_id =  CMAS message ID
        warning_message =  CMAS warning message

    Returns:
        True for success False for failure
    """
    status = False
    event = None
    ad.droid.smsStartTrackingGsmEmergencyCBMessage()
    anritsu_handle.send_cmas_lte_wcdma(
        hex(serial_number), message_id, warning_message)
    try:
        log.info("Waiting for CMAS Message")
        event = ad.ed.pop_event(EventCmasReceived, 60)
        status = True
        log.info(event)
        if warning_message != event['data']['message']:
            log.info("Wrong warning messgae received")
            status = False
        if message_id != hex(event['data']['serviceCategory']):
            log.info("Wrong warning messgae received")
            status = False
    except Empty:
        log.info("Timeout: Expected event is not received.")

    ad.droid.smsStopTrackingGsmEmergencyCBMessage()
    return status


def cmas_receive_verify_message_cdma1x(
        log,
        ad,
        anritsu_handle,
        message_id,
        service_category,
        alert_text,
        response_type=CMAS_C2K_RESPONSETYPE_SHELTER,
        severity=CMAS_C2K_SEVERITY_EXTREME,
        urgency=CMAS_C2K_URGENCY_IMMEDIATE,
        certainty=CMAS_C2K_CERTIANTY_OBSERVED):
    """ Makes Anritsu to send a CMAS message and phone and verifies phone
        receives the message on CDMA 1X

    Args:
        ad: Android device object.
        anritsu_handle: Anritus device object
        serial_number =  serial number of CMAS message
        message_id =  CMAS message ID
        warning_message =  CMAS warning message

    Returns:
        True for success False for failure
    """
    status = False
    event = None
    ad.droid.smsStartTrackingCdmaEmergencyCBMessage()
    anritsu_handle.send_cmas_etws_cdma1x(message_id, service_category,
                                         alert_text, response_type, severity,
                                         urgency, certainty)
    try:
        log.info("Waiting for CMAS Message")
        event = ad.ed.pop_event(EventCmasReceived, 60)
        status = True
        log.info(event)
        if alert_text != event['data']['message']:
            log.info("Wrong alert messgae received")
            status = False

        if event['data']['cmasResponseType'].lower() != response_type.lower():
            log.info("Wrong response type received")
            status = False

        if event['data']['cmasUrgency'].lower() != urgency.lower():
            log.info("Wrong cmasUrgency received")
            status = False

        if event['data']['cmasSeverity'].lower() != severity.lower():
            log.info("Wrong cmasSeverity received")
            status = False
    except Empty:
        log.info("Timeout: Expected event is not received.")

    ad.droid.smsStopTrackingCdmaEmergencyCBMessage()
    return status


def etws_receive_verify_message_lte_wcdma(
        log, ad, anritsu_handle, serial_number, message_id, warning_message):
    """ Makes Anritsu to send a ETWS message and phone and verifies phone
        receives the message on LTE/WCDMA

    Args:
        ad: Android device object.
        anritsu_handle: Anritus device object
        serial_number =  serial number of ETWS message
        message_id =  ETWS message ID
        warning_message =  ETWS warning message

    Returns:
        True for success False for failure
    """
    status = False
    event = None
    if message_id == ETWS_WARNING_EARTHQUAKE:
        warning_type = "Earthquake"
    elif message_id == ETWS_WARNING_EARTHQUAKETSUNAMI:
        warning_type = "EarthquakeandTsunami"
    elif message_id == ETWS_WARNING_TSUNAMI:
        warning_type = "Tsunami"
    elif message_id == ETWS_WARNING_TEST_MESSAGE:
        warning_type = "test"
    elif message_id == ETWS_WARNING_OTHER_EMERGENCY:
        warning_type = "other"
    ad.droid.smsStartTrackingGsmEmergencyCBMessage()
    anritsu_handle.send_etws_lte_wcdma(
        hex(serial_number), message_id, warning_type, warning_message, "ON",
        "ON")
    try:
        log.info("Waiting for ETWS Message")
        event = ad.ed.pop_event(EventEtwsReceived, 60)
        status = True
        log.info(event)
        # TODO: b/26296388 Event data verification
    except Empty:
        log.info("Timeout: Expected event is not received.")

    ad.droid.smsStopTrackingGsmEmergencyCBMessage()
    return status


def etws_receive_verify_message_cdma1x(log, ad, anritsu_handle, serial_number,
                                       message_id, warning_message):
    """ Makes Anritsu to send a ETWS message and phone and verifies phone
        receives the message on CDMA1X

    Args:
        ad: Android device object.
        anritsu_handle: Anritus device object
        serial_number =  serial number of ETWS message
        message_id =  ETWS message ID
        warning_message =  ETWS warning message

    Returns:
        True for success False for failure
    """
    status = False
    event = None
    # TODO: b/26296388 need to add logic to check etws.
    return status


def read_ue_identity(log, ad, anritsu_handle, identity_type):
    """ Get the UE identity IMSI, IMEI, IMEISV

    Args:
        ad: Android device object.
        anritsu_handle: Anritus device object
        identity_type: Identity type(IMSI/IMEI/IMEISV)

    Returns:
        Requested Identity value
    """
    return anritsu_handle.get_ue_identity(identity_type)


def get_transmission_mode(user_params, cell_no):
    """ Returns the TRANSMODE to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        TM to be used
    """
    key = "cell{}_transmission_mode".format(cell_no)
    transmission_mode = user_params.get(key, DEFAULT_T_MODE)
    return transmission_mode


def get_dl_antenna(user_params, cell_no):
    """ Returns the DL ANTENNA to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        number of DL ANTENNAS to be used
    """
    key = "cell{}_dl_antenna".format(cell_no)
    dl_antenna = user_params.get(key, DEFAULT_DL_ANTENNA)
    return dl_antenna


def get_lte_band(user_params, cell_no, sim_card):
    """ Returns the LTE BAND to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        LTE BAND to be used
    """
    key = "cell{}_lte_band".format(cell_no)
    if sim_card == FiTMO:
        band = Fi_LTE_TMO_BAND[cell_no - 1]
    elif sim_card == FiSPR:
        band = Fi_LTE_SPR_BAND[cell_no - 1]
    elif sim_card == FiUSCC:
        band = Fi_LTE_USCC_BAND[cell_no - 1]
    else:
        band = DEFAULT_LTE_BAND[cell_no - 1]
    return user_params.get(key, band)


def get_wcdma_band(user_params, cell_no):
    """ Returns the WCDMA BAND to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        WCDMA BAND to be used
    """
    key = "cell{}_wcdma_band".format(cell_no)
    wcdma_band = user_params.get(key, DEFAULT_WCDMA_BAND)
    return wcdma_band


def get_gsm_band(user_params, cell_no, sim_card):
    """ Returns the GSM BAND to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        GSM BAND to be used
    """
    key = "cell{}_gsm_band".format(cell_no)
    if sim_card == FiTMO:
        gsm_band = Fi_GSM_TMO_BAND
    else:
        gsm_band = user_params.get(key, DEFAULT_GSM_BAND)
    return gsm_band


def get_1x_band(user_params, cell_no, sim_card):
    """ Returns the 1X BAND to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        1X BAND to be used
    """
    key = "cell{}_1x_band".format(cell_no)
    if sim_card == FiSPR:
        band = Fi_SPR1X_BAND
    elif sim_card == FiUSCC:
        band = Fi_USCC1X_BAND
    elif sim_card == VzW12349:
        band = VzW_CDMA1x_BAND
    else:
        band = DEFAULT_CDMA1X_BAND
    return user_params.get(key, band)


def get_evdo_band(user_params, cell_no, sim_card):
    """ Returns the EVDO BAND to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        EVDO BAND to be used
    """
    key = "cell{}_evdo_band".format(cell_no)
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        band = Fi_EVDO_BAND
    elif sim_card == VzW12349:
        band = VzW_EVDO_BAND
    else:
         band = DEFAULT_EVDO_BAND
    return user_params.get(key, band)


def get_wcdma_rac(user_params, cell_no):
    """ Returns the WCDMA RAC to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        WCDMA RAC to be used
    """
    key = "cell{}_wcdma_rac".format(cell_no)
    try:
        wcdma_rac = user_params[key]
    except KeyError:
        wcdma_rac = DEFAULT_RAC
    return wcdma_rac


def get_gsm_rac(user_params, cell_no):
    """ Returns the GSM RAC to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        GSM RAC to be used
    """
    key = "cell{}_gsm_rac".format(cell_no)
    try:
        gsm_rac = user_params[key]
    except KeyError:
        gsm_rac = DEFAULT_RAC
    return gsm_rac


def get_wcdma_lac(user_params, cell_no):
    """ Returns the WCDMA LAC to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        WCDMA LAC to be used
    """
    key = "cell{}_wcdma_lac".format(cell_no)
    try:
        wcdma_lac = user_params[key]
    except KeyError:
        wcdma_lac = DEFAULT_LAC
    return wcdma_lac


def get_gsm_lac(user_params, cell_no):
    """ Returns the GSM LAC to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        GSM LAC to be used
    """
    key = "cell{}_gsm_lac".format(cell_no)
    try:
        gsm_lac = user_params[key]
    except KeyError:
        gsm_lac = DEFAULT_LAC
    return gsm_lac


def get_lte_mcc(user_params, cell_no, sim_card):
    """ Returns the LTE MCC to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        LTE MCC to be used
    """

    key = "cell{}_lte_mcc".format(cell_no)
    if sim_card == FiTMO:
        mcc = Fi_TMO_MCC
    elif sim_card == FiSPR:
        mcc = Fi_SPR_MCC
    elif sim_card == FiUSCC:
        mcc = Fi_USCC_MCC
    elif sim_card == VzW12349:
        mcc = VzW_MCC
    else:
        mcc = DEFAULT_MCC
    return user_params.get(key, mcc)


def get_lte_mnc(user_params, cell_no, sim_card):
    """ Returns the LTE MNC to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        LTE MNC to be used
    """
    key = "cell{}_lte_mnc".format(cell_no)
    if sim_card == FiTMO:
        mnc = Fi_TMO_MNC
    elif sim_card == FiSPR:
        mnc = Fi_SPR_MNC
    elif sim_card == FiUSCC:
        mnc = Fi_USCC_MNC
    elif sim_card == VzW12349:
        mnc = VzW_MNC
    else:
        mnc = DEFAULT_MNC
    return user_params.get(key, mnc)


def get_wcdma_mcc(user_params, cell_no, sim_card):
    """ Returns the WCDMA MCC to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        WCDMA MCC to be used
    """
    key = "cell{}_wcdma_mcc".format(cell_no)
    mcc = VzW_MCC if sim_card == VzW12349 else DEFAULT_MCC
    return user_params.get(key, mcc)


def get_wcdma_mnc(user_params, cell_no, sim_card):
    """ Returns the WCDMA MNC to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        WCDMA MNC to be used
    """
    key = "cell{}_wcdma_mnc".format(cell_no)
    mnc = VzW_MNC if sim_card == VzW12349 else DEFAULT_MNC
    return user_params.get(key, mnc)


def get_gsm_mcc(user_params, cell_no, sim_card):
    """ Returns the GSM MCC to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        GSM MCC to be used
    """
    key = "cell{}_gsm_mcc".format(cell_no)
    mcc = VzW_MCC if sim_card == VzW12349 else DEFAULT_MCC
    return user_params.get(key, mcc)


def get_gsm_mnc(user_params, cell_no, sim_card):
    """ Returns the GSM MNC to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        GSM MNC to be used
    """
    key = "cell{}_gsm_mnc".format(cell_no)
    mnc = VzW_MNC if sim_card == VzW12349 else DEFAULT_MNC
    return user_params.get(key, mnc)


def get_1x_mcc(user_params, cell_no, sim_card):
    """ Returns the 1X MCC to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        1X MCC to be used
    """
    key = "cell{}_1x_mcc".format(cell_no)
    if sim_card == FiSPR:
        mcc = Fi_SPR1X_MCC
    elif sim_card == FiUSCC:
        mcc = Fi_USCC1X_MCC
    elif sim_card == VzW12349:
        mcc = VzW_MCC
    else:
        mcc = DEFAULT_MCC
    return user_params.get(key, mcc)


def get_1x_channel(user_params, cell_no, sim_card):
    """ Returns the 1X Channel to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        1X Channel to be used
    """
    key = "cell{}_1x_channel".format(cell_no)
    if sim_card == FiSPR:
        ch = Fi_SPR1X_CH
    elif sim_card == FiUSCC:
        ch = Fi_USCC1X_CH
    elif sim_card == VzW12349:
        ch = VzW_CDMA1x_CH
    else:
        ch = DEFAULT_CDMA1X_CH
    return user_params.get(key, ch)


def get_1x_sid(user_params, cell_no, sim_card):
    """ Returns the 1X SID to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        1X SID to be used
    """
    key = "cell{}_1x_sid".format(cell_no)
    if sim_card == FiSPR:
        sid = Fi_SPR1X_SID
    elif sim_card == FiUSCC:
        sid = Fi_USCC1X_SID
    elif sim_card == VzW12349:
        sid = VzW_CDMA1X_SID
    else:
        sid = DEFAULT_CDMA1X_SID
    return user_params.get(key, sid)


def get_1x_nid(user_params, cell_no, sim_card):
    """ Returns the 1X NID to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        1X NID to be used
    """
    key = "cell{}_1x_nid".format(cell_no)
    if sim_card == FiSPR:
        nid = Fi_SPR1X_NID
    elif sim_card == FiUSCC:
        nid = Fi_USCC1X_NID
    elif sim_card == VzW12349:
        nid = VzW_CDMA1X_NID
    else:
        nid = DEFAULT_CDMA1X_NID
    return user_params.get(key, nid)


def get_evdo_channel(user_params, cell_no, sim_card):
    """ Returns the EVDO Channel to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        EVDO Channel to be used
    """
    key = "cell{}_evdo_channel".format(cell_no)
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        ch = Fi_EVDO_CH
    elif sim_card == VzW12349:
        ch = VzW_EVDO_CH
    else:
        ch = DEFAULT_EVDO_CH
    return user_params.get(key, ch)


def get_evdo_sid(user_params, cell_no, sim_card):
    """ Returns the EVDO SID to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        EVDO SID to be used
    """
    key = "cell{}_evdo_sid".format(cell_no)
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        sid = Fi_EVDO_SECTOR_ID
    elif sim_card == VzW12349:
        sid = VzW_EVDO_SECTOR_ID
    else:
        sid = DEFAULT_EVDO_SECTOR_ID
    return user_params.get(key, sid)


def get_csfb_type(user_params):
    """ Returns the CSFB Type to be used from the user specified parameters
        or default value

    Args:
        user_params: pointer to user supplied parameters
        cell_no: specify the cell number this BTS is configured
        Anritsu supports two cells. so cell_1 or cell_2

    Returns:
        CSFB Type to be used
    """
    try:
        csfb_type = user_params["csfb_type"]
    except KeyError:
        csfb_type = CsfbType.CSFB_TYPE_REDIRECTION
    return csfb_type


def set_post_sim_params(anritsu_handle, user_params, sim_card):
    if sim_card == FiTMO or sim_card == FiSPR or sim_card == FiUSCC:
        anritsu_handle.send_command("PDNCHECKAPN 1,h2g2")
        anritsu_handle.send_command("PDNCHECKAPN 2,n.nv.ispsn")
        anritsu_handle.send_command("PDNCHECKAPN 3,fast.t-mobile.com")
        anritsu_handle.send_command("PDNCHECKAPN 4,ims")
        anritsu_handle.send_command("PDNCHECKAPN 5,*")
        anritsu_handle.send_command("PDNIMS 1,DISABLE")
        anritsu_handle.send_command("PDNIMS 2,DISABLE")
        anritsu_handle.send_command("PDNIMS 3,DISABLE")
        anritsu_handle.send_command("PDNIMS 4,ENABLE")
        anritsu_handle.send_command("PDNVNID 4,1")
        anritsu_handle.send_command("PDNIMS 5,ENABLE")
        anritsu_handle.send_command("PDNVNID 5,2")
    if sim_card == P0135Ax:
        anritsu_handle.send_command("PDNCHECKAPN 1,ims")
        anritsu_handle.send_command("PDNCHECKAPN 2,fast.t-mobile.com")
        anritsu_handle.send_command("PDNIMS 1,ENABLE")
        anritsu_handle.send_command("PDNVNID 1,1")
        anritsu_handle.send_command("PDNIMS 2,ENABLE")
        anritsu_handle.send_command("PDNIMS 3,ENABLE")
        anritsu_handle.send_command("PDNVNID 3,1")
    if sim_card == VzW12349:
        anritsu_handle.send_command("PDNCHECKAPN 1,IMS")
        anritsu_handle.send_command("PDNCHECKAPN 2,VZWINTERNET")
        anritsu_handle.send_command("PDNIMS 1,ENABLE")
        anritsu_handle.send_command("PDNVNID 1,1")
        anritsu_handle.send_command("PDNIMS 3,ENABLE")
        anritsu_handle.send_command("PDNVNID 3,1")