# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import dbus
import dbus.types
import logging

import modem
import pm_constants
import pm_errors
import utils

from autotest_lib.client.cros.cellular import mm1_constants

def SubscriptionStateToPco(state):
    """
    Takes an old SubscriptionState enum and returns a Pco that will be
    interpreted as that subscription state.

    @param state: see mm1_constants.MM_MODEM_3GPP_SUBSCRIPTION_STATE_*
    """

    pco_data = '\x27\x08\x00\xFF\x00\x04\x13\x01\x84'
    if state == mm1_constants.MM_MODEM_3GPP_SUBSCRIPTION_STATE_UNKNOWN:
        pco_data += '\xFF'
    elif state == mm1_constants.MM_MODEM_3GPP_SUBSCRIPTION_STATE_UNPROVISIONED:
        pco_data += '\x05'
    elif state == mm1_constants.MM_MODEM_3GPP_SUBSCRIPTION_STATE_PROVISIONED:
        pco_data += '\x00'
    elif state == mm1_constants.MM_MODEM_3GPP_SUBSCRIPTION_STATE_OUT_OF_DATA:
        pco_data += '\x03'

    return dbus.types.Struct(
            [dbus.types.UInt32(1),
             dbus.types.Boolean(True),
             dbus.types.ByteArray(pco_data)],
            signature='ubay')


