# Copyright 2014 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.

class Bounds(object):
  """Represents a min-max bounds."""
  def __init__(self):
    self.is_empty_ = True
    self.min_ = None
    self.max_ = None

  @staticmethod
  def CreateFromEvent(event):
    bounds = Bounds()
    bounds.AddEvent(event)
    return bounds

  def __repr__(self):
    if self.is_empty_:
      return "Bounds()"
    else:
      return "Bounds(min=%s,max=%s)" % (self.min_, self.max_)

  @property
  def is_empty(self):
    return self.is_empty_

  @property
  def min(self):
    if self.is_empty_:
      return None
    return self.min_

  @property
  def max(self):
    if self.is_empty_:
      return None
    return self.max_

  @property
  def bounds(self):
    if self.is_empty_:
      return None
    return self.max_ - self.min_

  @property
  def center(self):
    return (self.min_ + self.max_) * 0.5

  def Contains(self, other):
    if self.is_empty or other.is_empty:
      return False
    return self.min <= other.min and self.max >= other.max

  def ContainsInterval(self, start, end):
    return self.min <= start and self.max >= end

  def Intersects(self, other):
    if self.is_empty or other.is_empty:
      return False
    return not (other.max < self.min or other.min > self.max)

  def Reset(self):
    self.is_empty_ = True
    self.min_ = None
    self.max_ = None

  def AddBounds(self, bounds):
    if bounds.is_empty:
      return
    self.AddValue(bounds.min_)
    self.AddValue(bounds.max_)

  def AddValue(self, value):
    if self.is_empty_:
      self.max_ = value
      self.min_ = value
      self.is_empty_ = False
      return

    self.max_ = max(self.max_, value)
    self.min_ = min(self.min_, value)

  def AddEvent(self, event):
    self.AddValue(event.start)
    self.AddValue(event.start + event.duration)

  @staticmethod
  def CompareByMinTimes(a, b):
    if not a.is_empty and not b.is_empty:
      return a.min_ - b.min_

    if a.is_empty and not b.is_empty:
      return -1

    if not a.is_empty and b.is_empty:
      return 1

    return 0

  @staticmethod
  def GetOverlapBetweenBounds(first_bounds, second_bounds):
    """Compute the overlap duration between first_bounds and second_bounds."""
    return Bounds.GetOverlap(first_bounds.min_, first_bounds.max_,
                             second_bounds.min_, second_bounds.max_)

  @staticmethod
  def GetOverlap(first_bounds_min, first_bounds_max,
                 second_bounds_min, second_bounds_max):
    assert first_bounds_min <= first_bounds_max
    assert second_bounds_min <= second_bounds_max
    overlapped_range_start = max(first_bounds_min, second_bounds_min)
    overlapped_range_end = min(first_bounds_max, second_bounds_max)
    return max(overlapped_range_end - overlapped_range_start, 0)