# Copyright (c) 2014 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 contextlib import closing
import logging
import os
import time
import urllib2

from autotest_lib.client.bin import test, utils
from autotest_lib.client.common_lib import error
from autotest_lib.client.common_lib.cros import chrome
from autotest_lib.client.cros import power_status, power_utils
from autotest_lib.client.cros import service_stopper


# Chrome flags to use fake camera and skip camera permission.
EXTRA_BROWSER_ARGS = ['--use-fake-device-for-media-stream',
                      '--use-fake-ui-for-media-stream']
NO_WEBRTC_HARDWARE_ACCELERATION_BROWSER_ARGS = ['--disable-webrtc-hw-decoding',
                                                '--disable-webrtc-hw-encoding']

FAKE_FILE_ARG = '--use-file-for-fake-video-capture="%s"'
DOWNLOAD_BASE = 'http://commondatastorage.googleapis.com/chromiumos-test-assets-public/crowd/'
VIDEO_NAME = 'crowd720_25frames.y4m'

WEBRTC_INTERNALS_URL = 'chrome://webrtc-internals'
RTC_INIT_HISTOGRAM = 'Media.RTCVideoDecoderInitDecodeSuccess'
HISTOGRAMS_URL = 'chrome://histograms/' + RTC_INIT_HISTOGRAM

# Minimum battery charge percentage we prefer to run the test
BATTERY_INITIAL_CHARGED_MIN = 10

WEBRTC_WITH_HARDWARE_ACCELERATION = 'webrtc_with_hardware_acceleration'
WEBRTC_WITHOUT_HARDWARE_ACCELERATION = 'webrtc_without_hardware_acceleration'

# Measure duration in seconds
MEASURE_DURATION = 120
# Time to exclude from calculation after firing a task [seconds].
STABILIZATION_DURATION = 5

