# 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 logging
import re
import time

import air_state_verifier
import base_station_interface
import cellular

from autotest_lib.client.bin import utils


class Error(Exception):
  pass


class Timeout(Error):
  pass


POLL_SLEEP=0.2


class BaseStation8960(base_station_interface.BaseStationInterface):
  """Wrap an Agilent 8960 Series 10."""

  def __init__(self,
               scpi_connection):
    self.c = scpi_connection

    self.checker_context = self.c.checker_context
    with self.checker_context:
      self._Verify()
      self._Reset()
      self.SetPower(cellular.Power.DEFAULT)

  def _Verify(self):
    idn = self.c.Query('*IDN?')
    if '8960 Series 10 E5515C' not in idn:
      raise Error('Not actually an 8960:  *IDN? says ' + idn)

  def _Reset(self):
    self.c.Reset()
    self.Stop()
    # Perform a partial reset to workaround a problem with the 8960
    # failing to accept CDMA connections after switching from a
    # GSM technology.
    self.c.SendStanza(['SYSTEM:PRESet3'])

  def _IsIdle(self):
    call_state = self.c.Query('CALL:STATus?')
    data_state = self.c.Query('CALL:STATus:DATa?')
    return call_state == 'IDLE' and data_state in ['IDLE', 'OFF']

  def Close(self):
    self.c.Close()

  def GetAirStateVerifier(self):
    return air_state_verifier.AirStateVerifierBasestation(self)

  def GetDataCounters(self):
    output = {}
    for counter in ['OTATx', 'OTARx', 'IPTX', 'IPRX']:
      result_text = self.c.Query('CALL:COUNT:DTMonitor:%s:DRATe?' % counter)
      result = [float(x) for x in result_text.rstrip().split(',')]
      output[counter] = dict(zip(['Mean', 'Current', 'Max', 'Total'], result))
    logging.info('Data counters: %s', output)
    return output

  def GetRatUeDataStatus(self):
    """Get the radio-access-technology-specific status of the UE.

    Unlike GetUeDataStatus, below, this returns a status that depends
    on the RAT being used.
    """
    status = self.c.Query('CALL:STATus:DATa?')
    rat = ConfigDictionaries.FORMAT_TO_DATA_STATUS_TYPE[self.format][status]
    return rat

  def GetUeDataStatus(self):
    """Get the UeGenericDataStatus status of the device."""
    rat = self.GetRatUeDataStatus()
    return cellular.RatToGenericDataStatus[rat]

  def ResetDataCounters(self):
    self.c.SendStanza(['CALL:COUNt:DTMonitor:CLEar'])

  def ClearErrors(self):
    self.c.RetrieveErrors()

  def LogStats(self):
    self.c.Query("CALL:HSDPa:SERVice:PSData:HSDSchannel:CONFig?")

    # Category reported by UE
    self.c.Query("CALL:HSDPa:MS:REPorted:HSDSChannel:CATegory?")
    # The category in use
    self.c.Query("CALL:STATUS:MS:HSDSChannel:CATegory?")
    self.c.Query("CALL:HSDPA:SERV:PSD:CQI?")

  def SetBsIpV4(self, ip1, ip2):
    self.c.SendStanza([
        'SYSTem:COMMunicate:LAN:SELF:ADDRess:IP4 "%s"' % ip1,
        'SYSTem:COMMunicate:LAN:SELF:ADDRess2:IP4 "%s"' % ip2,])

  def SetBsNetmaskV4(self, netmask):
    self.c.SendStanza([
        'SYSTem:COMMunicate:LAN:SELF:SMASk:IP4 "%s"' % netmask,])

  def SetPlmn(self, mcc, mnc):
    # Doing this appears to set the WCDMa versions as well
    self.c.SendStanza([
        'CALL:MCCode %s' % mcc,
        'CALL:MNCode %s' % mnc,])

  def SetPower(self, dbm):
    if dbm <= cellular.Power.OFF :
      self.c.SendStanza([
          'CALL:CELL:POWer:STATe off',])
    else:
      self.c.SendStanza([
          'CALL:CELL:POWer %s' % dbm,])

  def SetTechnology(self, technology):
    #  TODO(rochberg): Check that we're not already in chosen tech for
    #  speed boost

    self.format = ConfigDictionaries.TECHNOLOGY_TO_FORMAT[technology]
    self.technology = technology

    self.c.SimpleVerify('SYSTem:APPLication:FORMat', self.format)
    # Setting the format will start the call box, we need to stop it so we
    # can configure the new format.
    self.Stop()
    self.c.SendStanza(
        ConfigDictionaries.TECHNOLOGY_TO_CONFIG_STANZA.get(technology, []))

  def SetUeDnsV4(self, dns1, dns2):
    """Set the DNS values provided to the UE.  Emulator must be stopped."""
    stanza = ['CALL:MS:DNSServer:PRIMary:IP:ADDRess "%s"' % dns1]
    if dns2:
      stanza.append('CALL:MS:DNSServer:SECondary:IP:ADDRess "%s"' % dns2)
    self.c.SendStanza(stanza)

  def SetUeIpV4(self, ip1, ip2=None):
    """Set the IP addresses provided to the UE.  Emulator must be stopped."""
    stanza = ['CALL:MS:IP:ADDRess1 "%s"' % ip1]
    if ip2:
      stanza.append('CALL:MS:IP:ADDRess2 "%s"' % ip2)
    self.c.SendStanza(stanza)

  def Start(self):
    self.c.SendStanza(['CALL:OPERating:MODE CALL'])

  def Stop(self):
    self.c.SendStanza(['CALL:OPERating:MODE OFF'])
    # Make sure the call status goes to idle before continuing.
    utils.poll_for_condition(
        lambda: self._IsIdle(),
        timeout=cellular.DEFAULT_TIMEOUT,
        exception=Error('8960 did not enter IDLE state'))

  def SupportedTechnologies(self):
    return [
      cellular.Technology.GPRS,
      cellular.Technology.EGPRS,
      cellular.Technology.WCDMA,
      cellular.Technology.HSDPA,
      cellular.Technology.HSUPA,
      cellular.Technology.HSDUPA,
      cellular.Technology.HSPA_PLUS,
      cellular.Technology.CDMA_2000,
      cellular.Technology.EVDO_1X,
      ]

  def WaitForStatusChange(self,
                          interested=None,
                          timeout=cellular.DEFAULT_TIMEOUT):
    """When UE status changes (to a value in interested), return the value.

    Arguments:
        interested: if non-None, only transitions to these states will
          cause a return
        timeout: in seconds.
    Returns: state
    Raises:  Error.Timeout
    """
    start = time.time()
    while time.time() - start <= timeout:
      state = self.GetUeDataStatus()
      if state in interested:
        return state
      time.sleep(POLL_SLEEP)

    state = self.GetUeDataStatus()
    if state in interested:
      return state

    raise Timeout('Timed out waiting for state in %s.  State was %s' %
                  (interested, state))

