# 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 logging
import subprocess

import pm_errors
import state_machine

from autotest_lib.client.cros.cellular import mm1_constants

class ConnectMachine(state_machine.StateMachine):
    """
    ConnectMachine handles the state transitions involved in bringing the modem
    to the CONNECTED state.

    """
    def __init__(self, modem, properties, return_cb, raise_cb):
        super(ConnectMachine, self).__init__(modem)
        self.connect_props = properties
        self.return_cb = return_cb
        self.raise_cb = raise_cb
        self.enable_initiated = False
        self.register_initiated = False


    def Cancel(self):
        """ Overriden from superclass. """
        logging.info('ConnectMachine: Canceling connect.')
        super(ConnectMachine, self).Cancel()
        state = self._modem.Get(mm1_constants.I_MODEM, 'State')
        reason = mm1_constants.MM_MODEM_STATE_CHANGE_REASON_USER_REQUESTED
        if state == mm1_constants.MM_MODEM_STATE_CONNECTING:
            logging.info('ConnectMachine: Setting state to REGISTERED.')
            self._modem.ChangeState(mm1_constants.MM_MODEM_STATE_REGISTERED,
                                    reason)
        elif self.enable_initiated and self._modem.enable_step:
            self._modem.enable_step.Cancel()
        self._modem.connect_step = None


    def _HandleDisabledState(self):
        logging.info('ConnectMachine: Modem is DISABLED.')
        assert not self._modem.IsPendingEnable()
        if self.enable_initiated:
            message = 'ConnectMachine: Failed to enable modem.'
            logging.error(message)
            self.Cancel()
            self._modem.connect_step = None
            self.raise_cb(pm_errors.MMCoreError(
                    pm_errors.MMCoreError.FAILED, message))
            return False
        else:
            logging.info('ConnectMachine: Initiating Enable.')
            self.enable_initiated = True
            self._modem.Enable(True)

            # state machine will spin until modem gets enabled,
            # or if enable fails
            return True


    def _HandleEnablingState(self):
        logging.info('ConnectMachine: Modem is ENABLING.')
        assert self._modem.IsPendingEnable()
        logging.info('ConnectMachine: Waiting for enable.')
        return True


    def _HandleEnabledState(self):
        logging.info('ConnectMachine: Modem is ENABLED.')

        # Check to see if a register is going on, if not,
        # start register
        if self.register_initiated:
            message = 'ConnectMachine: Failed to register.'
            logging.error(message)
            self.Cancel()
            self._modem.connect_step = None
            self.raise_cb(pm_errors.MMCoreError(pm_errors.MMCoreError.FAILED,
                                                message))
            return False
        else:
            logging.info('ConnectMachine: Waiting for Register.')
            if not self._modem.IsPendingRegister():
                self._modem.RegisterWithNetwork(
                        "", self._return_cb, self._raise_cb)
            self.register_initiated = True
            return True


    def _HandleSearchingState(self):
        logging.info('ConnectMachine: Modem is SEARCHING.')
        logging.info('ConnectMachine: Waiting for modem to register.')
        assert self.register_initiated
        assert self._modem.IsPendingRegister()
        return True


    def _HandleRegisteredState(self):
        logging.info('ConnectMachine: Modem is REGISTERED.')
        assert not self._modem.IsPendingDisconnect()
        assert not self._modem.IsPendingEnable()
        assert not self._modem.IsPendingDisable()
        assert not self._modem.IsPendingRegister()
        logging.info('ConnectMachine: Setting state to CONNECTING.')
        reason = mm1_constants.MM_MODEM_STATE_CHANGE_REASON_USER_REQUESTED
        self._modem.ChangeState(mm1_constants.MM_MODEM_STATE_CONNECTING,
                                reason)
        return True


    def _GetBearerToActivate(self):
        # Import modem here to avoid circular imports.
        import modem
        bearer = None
        bearer_path = None
        bearer_props = {}
        for p, b in self._modem.bearers.iteritems():
            # assemble bearer props
            for key, val in self.connect_props.iteritems():
                if key in modem.ALLOWED_BEARER_PROPERTIES:
                    bearer_props[key] = val
            if (b.bearer_properties == bearer_props):
                logging.info('ConnectMachine: Found matching bearer.')
                bearer = b
                bearer_path = p
                break
        if bearer is None:
            assert bearer_path is None
            logging.info(('ConnectMachine: No matching bearer found, '
                'creating brearer with properties: ' +
                str(self.connect_props)))
            bearer_path = self._modem.CreateBearer(self.connect_props)

        return bearer_path


    def _HandleConnectingState(self):
        logging.info('ConnectMachine: Modem is CONNECTING.')
        assert not self._modem.IsPendingDisconnect()
        assert not self._modem.IsPendingEnable()
        assert not self._modem.IsPendingDisable()
        assert not self._modem.IsPendingRegister()
        try:
            bearer_path = self._GetBearerToActivate()
            self._modem.ActivateBearer(bearer_path)
            logging.info('ConnectMachine: Setting state to CONNECTED.')
            reason = mm1_constants.MM_MODEM_STATE_CHANGE_REASON_USER_REQUESTED
            self._modem.ChangeState(mm1_constants.MM_MODEM_STATE_CONNECTED,
                                    reason)
            self._modem.connect_step = None
            logging.info(
                'ConnectMachine: Returning bearer path: %s', bearer_path)
            self.return_cb(bearer_path)
        except (pm_errors.MMError, subprocess.CalledProcessError) as e:
            logging.error('ConnectMachine: Failed to connect: ' + str(e))
            self.raise_cb(e)
            self._modem.ChangeState(
                    mm1_constants.MM_MODEM_STATE_REGISTERED,
                    mm1_constants.MM_MODEM_STATE_CHANGE_REASON_UNKNOWN)
            self._modem.connect_step = None
        return False


    def _GetModemStateFunctionMap(self):
        return {
            mm1_constants.MM_MODEM_STATE_DISABLED:
                    ConnectMachine._HandleDisabledState,
            mm1_constants.MM_MODEM_STATE_ENABLING:
                    ConnectMachine._HandleEnablingState,
            mm1_constants.MM_MODEM_STATE_ENABLED:
                    ConnectMachine._HandleEnabledState,
            mm1_constants.MM_MODEM_STATE_SEARCHING:
                    ConnectMachine._HandleSearchingState,
            mm1_constants.MM_MODEM_STATE_REGISTERED:
                    ConnectMachine._HandleRegisteredState,
            mm1_constants.MM_MODEM_STATE_CONNECTING:
                    ConnectMachine._HandleConnectingState
        }


    def _ShouldStartStateMachine(self):
        if self._modem.connect_step and self._modem.connect_step != self:
            # There is already a connect operation in progress.
            message = 'There is already an ongoing connect operation.'
            logging.error(message)
            self.raise_cb(pm_errors.MMCoreError(
                    pm_errors.MMCoreError.IN_PROGRESS, message))
            return False
        elif self._modem.connect_step is None:
            # There is no connect operation going on, cancelled or otherwise.
            if self._modem.IsPendingDisable():
                message = 'Modem is currently being disabled. Ignoring ' \
                          'connect.'
                logging.error(message)
                self.raise_cb(
                    pm_errors.MMCoreError(pm_errors.MMCoreError.WRONG_STATE,
                                          message))
                return False
            state = self._modem.Get(mm1_constants.I_MODEM, 'State')
            if state == mm1_constants.MM_MODEM_STATE_CONNECTED:
                message = 'Modem is already connected.'
                logging.error(message)
                self.raise_cb(
                    pm_errors.MMCoreError(pm_errors.MMCoreError.CONNECTED,
                                          message))
                return False
            if state == mm1_constants.MM_MODEM_STATE_DISCONNECTING:
                assert self._modem.IsPendingDisconnect()
                message = 'Cannot connect while disconnecting.'
                logging.error(message)
                self.raise_cb(
                    pm_errors.MMCoreError(pm_errors.MMCoreError.WRONG_STATE,
                                          message))
                return False

            logging.info('Starting Connect.')
            self._modem.connect_step = self
        return True