# Copyright (c) 2013 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 math

# Setup wardmodem package root and other autotest paths.
import common

import state_machine

class NetworkIdentityMachine(state_machine.StateMachine):
    """
    Various identification numbers are used by the network to identify a
    customer's mobile equipment. These numbers are variously dependent on the
    SIM card, the network, the original subscriber, the geographical location
    etc.

    We serve queries regarding these identification numbers from this state
    machine, so that intuitive handles can be used to fake different
    combinations of the facets listed above.

    """

    def __init__(self, state, transceiver, modem_conf):
        """
        @param state: The GlobalState object shared by all state machines.

        @param transceiver: The ATTransceiver object to interact with.

        @param modem_conf: A ModemConfiguration object containing the
                configuration data for the current modem.

        """
        super(NetworkIdentityMachine, self).__init__(state, transceiver,
                                                     modem_conf)

        # Register all responses.
        self._add_response_function('wm_response_sim_info_success')
        self._add_response_function('wm_response_sim_info_error_too_long')
        self._add_response_function('wm_response_mdn')

        # Load configuration.
        self._mcc = modem_conf.network_identity_default_mcc
        self._mnc = modem_conf.network_identity_default_mnc
        self._msin = modem_conf.network_identity_default_msin
        self._mdn = modem_conf.network_identity_default_mdn


    def get_well_known_name(self):
        """ Returns the well known name for this machine. """
        return 'network_identity_machine'


    # ##########################################################################
    # State machine API functions.
    def read_imsi_from_modem(self):
        """
        Return the IMSI stored in the modem.

        This is currently a stub that returns the same IMSI as returned from
        SIM (@see read_sim_imsi). Note that the format of the returned value is
        different for these two functions. Some modems actually report two
        different IMSIs depending on where it is queried from. Implement this
        function if you want to simulate that behaviour.

        """
        self._respond_text(self._get_sim_imsi())
        self._respond_ok()


    def read_sim_admin_data(self, length_str):
        """
        Return administrative data read from the SIM.

        The administrative data contains, besides the length of the MNC, the
        state of the device -- is it under active development, undergoing some
        qualification process etc.
        We force the mode to be normal, and allow modems to provide different
        length of MNC if desired.

        @param length_str: (Type: str) Length of expected response.

        """
        answer = '0000000'
        answer += str(len(self._mnc))
        self._check_length_and_respond(answer, length_str)


    def read_sim_imsi(self, length_str):
        """
        Return the IMSI.

        The IMSI information is also available from request_response state
        machine. These two IMSI values can actually be different.

        @param length_str: (Type: str) Length of the expected response.

        """
        imsi = self._get_sim_imsi()
        # See ETSI TS 151.11 V14.4.0
        # The format of the returned string is
        # 'l' ['x' '<padded_imsi>']
        #
        # |l| is the number of bytes used by the 'x' and 'imsi' together.
        #
        # |x| encodes some parity checking, and can be '8' or '9' based on
        # parity. We currently set it to 9 (I haven't seen '8' in practice')
        #
        # |padded_imsi| is imsi padded with 'f' on the right to make the whole
        # thing 18 characters
        #
        # Finally the bytes within [] are represented LSB first, so the odd and
        # even characters in that string need to be swapped.
        x = '9'
        padded_imsi = x + imsi
        l = str(int(math.ceil(len(padded_imsi)/2)))
        while len(padded_imsi) < 16:
            padded_imsi += 'F'
        # Encode this number LSB first.
        switched_imsi = []
        for i in range(8):
            switched_imsi.append(padded_imsi[2*i+1])
            switched_imsi.append(padded_imsi[2*i])
        padded_imsi = ''.join(switched_imsi)

        # l should be 2 character long
        if len(l) != 2:
            l = '0' + l
        response = l + padded_imsi

        self._check_length_and_respond(response, length_str)


    def read_service_provider_name(self, length_str):
        """
        Return the name of the service provider encoded as hex string.

        Not Implemented. None of the modems we use return this information
        correctly right now.

        @param length_str: (Type: str) Length of the expected response.

        """
        # 'F' is used to pad unused bits. An all-'F' string means that we do not
        # have this information.
        # (TODO) pprabhu: Figure out the encoding scheme for this information if
        # a test needs it.
        provider_name = 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'
        self._check_length_and_respond(provider_name, length_str)


    def read_mdn(self):
        """
        Return the Mobile Directory Number for the current service account.

        """
        self._respond(self.wm_response_mdn, 0, self._mdn)
        self._respond_ok()


    def _check_length_and_respond(self, response, length_str):
        """
        Checks that the length of the response is not less than the expected
        response. If it is more, the response is clipped.

        @param response: The string to respond with.

        @param length_str: (Type: str)The expected length in bytes. Note that
                the number of bytes in |response| is half the length of the
                string |response|, since each byte encodes two characters.

        """
        try:
            length = int(length_str)
        except ValueError as e:
            dbgstr = self._tag_with_name(
                    'Failed to detect expected length of the response. '
                    'Are you sure this is a number: |%s|' % length_str)
            self._respond_error()
            return

        # We require ceil(len(response)) number of bytes to encode the string
        # |response|, since each byte holds two characters.
        if 2 * length > len(response):
            dbgstr = self._tag_with_name(
                    'Response too short. Requested reponse length: %d, Actual '
                    'response length: %d' % (2 * length, len(response)))
            self._logger.warning(dbgstr)
            self._respond(self.wm_response_sim_info_error_too_long)
        else:
            dbgstr = self._tag_with_name(
                    'Response: |%s|, clipped to length %d: |%s|' %
                    (response, length, response[:2*length]))
            self._logger.debug(dbgstr)
            self._respond(self.wm_response_sim_info_success, 0,
                          response[:2*length])
        self._respond_ok()


    def _get_sim_imsi(self):
        return self._mcc + self._mnc + self._msin