# Copyright (c) 2020 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.

from datetime import datetime
import logging
import time
import os

from autotest_lib.server import site_linux_system
from autotest_lib.server.cros.network import hostap_config
from autotest_lib.server.cros.network import wifi_cell_test_base
from autotest_lib.server.cros.network import wpa_mon
from autotest_lib.client.common_lib.cros.network import xmlrpc_datatypes

class network_WiFi_RoamNatural(wifi_cell_test_base.WiFiCellTestBase):
    """Bring up two APs, connect, vary attenuation as if the device is moving
    between the two APs (i.e. the signal gets weaker on one and stronger on the
    other until the first one cannot be seen anymore). At some point before the
    first AP is torn down, the device should have roamed to the second AP. If it
    doesn't there will be an association failure, which we can then log and
    write to a file. Ideally, there would be no association failures and a roam
    every time we expected one. Realistically, RSSI can vary quite widely, and
    we can't expect to see a good roam signal on every scan even where there
    should be one.

    This test is used to sanity check that "normal" roaming behavior is not
    broken by any roaming algorithm changes. A couple failed associations is
    acceptable, but any more than that is a good indication that roaming has
    become too sticky."""

    version = 1

    MAX_CENTER = 100
    MIN_CENTER = 84
    MAX_ATTEN = 106
    ATTEN_STEP = 2

    def test_body(self, pair_num, ap_pair, logger, roam_stats, failure_stats):
        """
        Execute the test with the given APs and record stats.

        @param pair_num int: the nth time this function is called (for results
        logging purposes).
        @param ap_pair tuple of HostapConfig objects: the APs
        @param logger WpaMon object: used for event monitoring
        @roam_stats dict of tuple to int: used to log roam stats.
        @failure_stats int list with a single int element: used to log assoc
        failure stats
        """
        # Reset the attenuation here since it won't have been reset after
        # previous iterations of this function.
        self.context.attenuator.set_variable_attenuation(0)

        min_atten = self.context.attenuator.get_minimal_total_attenuation()
        ap_pair[0].ssid = None
        self.context.configure(ap_pair[0])
        ssid = self.context.router.get_ssid()
        self.context.assert_connect_wifi(
            xmlrpc_datatypes.AssociationParameters(ssid=ssid))
        ap_pair[0].ssid = ssid
        ap_pair[1].ssid = ssid
        self.context.configure(ap_pair[1], configure_pcap=True)
        self.context.client.wait_for_bss(self.context.pcap_host.get_hostapd_mac(0))
        skip_roam_log = open(
            os.path.join(self.resultsdir,
                         str(pair_num) + '_skip_roam.txt'), 'w')
        assoc_failure_log = open(
            os.path.join(self.resultsdir,
                         str(pair_num) + '_failure.txt'), 'w')
        for center in range(self.MIN_CENTER, self.MAX_CENTER,
                            2 * self.ATTEN_STEP):
            # The attenuation should [con,di]verge around center. We move
            # the attenuation out 2dBm at a time until self.MAX_ATTEN is hit
            # on one AP, at which point we tear that AP down to simulate it
            # disappearing from the DUT's view. This should trigger a deauth
            # if the DUT is still associated.
            max_offset = self.MAX_ATTEN - center
            for _ in range(2):
                ranges = [range(0, max_offset, self.ATTEN_STEP),
                          range(max_offset, 0, -self.ATTEN_STEP),
                          range(0, -max_offset, -self.ATTEN_STEP),
                          range(-max_offset, 0, self.ATTEN_STEP)]
                for r, _ in enumerate(ranges):
                    self.context.client.clear_supplicant_blacklist()
                    logger.start_event_capture()
                    for offset in ranges[r]:
                        ap1_atten = max(center + offset, min_atten)
                        ap2_atten = max(center - offset, min_atten)
                        self.context.attenuator.set_total_attenuation(
                            ap1_atten, ap_pair[0].frequency, 0)
                        self.context.attenuator.set_total_attenuation(
                            ap1_atten, ap_pair[0].frequency, 1)
                        self.context.attenuator.set_total_attenuation(
                            ap2_atten, ap_pair[1].frequency, 2)
                        self.context.attenuator.set_total_attenuation(
                            ap2_atten, ap_pair[1].frequency, 3)
                        time.sleep(2)
                    if r % 2 == 1:
                        # The APs' RSSIs should have converged. No reason to
                        # check for disconnects/roams here.
                        continue

                    if r == 0:
                        # First AP is no longer in view
                        self.context.router.deconfig()
                    elif r == 2:
                        # Second AP is no longer in view
                        self.context.pcap_host.deconfig()

                    dc_events = logger.wait_for_event(
                        wpa_mon.WpaMon.CTRL_EVENT_DISCONNECTED, timeout=5)
                    if dc_events:
                        # Association failure happened, check if this
                        # was because a roam was skipped.
                        skip_roams = logger.get_events(
                            wpa_mon.WpaMon.CTRL_EVENT_SKIP_ROAM, True)
                        if skip_roams:
                            # Skipped roam caused association failure, log this
                            # so we can re-examine the roam decision.
                            for roam in skip_roams:
                                logging.info(roam)
                                skip_roam_log.write(str(roam) + '\n')
                                freq_pair = (int(roam.cur_freq) / 1000,
                                             int(roam.sel_freq) / 1000)
                                roam_stats[freq_pair] += 1
                        else:
                            # Association failure happened for some other reason
                            # (likely because AP disappeared before scan
                            # results returned). Log the failure for the
                            # timestamp in case we'd like to take a closer look.
                            for event in dc_events:
                                dc = str(datetime.now()) + ' ' +  str(event)
                                logging.info(dc)
                                assoc_failure_log.write(dc + '\n')
                                failure_stats[0] += 1

                    # Reset the attenuation here. In some groamer cells, the
                    # attenuation for 5GHz channels is miscalibrated such that
                    # the RSSI is lower than expected. If we bring the AP back
                    # up while it's still maximally attenuated, it may not be
                    # visible to the DUT (the test was written deliberately so
                    # that it wouldn't happen even at full attenuation for
                    # properly calibrated cells, but this is apparently not
                    # always a good assumption).
                    self.context.attenuator.set_variable_attenuation(0)

                    self.context.configure(ap_pair[r / 2],
                                           configure_pcap=(r == 2))
                    host = self.context.router if r == 0 else \
                        self.context.pcap_host
                    self.context.client.wait_for_bss(host.get_hostapd_mac(0))

        skip_roam_log.close()
        assoc_failure_log.close()
        self.context.client.shill.disconnect(ssid)
        self.context.router.deconfig()
        self.context.pcap_host.deconfig()

    def output_roam_stats(self, roam_skip_stats, failure_stats):
        """Output roam stats."""
        for pair, skips in roam_skip_stats.items():
            logging.info('%d association failures caused by skipped roams ' \
                         'from %s GHz to %s GHz', skips, pair[0], pair[1])
            self.output_perf_value('roam_natural_%s_%s' % (pair[0], pair[1]),
                                   skips, units='roams skipped',
                                   higher_is_better=False)
        logging.info('%d association failures unrelated to skipped roams',
                     failure_stats)
        self.output_perf_value('roam_natural_assoc_failures', failure_stats,
                               units='assocation failures',
                               higher_is_better=False)

    def run_once(self):
        """Body of the test."""
        self.context.client.require_capabilities(
            [site_linux_system.LinuxSystem.CAPABILITY_SUPPLICANT_ROAMING])

        mode = hostap_config.HostapConfig.MODE_11N_PURE
        ap1 = hostap_config.HostapConfig(channel=1, mode=mode)
        ap2 = hostap_config.HostapConfig(channel=2, mode=mode)
        ap3 = hostap_config.HostapConfig(channel=36, mode=mode)
        ap_configs = [(ap1, ap2), (ap1, ap3)]

        # Dictionary of roams skipped keyed by a pair of ints representing the
        # current AP's frequency band and the target AP's frequency band.
        roam_stats = {(2, 2): 0,
                      (2, 5): 0,
                      (5, 2): 0}
        failure_stats = [0]

        with self.context.client._wpa_mon as logger:
            for pair_num, ap_pair in enumerate(ap_configs):
                self.test_body(pair_num, ap_pair, logger, roam_stats, failure_stats)

        # Log roam skips and assoc failures and output perf values
        self.output_roam_stats(roam_stats, failure_stats[0])