//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

@_exported import CoreMedia // Clang module

extension CMTime {
  public init(seconds: Double, preferredTimescale: CMTimeScale) {
    self = CMTimeMakeWithSeconds(seconds, preferredTimescale)
  }

  public init(value: CMTimeValue, timescale: CMTimeScale) {
    self = CMTimeMake(value, timescale)
  }
}

// CMTIME_IS_VALID
// CMTIME_IS_INVALID
// CMTIME_IS_POSITIVEINFINITY
// CMTIME_IS_NEGATIVEINFINITY
// CMTIME_IS_INDEFINITE
// CMTIME_IS_NUMERIC
// CMTIME_HAS_BEEN_ROUNDED
// CMTimeGetSeconds
// CMTimeConvertScale
extension CMTime {
  public var isValid: Bool {
    return self.flags.contains(.valid)
  }

  public var isPositiveInfinity: Bool {
    return self.isValid &&
      self.flags.contains(.positiveInfinity)
  }

  public var isNegativeInfinity: Bool {
    return self.isValid &&
      self.flags.contains(.negativeInfinity)
  }

  public var isIndefinite: Bool {
    return self.isValid &&
      self.flags.contains(.indefinite)
  }

  public var isNumeric: Bool {
    return
      self.flags.intersection([.valid, .impliedValueFlagsMask]) == .valid
  }

  public var hasBeenRounded: Bool {
    return self.isNumeric &&
      self.flags.contains(.hasBeenRounded)
  }

  public var seconds: Double {
    return CMTimeGetSeconds(self) as Double
  }

  public func convertScale(_ newTimescale: Int32, method: CMTimeRoundingMethod)
    -> CMTime {
    return CMTimeConvertScale(self, newTimescale, method)
  }
}

public func CMTIME_IS_VALID(_ time: CMTime) -> Bool {
  return time.isValid
}

public func CMTIME_IS_INVALID(_ time: CMTime) -> Bool {
  return !time.isValid
}

public func CMTIME_IS_POSITIVEINFINITY(_ time: CMTime) -> Bool {
  return time.isPositiveInfinity
}

public func CMTIME_IS_NEGATIVEINFINITY(_ time: CMTime) -> Bool {
  return time.isNegativeInfinity
}

public func CMTIME_IS_INDEFINITE(_ time: CMTime) -> Bool {
  return time.isIndefinite
}

public func CMTIME_IS_NUMERIC(_ time: CMTime) -> Bool {
  return time.isNumeric
}

public func CMTIME_HAS_BEEN_ROUNDED(_ time: CMTime) -> Bool {
  return time.hasBeenRounded
}

extension CMTime {
  // CMTimeAdd
  public static func + (addend1: CMTime, addend2: CMTime) -> CMTime {
    return CMTimeAdd(addend1, addend2)
  }
  
  // CMTimeSubtract
  public static func - (minuend: CMTime, subtrahend: CMTime) -> CMTime {
    return CMTimeSubtract(minuend, subtrahend)
  }
}

// CMTimeCompare
extension CMTime : Equatable, Comparable {
  public static func < (time1: CMTime, time2: CMTime) -> Bool {
    return CMTimeCompare(time1, time2) < 0
  }
  public static func <= (time1: CMTime, time2: CMTime) -> Bool {
    return CMTimeCompare(time1, time2) <= 0
  }
  public static func > (time1: CMTime, time2: CMTime) -> Bool {
    return CMTimeCompare(time1, time2) > 0
  }
  public static func >= (time1: CMTime, time2: CMTime) -> Bool {
    return CMTimeCompare(time1, time2) >= 0
  }
  public static func == (time1: CMTime, time2: CMTime) -> Bool {
    return CMTimeCompare(time1, time2) == 0
  }
  public static func != (time1: CMTime, time2: CMTime) -> Bool {
    return CMTimeCompare(time1, time2) != 0
  }
}