def _Parse(command_sequence):
  """Split and remove comments from a config stanza."""
  uncommented = [re.sub(r'\s*#.*', '', line)
          for line in command_sequence.split('\n')]

  # Return only nonempty lines
  return [line for line in uncommented if line]


class ConfigStanzas(object):
  # p 22 of http://cp.literature.agilent.com/litweb/pdf/5989-5932EN.pdf
  WCDMA_MAX = _Parse("""
# RAB3: 64 Up/384 down
# http://wireless.agilent.com/rfcomms/refdocs/wcdma/wcdmala_hpib_call_service.html#CACBDEAH
CALL:UPLink:TXPower:LEVel:MAXimum 24
CALL:SERVICE:GPRS:RAB GPRSRAB3
""")

  # p 20 of http://cp.literature.agilent.com/litweb/pdf/5989-5932EN.pdf
  CDMA_2000_MAX = _Parse("""
CALL:SCHannel:FORWard:DRATe BPS153600
CALL:CELL:SOPTion:RCONfig3 SOFS33
""")

  # p 19 of http://cp.literature.agilent.com/litweb/pdf/5989-5932EN.pdf
  EVDO_1X_MAX = _Parse("""
CALL:CELL:CONTrol:CATTribute:ISTate:PCCCycle ATSP
# Default data application
CALL:APPLication:SESSion DPAPlication
# Give DUT 100% of channel
CALL:CELL:APPLication:ATDPackets 100
""")

  GPRS_MAX = _Parse("""
call:bch:scel gprs
call:pdtch:mslot:config d1u1
call:cell:tbflow:t3192 ms1500
""")

  EGPRS_MAX = _Parse("""
call:bch:scel egprs
call:pdtch:mslot:config d4u1
call:cell:tbflow:t3192 ms1500
""")

  CAT_08 = _Parse("""
call:pow:stat ON
call:ms:pow:targ 0
call:cell:rlc:rees OFF
call:hsdpa:ms:hsdschannel:cat:control:auto off
call:hsdpa:ms:hsdschannel:cat:man 8
call:hsdpa:service:psdata:hsdschannel:config cqiv
call:hsdpa:service:psdata:cqi 22
call:serv:gprs:rab PHSP
call:serv:rbt:rab HSDP12
call:serv:psd:srb:mapp UEDD
call:hsup:serv:psd:edpd:ccod:max T2T4
call:hsup:edch:tti MS10
call:hsup:serv:psd:ergc:inf:stat Off
""")

  CAT_10 = _Parse("""
call:pow:stat ON
call:ms:pow:targ 0
call:cell:rlc:rees OFF
call:hsdpa:ms:hsdschannel:cat:control:auto off
call:hsdpa:ms:hsdschannel:cat:man 10
call:serv:gprs:rab PHSP
call:serv:rbt:rab HSDP12
call:hsdpa:service:psdata:hsdschannel:config cqiv
call:hsdpa:service:psdata:cqi 22
call:serv:psd:srb:mapp UEDD
call:hsup:serv:psd:edpd:ccod:max T2T4
call:hsup:edch:tti MS2
call:hsup:serv:psd:ergc:inf:stat Off
""")