class Modem3gpp(modem.Modem):
    """
    Pseudomodem implementation of the
    org.freedesktop.ModemManager1.Modem.Modem3gpp and
    org.freedesktop.ModemManager1.Modem.Simple interfaces. This class provides
    access to specific actions that may be performed in modems with 3GPP
    capabilities.

    """

    IMEI = '00112342342123'

    class GsmNetwork(object):
        """
        GsmNetwork stores the properties of a 3GPP network that can be
        discovered during a network scan.

        """
        def __init__(self,
                     operator_long,
                     operator_short,
                     operator_code,
                     status,
                     access_technology):
            self.status = status
            self.operator_long = operator_long
            self.operator_short = operator_short
            self.operator_code = operator_code
            self.access_technology = access_technology


        def ToScanDictionary(self):
            """
            @returns: Dictionary containing operator data as defined by
                    org.freedesktop.ModemManager1.Modem.Modem3gpp.Scan.

            """
            return {
              'status': dbus.types.UInt32(self.status),
              'operator-long': self.operator_long,
              'operator-short': self.operator_short,
              'operator-code': self.operator_code,
              'access-technology': dbus.types.UInt32(self.access_technology),
            }


    def __init__(self,
                 state_machine_factory=None,
                 bus=None,
                 device='pseudomodem0',
                 index=0,
                 roaming_networks=None,
                 config=None):
        modem.Modem.__init__(self,
                             state_machine_factory,
                             bus=bus,
                             device=device,
                             roaming_networks=roaming_networks,
                             config=config)

        self._scanned_networks = {}
        self._cached_pco = dbus.types.Array([], "(ubay)")


    def _InitializeProperties(self):
        ip = modem.Modem._InitializeProperties(self)
        props = ip[mm1_constants.I_MODEM]
        props3gpp = self._GetDefault3GPPProperties()
        if props3gpp:
            ip[mm1_constants.I_MODEM_3GPP] = props3gpp
        props['SupportedCapabilities'] = [
                dbus.types.UInt32(mm1_constants.MM_MODEM_CAPABILITY_GSM_UMTS),
                dbus.types.UInt32(mm1_constants.MM_MODEM_CAPABILITY_LTE),
                dbus.types.UInt32(
                        mm1_constants.MM_MODEM_CAPABILITY_GSM_UMTS |
                        mm1_constants.MM_MODEM_CAPABILITY_LTE)
        ]
        props['CurrentCapabilities'] = dbus.types.UInt32(
                mm1_constants.MM_MODEM_CAPABILITY_GSM_UMTS |
                mm1_constants.MM_MODEM_CAPABILITY_LTE)
        props['MaxBearers'] = dbus.types.UInt32(3)
        props['MaxActiveBearers'] = dbus.types.UInt32(2)
        props['EquipmentIdentifier'] = self.IMEI
        props['AccessTechnologies'] = dbus.types.UInt32((
                mm1_constants.MM_MODEM_ACCESS_TECHNOLOGY_GSM |
                mm1_constants.MM_MODEM_ACCESS_TECHNOLOGY_UMTS))
        props['SupportedModes'] = [
                dbus.types.Struct(
                        [dbus.types.UInt32(mm1_constants.MM_MODEM_MODE_3G |
                                           mm1_constants.MM_MODEM_MODE_4G),
                         dbus.types.UInt32(mm1_constants.MM_MODEM_MODE_4G)],
                        signature='uu')
        ]
        props['CurrentModes'] = props['SupportedModes'][0]
        props['SupportedBands'] = [
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_EGSM),
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_DCS),
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_PCS),
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_G850),
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_U2100),
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_U1800),
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_U17IV),
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_U800),
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_U850)
        ]
        props['CurrentBands'] = [
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_EGSM),
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_DCS),
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_PCS),
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_G850),
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_U2100),
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_U800),
            dbus.types.UInt32(mm1_constants.MM_MODEM_BAND_U850)
        ]
        return ip


    def _GetDefault3GPPProperties(self):
        if not self.sim or self.sim.locked:
            return None
        return {
            'Imei' : self.IMEI,
            'RegistrationState' : (
                    dbus.types.UInt32(
                        mm1_constants.MM_MODEM_3GPP_REGISTRATION_STATE_IDLE)),
            'OperatorCode' : '',
            'OperatorName' : '',
            'EnabledFacilityLocks' : (
                    dbus.types.UInt32(self.sim.enabled_locks)),
            'Pco': dbus.types.Array([], "(ubay)"),
        }


    def SyncScan(self):
        """ The synchronous implementation of |Scan| for this class. """
        state = self.Get(mm1_constants.I_MODEM, 'State')
        if state < mm1_constants.MM_MODEM_STATE_ENABLED:
            raise pm_errors.MMCoreError(
                    pm_errors.MMCoreError.WRONG_STATE,
                    'Modem not enabled, cannot scan for networks.')

        sim_path = self.Get(mm1_constants.I_MODEM, 'Sim')
        if not self.sim:
            assert sim_path == mm1_constants.ROOT_PATH
            raise pm_errors.MMMobileEquipmentError(
                pm_errors.MMMobileEquipmentError.SIM_NOT_INSERTED,
                'Cannot scan for networks because no SIM is inserted.')
        assert sim_path != mm1_constants.ROOT_PATH

        # TODO(armansito): check here for SIM lock?

        scanned = [network.ToScanDictionary()
                   for network in self.roaming_networks]

        # get home network
        sim_props = self.sim.GetAll(mm1_constants.I_SIM)
        scanned.append({
            'status': dbus.types.UInt32(
                    mm1_constants.MM_MODEM_3GPP_NETWORK_AVAILABILITY_AVAILABLE),
            'operator-long': sim_props['OperatorName'],
            'operator-short': sim_props['OperatorName'],
            'operator-code': sim_props['OperatorIdentifier'],
            'access-technology': dbus.types.UInt32(self.sim.access_technology)
        })

        self._scanned_networks = (
                {network['operator-code']: network for network in scanned})
        return scanned


    def AssignPco(self, pco):
        """
        Stores the given value so that it is shown as the value of Pco when
        the modem is in a registered state.

        Always prefer this method over calling "Set" directly if the PCO value
        should be cached.

        Note: See testing.Testing.UpdatePco, which allows calling this method
        over D-Bus.

        @param pco_value: D-Bus struct containing the PCO value to remember.

        """
        self._cached_pco = pco
        self.UpdatePco()


    def UpdatePco(self):
        """
        Updates the current PCO value based on the registration state.

        """
        if not mm1_constants.I_MODEM_3GPP in self._properties:
            return
        state = self.Get(mm1_constants.I_MODEM_3GPP, 'RegistrationState')
        if (state == mm1_constants.MM_MODEM_3GPP_REGISTRATION_STATE_HOME or
            state == mm1_constants.MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING):
            new_pco_value = self._cached_pco
        else:
            new_pco_value = dbus.types.Array([], "(ubay)")
        self.Set(mm1_constants.I_MODEM_3GPP, 'Pco', new_pco_value)


    def AssignSubscriptionState(self,
                                registered_subscription_state):
        """
        Caches the given subscription states and updates the actual
        |SubscriptionState| property depending on the |RegistrationState|.

        @param unregistered_subscription_state: This subscription state is
                returned when the modem is not registered on a network.
        @param registered_subscription_state: This subscription state is
                returned when the modem is registered on a network.

        """
        new_pco = SubscriptionStateToPco(registered_subscription_state)
        self.AssignPco([new_pco])
        self.UpdatePco()


    def UpdateLockStatus(self):
        """
        Overloads superclass implementation. Also updates
        'EnabledFacilityLocks' if 3GPP properties are exposed.

        """
        modem.Modem.UpdateLockStatus(self)
        if mm1_constants.I_MODEM_3GPP in self._properties:
            self.SetUInt32(mm1_constants.I_MODEM_3GPP,
                     'EnabledFacilityLocks',
                     self.sim.enabled_locks)


    def SetSIM(self, sim):
        """
        Overrides modem.Modem.SetSIM. Once the SIM has been assigned, attempts
        to expose 3GPP properties if SIM readable.

        @param sim: An instance of sim.SIM
        Emits:
            PropertiesChanged

        """
        modem.Modem.SetSIM(self, sim)
        self.Expose3GPPProperties()


    def Expose3GPPProperties(self):
        """
        A call to this method will attempt to expose 3GPP properties if there
        is a current SIM and is unlocked.

        """
        props = self._GetDefault3GPPProperties()
        if props:
            self.SetAll(mm1_constants.I_MODEM_3GPP, props)


    def SetRegistrationState(self, state):
        """
        Sets the 'RegistrationState' property.

        @param state: An MMModem3gppRegistrationState value.
        Emits:
            PropertiesChanged

        """
        self.SetUInt32(mm1_constants.I_MODEM_3GPP, 'RegistrationState', state)
        self.UpdatePco()


    @property
    def scanned_networks(self):
        """
        @returns: Dictionary containing the result of the most recent network
                scan, where the keys are the operator code.

        """
        return self._scanned_networks


    @utils.log_dbus_method(return_cb_arg='return_cb', raise_cb_arg='raise_cb')
    @dbus.service.method(mm1_constants.I_MODEM_3GPP, in_signature='s',
                         async_callbacks=('return_cb', 'raise_cb'))
    def Register(self, operator_id, return_cb=None, raise_cb=None):
        """
        Request registration with a given modem network.

        @param operator_id: The operator ID to register. An empty string can be
                used to register to the home network.
        @param return_cb: Async success callback.
        @param raise_cb: Async error callback.

        """
        logging.info('Modem3gpp.Register: %s', operator_id)

        # Check if we're already registered with the given network.
        if (self.Get(mm1_constants.I_MODEM_3GPP, 'OperatorCode') ==
            operator_id or
            ((not operator_id and self.Get(mm1_constants.I_MODEM, 'State') >=
                    mm1_constants.MM_MODEM_STATE_REGISTERED))):
            message = 'Already registered.'
            logging.info(message)
            raise pm_errors.MMCoreError(pm_errors.MMCoreError.FAILED, message)

        if (self.Get(mm1_constants.I_MODEM, 'State') <
            mm1_constants.MM_MODEM_STATE_ENABLED):
            message = 'Cannot register the modem if not enabled.'
            logging.info(message)
            raise pm_errors.MMCoreError(pm_errors.MMCoreError.FAILED, message)

        self.CancelAllStateMachines()

        def _Reregister():
            if (self.Get(mm1_constants.I_MODEM, 'State') ==
                mm1_constants.MM_MODEM_STATE_REGISTERED):
                self.UnregisterWithNetwork()
            self.RegisterWithNetwork(operator_id, return_cb, raise_cb)

        if (self.Get(mm1_constants.I_MODEM, 'State') ==
            mm1_constants.MM_MODEM_STATE_CONNECTED):
            self.Disconnect(mm1_constants.ROOT_PATH, _Reregister, raise_cb)
        else:
            _Reregister()


    def SetRegistered(self, operator_code, operator_name):
        """
        Sets the modem to be registered with the give network. Sets the Modem
        and Modem3gpp registration states.

        @param operator_code: The operator code that should be displayed by
                the modem.
        @param operator_name: The operator name that should be displayed by
                the modem.

        """
        if operator_code:
            assert self.sim
            assert (self.Get(mm1_constants.I_MODEM, 'Sim') !=
                    mm1_constants.ROOT_PATH)
            if (operator_code ==
                self.sim.Get(mm1_constants.I_SIM, 'OperatorIdentifier')):
                state = mm1_constants.MM_MODEM_3GPP_REGISTRATION_STATE_HOME
            else:
                state = mm1_constants.MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING
        else:
            state = mm1_constants.MM_MODEM_3GPP_REGISTRATION_STATE_HOME

        logging.info('Modem3gpp.Register: Setting registration state to %s.',
            mm1_constants.RegistrationStateToString(state))
        self.SetRegistrationState(state)
        logging.info('Modem3gpp.Register: Setting state to REGISTERED.')
        self.ChangeState(mm1_constants.MM_MODEM_STATE_REGISTERED,
            mm1_constants.MM_MODEM_STATE_CHANGE_REASON_USER_REQUESTED)
        self.Set(mm1_constants.I_MODEM_3GPP, 'OperatorCode', operator_code)
        self.Set(mm1_constants.I_MODEM_3GPP, 'OperatorName', operator_name)


    @utils.log_dbus_method(return_cb_arg='return_cb', raise_cb_arg='raise_cb')
    @dbus.service.method(mm1_constants.I_MODEM_3GPP, out_signature='aa{sv}',
                         async_callbacks=('return_cb', 'raise_cb'))
    def Scan(self, return_cb, raise_cb):
        """
        Scan for available networks.

        @param return_cb: This function is called with the result.
        @param raise_cb: This function may be called with error.
        @returns: An array of dictionaries with each array element describing a
                mobile network found in the scan. See the ModemManager reference
                manual for the list of keys that may be included in the returned
                dictionary.

        """
        scan_result = self.SyncScan()
        return_cb(scan_result)


    def RegisterWithNetwork(
            self, operator_id="", return_cb=None, raise_cb=None):
        """
        Overridden from superclass.

        @param operator_id: See superclass documentation.
        @param return_cb: See superclass documentation.
        @param raise_cb: See superclass documentation.

        """
        machine = self._state_machine_factory.CreateMachine(
                pm_constants.STATE_MACHINE_REGISTER,
                self,
                operator_id,
                return_cb,
                raise_cb)
        machine.Start()


    def UnregisterWithNetwork(self):
        """
        Overridden from superclass.

        """
        logging.info('Modem3gpp.UnregisterWithHomeNetwork')
        logging.info('Setting registration state to IDLE.')
        self.SetRegistrationState(
                mm1_constants.MM_MODEM_3GPP_REGISTRATION_STATE_IDLE)
        logging.info('Setting state to ENABLED.')
        self.ChangeState(mm1_constants.MM_MODEM_STATE_ENABLED,
            mm1_constants.MM_MODEM_STATE_CHANGE_REASON_USER_REQUESTED)
        self.Set(mm1_constants.I_MODEM_3GPP, 'OperatorName', '')
        self.Set(mm1_constants.I_MODEM_3GPP, 'OperatorCode', '')


    # Inherited from modem_simple.ModemSimple.
    @utils.log_dbus_method(return_cb_arg='return_cb', raise_cb_arg='raise_cb')
    def Connect(self, properties, return_cb, raise_cb):
        """
        Overriden from superclass.

        @param properties
        @param return_cb
        @param raise_cb

        """
        logging.info('Connect')
        machine = self._state_machine_factory.CreateMachine(
                pm_constants.STATE_MACHINE_CONNECT,
                self,
                properties,
                return_cb,
                raise_cb)
        machine.Start()


    # Inherited from modem_simple.ModemSimple.
    @utils.log_dbus_method(return_cb_arg='return_cb', raise_cb_arg='raise_cb')
    def Disconnect(self, bearer_path, return_cb, raise_cb, *return_cb_args):
        """
        Overriden from superclass.

        @param bearer_path
        @param return_cb
        @param raise_cb
        @param return_cb_args

        """
        logging.info('Disconnect: %s', bearer_path)
        machine = self._state_machine_factory.CreateMachine(
                pm_constants.STATE_MACHINE_DISCONNECT,
                self,
                bearer_path,
                return_cb,
                raise_cb,
                return_cb_args)
        machine.Start()


    # Inherited from modem_simple.ModemSimple.
    @utils.log_dbus_method()
    def GetStatus(self):
        """
        Overriden from superclass.

        """
        modem_props = self.GetAll(mm1_constants.I_MODEM)
        m3gpp_props = self.GetAll(mm1_constants.I_MODEM_3GPP)
        retval = {}
        retval['state'] = modem_props['State']
        if retval['state'] >= mm1_constants.MM_MODEM_STATE_REGISTERED:
            retval['signal-quality'] = modem_props['SignalQuality'][0]
            retval['bands'] = modem_props['CurrentBands']
            retval['access-technology'] = self.sim.access_technology
            retval['m3gpp-registration-state'] = \
                m3gpp_props['RegistrationState']
            retval['m3gpp-operator-code'] = m3gpp_props['OperatorCode']
            retval['m3gpp-operator-name'] = m3gpp_props['OperatorName']
        return retval
    # TODO(armansito): implement
    # org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd, if needed
    # (in a separate class?)