# Copyright 2013 The Chromium 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 telemetry.util import image_util
from telemetry.util import rgba_color
from telemetry.value import scalar

from metrics import Metric


class SpeedIndexMetric(Metric):
  """The speed index metric is one way of measuring page load speed.

  It is meant to approximate user perception of page load speed, and it
  is based on the amount of time that it takes to paint to the visual
  portion of the screen. It includes paint events that occur after the
  onload event, and it doesn't include time loading things off-screen.

  This speed index metric is based on WebPageTest.org (WPT).
  For more info see: http://goo.gl/e7AH5l
  """

  def __init__(self):
    super(SpeedIndexMetric, self).__init__()
    self._impl = None

  @classmethod
  def CustomizeBrowserOptions(cls, options):
    options.AppendExtraBrowserArgs('--disable-infobars')

  def Start(self, _, tab):
    """Start recording events.

    This method should be called in the WillNavigateToPage method of
    a PageTest, so that all the events can be captured. If it's called
    in DidNavigateToPage, that will be too late.
    """
    if not tab.video_capture_supported:
      return
    self._impl = VideoSpeedIndexImpl()
    self._impl.Start(tab)

  def Stop(self, _, tab):
    """Stop recording."""
    if not tab.video_capture_supported:
      return
    assert self._impl, 'Must call Start() before Stop()'
    assert self.IsFinished(tab), 'Must wait for IsFinished() before Stop()'
    self._impl.Stop(tab)

  # Optional argument chart_name is not in base class Metric.
  # pylint: disable=arguments-differ
  def AddResults(self, tab, results, chart_name=None):
    """Calculate the speed index and add it to the results."""
    try:
      if tab.video_capture_supported:
        index = self._impl.CalculateSpeedIndex(tab)
        none_value_reason = None
      else:
        index = None
        none_value_reason = 'Video capture is not supported.'
    finally:
      self._impl = None  # Release the tab so that it can be disconnected.

    results.AddValue(scalar.ScalarValue(
        results.current_page, '%s_speed_index' % chart_name, 'ms', index,
        description='Speed Index. This focuses on time when visible parts of '
                    'page are displayed and shows the time when the '
                    'first look is "almost" composed. If the contents of the '
                    'testing page are composed by only static resources, load '
                    'time can measure more accurately and speed index will be '
                    'smaller than the load time. On the other hand, If the '
                    'contents are composed by many XHR requests with small '
                    'main resource and javascript, speed index will be able to '
                    'get the features of performance more accurately than load '
                    'time because the load time will measure the time when '
                    'static resources are loaded. If you want to get more '
                    'detail, please refer to http://goo.gl/Rw3d5d. Currently '
                    'there are two implementations: for Android and for '
                    'Desktop. The Android version uses video capture; the '
                    'Desktop one uses paint events and has extra overhead to '
                    'catch paint events.', none_value_reason=none_value_reason))

  def IsFinished(self, tab):
    """Decide whether the recording should be stopped.

    A page may repeatedly request resources in an infinite loop; a timeout
    should be placed in any measurement that uses this metric, e.g.:
      def IsDone():
        return self._speedindex.IsFinished(tab)
      util.WaitFor(IsDone, 60)

    Returns:
      True if 2 seconds have passed since last resource received, false
      otherwise.
    """
    return tab.HasReachedQuiescence()


class SpeedIndexImpl(object):

  def Start(self, tab):
    raise NotImplementedError()

  def Stop(self, tab):
    raise NotImplementedError()

  def GetTimeCompletenessList(self, tab):
    """Returns a list of time to visual completeness tuples.

    In the WPT PHP implementation, this is also called 'visual progress'.
    """
    raise NotImplementedError()

  def CalculateSpeedIndex(self, tab):
    """Calculate the speed index.

    The speed index number conceptually represents the number of milliseconds
    that the page was "visually incomplete". If the page were 0% complete for
    1000 ms, then the score would be 1000; if it were 0% complete for 100 ms
    then 90% complete (ie 10% incomplete) for 900 ms, then the score would be
    1.0*100 + 0.1*900 = 190.

    Returns:
      A single number, milliseconds of visual incompleteness.
    """
    time_completeness_list = self.GetTimeCompletenessList(tab)
    prev_completeness = 0.0
    speed_index = 0.0
    prev_time = time_completeness_list[0][0]
    for time, completeness in time_completeness_list:
      # Add the incremental value for the interval just before this event.
      elapsed_time = time - prev_time
      incompleteness = (1.0 - prev_completeness)
      speed_index += elapsed_time * incompleteness

      # Update variables for next iteration.
      prev_completeness = completeness
      prev_time = time
    return int(speed_index)


class VideoSpeedIndexImpl(SpeedIndexImpl):

  def __init__(self, image_util_module=image_util):
    # Allow image_util to be passed in so we can fake it out for testing.
    super(VideoSpeedIndexImpl, self).__init__()
    self._time_completeness_list = None
    self._image_util_module = image_util_module

  def Start(self, tab):
    assert tab.video_capture_supported
    # Blank out the current page so it doesn't count towards the new page's
    # completeness.
    tab.Highlight(rgba_color.WHITE)
    # TODO(tonyg): Bitrate is arbitrary here. Experiment with screen capture
    # overhead vs. speed index accuracy and set the bitrate appropriately.
    tab.StartVideoCapture(min_bitrate_mbps=4)

  def Stop(self, tab):
    # Ignore white because Chrome may blank out the page during load and we want
    # that to count as 0% complete. Relying on this fact, we also blank out the
    # previous page to white. The tolerance of 8 experimentally does well with
    # video capture at 4mbps. We should keep this as low as possible with
    # supported video compression settings.
    video_capture = tab.StopVideoCapture()
    histograms = [
        (time, self._image_util_module.GetColorHistogram(
            image, ignore_color=rgba_color.WHITE, tolerance=8))
        for time, image in video_capture.GetVideoFrameIter()
    ]

    start_histogram = histograms[0][1]
    final_histogram = histograms[-1][1]
    total_distance = start_histogram.Distance(final_histogram)

    def FrameProgress(histogram):
      if total_distance == 0:
        if histogram.Distance(final_histogram) == 0:
          return 1.0
        else:
          return 0.0
      return 1 - histogram.Distance(final_histogram) / total_distance

    self._time_completeness_list = [(time, FrameProgress(hist))
                                    for time, hist in histograms]

  def GetTimeCompletenessList(self, tab):
    assert self._time_completeness_list, 'Must call Stop() first.'
    return self._time_completeness_list