class video_WebRtcPower(test.test):
    """The test outputs the power consumption for WebRTC to performance
    dashboard.
    """
    version = 1

    def initialize(self):
        # Objects that need to be taken care of in cleanup() are initialized
        # here to None. Otherwise we run the risk of AttributeError raised in
        # cleanup() masking a real error that caused the test to fail during
        # initialize() before those variables were assigned.
        self._backlight = None

        self._services = service_stopper.ServiceStopper(
            service_stopper.ServiceStopper.POWER_DRAW_SERVICES)
        self._services.stop_services()

        self._power_status = power_status.get_status()
        # Verify that we are running on battery and the battery is
        # sufficiently charged.
        self._power_status.assert_battery_state(BATTERY_INITIAL_CHARGED_MIN)


    def start_loopback(self, cr):
        """
        Opens WebRTC loopback page.

        @param cr: Autotest Chrome instance.
        """
        tab = cr.browser.tabs[0]
        tab.Navigate(cr.browser.http_server.UrlOf(
                os.path.join(self.bindir, 'loopback.html')))
        tab.WaitForDocumentReadyStateToBeComplete()


    def assert_hardware_accelerated(self, cr, is_hardware_accelerated):
        """
        Checks if WebRTC decoding is hardware accelerated.

        @param cr: Autotest Chrome instance.
        @param is_hardware_accelerated: if is_hardware_accelerated is True then
        assert hardware accelerated otherwise assert hardware not accelerated.

        @raises error.TestError if decoding is not hardware accelerated while
        is_hardware_accelerated is True or if decoding is hardware accelerated
        while is_hardware_accelerated is False.
        """
        tab = cr.browser.tabs.New()
        def histograms_loaded():
            """Returns true if histogram is loaded."""
            tab.Navigate(HISTOGRAMS_URL)
            tab.WaitForDocumentReadyStateToBeComplete()
            return tab.EvaluateJavaScript(
                    'document.documentElement.innerText.search("%s") != -1'
                    % RTC_INIT_HISTOGRAM)

        try:
            utils.poll_for_condition(
                    histograms_loaded,
                    timeout=5,
                    exception=error.TestError(
                            'Cannot find rtc video decoder histogram.'),
                    sleep_interval=1)
        except error.TestError as e:
            if is_hardware_accelerated:
                raise e
        else:
            if not is_hardware_accelerated:
                raise error.TestError(
                        'Video decode acceleration shoud not be working.')
            if tab.EvaluateJavaScript(
                    'document.documentElement.innerText.search('
                    '"1 = 100.0%") == -1'):
                raise error.TestError(
                        'Video decode acceleration is not working.')

        tab.Close()


    def run_once(self):
        # Download test video.
        url = DOWNLOAD_BASE + VIDEO_NAME
        local_path = os.path.join(self.bindir, VIDEO_NAME)
        self.download_file(url, local_path)

        self._backlight = power_utils.Backlight()
        self._backlight.set_default()

        measurements = [power_status.SystemPower(
                self._power_status.battery_path)]
        self._power_logger = power_status.PowerLogger(measurements)
        self._power_logger.start()

        # Run the WebRTC tests.
        self.test_webrtc(local_path)

        keyvals = self._power_logger.calc()
        measurement_type = '_' + measurements[0].domain + '_pwr'
        energy_rate_with_hw = keyvals[WEBRTC_WITH_HARDWARE_ACCELERATION +
                                      measurement_type]
        self.output_perf_value(
                description='webrtc_energy_rate.mean',
                value=energy_rate_with_hw,
                units='W', higher_is_better=False)
        # Save the results to the autotest results directory
        self._power_logger.save_results(self.resultsdir)

        # Find the energy of full battery
        batinfo = self._power_status.battery[0]
        self.energy_full_design = batinfo.energy_full_design
        logging.info("energy_full_design = %0.3f Wh",
                     self.energy_full_design)

        logging.info('Expected battery life using WebRtc with'
                     'hardware acceleration : %0.3f hours',
                     self.energy_full_design / energy_rate_with_hw)

        energy_rate_without_hw = keyvals[WEBRTC_WITHOUT_HARDWARE_ACCELERATION +
                                         measurement_type]
        logging.info('Expected battery life using WebRtc without'
                     'hardware acceleration : %0.3f hours',
                     self.energy_full_design / energy_rate_without_hw)


    def test_webrtc(self, local_path):
        """
        Runs the WebRTC test with and without hardware acceleration.

        @param local_path: the path to the video file.
        @param test_duration: test duration for a run (seconds).
        """
        EXTRA_BROWSER_ARGS.append(FAKE_FILE_ARG % local_path)
        with chrome.Chrome(extra_browser_args=EXTRA_BROWSER_ARGS) as cr:
            # Open WebRTC loopback page.
            cr.browser.SetHTTPServerDirectories(self.bindir)
            self.start_loopback(cr)

            # Make sure decode is hardware accelerated.
            self.assert_hardware_accelerated(cr, True)

            # Record the start time and the end time of this power
            # measurement test run.
            time.sleep(STABILIZATION_DURATION)
            start_time = time.time()
            time.sleep(MEASURE_DURATION)
            self._power_logger.checkpoint(WEBRTC_WITH_HARDWARE_ACCELERATION,
                                          start_time)

        # Start chrome with test flag
        # and disabled WebRTC hardware encode and decode flag.
        with chrome.Chrome(extra_browser_args=EXTRA_BROWSER_ARGS +
                           NO_WEBRTC_HARDWARE_ACCELERATION_BROWSER_ARGS) as cr:

            # Open WebRTC loopback page.
            cr.browser.SetHTTPServerDirectories(self.bindir)
            self.start_loopback(cr)

            # Make sure decode is not hardware accelerated.
            self.assert_hardware_accelerated(cr, False)

            # Record the start time and the end time of this power
            # measurement test run.
            time.sleep(STABILIZATION_DURATION)
            start_time = time.time()
            time.sleep(MEASURE_DURATION)
            self._power_logger.checkpoint(WEBRTC_WITHOUT_HARDWARE_ACCELERATION,
                                          start_time)


    def download_file(self, url, local_path):
        """
        Downloads a file from the specified URL.

        @param url: URL of the file.
        @param local_path: the path that the file will be saved to.
        """
        logging.info('Downloading "%s" to "%s"', url, local_path)
        with closing(urllib2.urlopen(url)) as r, open(local_path, 'wb') as w:
            w.write(r.read())


    def cleanup(self):
        # cleanup() is run by common_lib/test.py.
        if self._backlight:
            self._backlight.restore()
        if self._services:
            self._services.restore_services()

        super(video_WebRtcPower, self).cleanup()