class ConfigDictionaries(object):
  TECHNOLOGY_TO_FORMAT_RAW = {
      cellular.Technology.GPRS: 'GSM/GPRS',
      cellular.Technology.EGPRS: 'GSM/GPRS',

      cellular.Technology.WCDMA: 'WCDMA',
      cellular.Technology.HSDPA: 'WCDMA',
      cellular.Technology.HSUPA: 'WCDMA',
      cellular.Technology.HSDUPA: 'WCDMA',
      cellular.Technology.HSPA_PLUS: 'WCDMA',

      cellular.Technology.CDMA_2000: 'IS-2000/IS-95/AMPS',

      cellular.Technology.EVDO_1X: 'IS-856',
      }

  # Put each value in "" marks to quote it for GPIB
  TECHNOLOGY_TO_FORMAT = dict([
      (x, '"%s"' % y) for
      x, y in TECHNOLOGY_TO_FORMAT_RAW.iteritems()])

  TECHNOLOGY_TO_CONFIG_STANZA = {
      cellular.Technology.CDMA_2000: ConfigStanzas.CDMA_2000_MAX,
      cellular.Technology.EVDO_1X: ConfigStanzas.EVDO_1X_MAX,
      cellular.Technology.GPRS: ConfigStanzas.GPRS_MAX,
      cellular.Technology.EGPRS: ConfigStanzas.EGPRS_MAX,
      cellular.Technology.WCDMA: ConfigStanzas.WCDMA_MAX,
      cellular.Technology.HSDPA: ConfigStanzas.CAT_08,
      cellular.Technology.HSUPA: ConfigStanzas.CAT_08,
      cellular.Technology.HSDUPA: ConfigStanzas.CAT_08,
      cellular.Technology.HSPA_PLUS: ConfigStanzas.CAT_10,
      }

# http://wireless.agilent.com/rfcomms/refdocs/gsmgprs/prog_synch_callstategprs.html#CHDDFBAJ
# NB:  We have elided a few states of the GSM state machine here.
  CALL_STATUS_DATA_TO_STATUS_GSM_GPRS = {
      'IDLE': cellular.UeGsmDataStatus.IDLE,
      'ATTG': cellular.UeGsmDataStatus.ATTACHING,
      'DET': cellular.UeGsmDataStatus.DETACHING,
      'ATT': cellular.UeGsmDataStatus.ATTACHED,
      'STAR': cellular.UeGsmDataStatus.ATTACHING,
      'END': cellular.UeGsmDataStatus.PDP_DEACTIVATING,
      'TRAN': cellular.UeGsmDataStatus.PDP_ACTIVE,
      'PDPAG': cellular.UeGsmDataStatus.PDP_ACTIVATING,
      'PDP': cellular.UeGsmDataStatus.PDP_ACTIVE,
      'PDPD': cellular.UeGsmDataStatus.PDP_DEACTIVATING,
      'DCON': cellular.UeGsmDataStatus.PDP_ACTIVE,
      'SUSP': cellular.UeGsmDataStatus.IDLE,
}

# http://wireless.agilent.com/rfcomms/refdocs/wcdma/wcdma_gen_call_proc_status.html#CJADGAHG
  CALL_STATUS_DATA_TO_STATUS_WCDMA = {
      'IDLE': cellular.UeGsmDataStatus.IDLE,
      'ATTG': cellular.UeGsmDataStatus.ATTACHING,
      'DET': cellular.UeGsmDataStatus.DETACHING,
      'OFF': cellular.UeGsmDataStatus.NONE,
      'PDPAG': cellular.UeGsmDataStatus.PDP_ACTIVATING,
      'PDP': cellular.UeGsmDataStatus.PDP_ACTIVE,
      'PDPD': cellular.UeGsmDataStatus.PDP_DEACTIVATING,
      }

# http://wireless.agilent.com/rfcomms/refdocs/cdma2k/cdma2000_hpib_call_status.html#CJABGBCF
  CALL_STATUS_DATA_TO_STATUS_CDMA_2000 = {
      'OFF': cellular.UeC2kDataStatus.OFF,
      'DORM': cellular.UeC2kDataStatus.DORMANT,
      'DCON': cellular.UeC2kDataStatus.DATA_CONNECTED,
      }

# http://wireless.agilent.com/rfcomms/refdocs/1xevdo/1xevdo_hpib_call_status.html#BABCGBCD
  CALL_STATUS_DATA_TO_STATUS_EVDO = {
      'CCL': cellular.UeEvdoDataStatus.CONNECTION_CLOSING,
      'CNEG': cellular.UeEvdoDataStatus.CONNECTION_NEGOTIATE,
      'CREQ': cellular.UeEvdoDataStatus.CONNECTION_REQUEST,
      'DCON': cellular.UeEvdoDataStatus.DATA_CONNECTED,
      'DORM': cellular.UeEvdoDataStatus.DORMANT,
      'HAND': cellular.UeEvdoDataStatus.HANDOFF,
      'IDLE': cellular.UeEvdoDataStatus.IDLE,
      'PAG': cellular.UeEvdoDataStatus.PAGING,
      'SCL': cellular.UeEvdoDataStatus.SESSION_CLOSING,
      'SNEG': cellular.UeEvdoDataStatus.SESSION_NEGOTIATE,
      'SOP': cellular.UeEvdoDataStatus.SESSION_OPEN,
      'UREQ': cellular.UeEvdoDataStatus.UATI_REQUEST,
      }

  FORMAT_TO_DATA_STATUS_TYPE = {
      '"GSM/GPRS"': CALL_STATUS_DATA_TO_STATUS_GSM_GPRS,
      '"WCDMA"': CALL_STATUS_DATA_TO_STATUS_WCDMA,
      '"IS-2000/IS-95/AMPS"': CALL_STATUS_DATA_TO_STATUS_CDMA_2000,
      '"IS-856"': CALL_STATUS_DATA_TO_STATUS_EVDO,
      }