//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 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
//
//===----------------------------------------------------------------------===//

import Swift
@_exported import Accelerate
@_exported import Accelerate.vecLib.BNNS

%{
bnns2016 = [
  ('OSX','10.12'), ('iOS','10.0'), ('tvOS','10.0'), ('watchOS','3.0')
]

bnns2017 = [
  ('OSX','10.13'), ('iOS','11.0'), ('tvOS','11.0'), ('watchOS','4.0')
]

def relString(releases):
  if not releases:
    return '*'
  return ', '.join([
    r[0] + ' ' + r[1] for r in releases
  ] + ['*'])

def available(releases):
  return '@available(' + relString(releases) + ')'

def renamed(name, rel=None):
  return '\n'.join([
    available(rel),
    '@available(*, deprecated, renamed: "' + name + '")'
  ])

def newEnumValue(base, new, old, rel):
  decl = '  public static var ' + new + ': ' + base + ' {\n'
  impl = '    return __' + base + old + '\n  }'
  return '  ' + available(rel) + '\n' + decl + impl

def oldEnumValue(base, new, old, oldRel):
  return renamed(base + '.' + new, oldRel) + '\n' + \
  'public var ' + base + old + ' = __' + base + old

def renameEnumMembers(base, baseRel, names):
  return available(baseRel) + \
  '\nextension ' + base + ' {\n' + \
  '\n'.join([newEnumValue(base, new, old, rel) for new, old, rel in names]) + '\n}\n' + \
  '\n'.join([oldEnumValue(base, new, old, rel) for new, old, rel in names if rel != bnns2017])
}%

${renameEnumMembers('BNNSDataType', bnns2016, [
  ('float16', 'Float16', bnns2016),
  ('float',   'Float32', bnns2016),
  ('int8',    'Int8',    bnns2016),
  ('int16',   'Int16',   bnns2016),
  ('int32',   'Int32',   bnns2016),
  ('uint8',   'UInt8',   bnns2017),
  ('uint16',  'UInt16',  bnns2017),
  ('uint32',  'UInt32',  bnns2017),
  ('indexed8','Indexed8',bnns2016),
])}

${renameEnumMembers('BNNSPoolingFunction', bnns2016, [
  ('max',     'Max',     bnns2016),
  ('average', 'Average', bnns2016),
])}

${renameEnumMembers('BNNSActivationFunction', bnns2016, [
  ('identity', 'Identity', bnns2016),
  ('rectifiedLinear', 'RectifiedLinear', bnns2016),
  ('leakyRectifiedLinear', 'LeakyRectifiedLinear', bnns2016),
  ('sigmoid', 'Sigmoid', bnns2016),
  ('tanh', 'Tanh', bnns2016),
  ('scaledTanh', 'ScaledTanh', bnns2016),
  ('abs', 'Abs', bnns2016),
  ('linear', 'Linear', bnns2017),
  ('clamp', 'Clamp', bnns2017),
  ('integerLinearSaturate', 'IntegerLinearSaturate', bnns2017),
  ('integerLinearSaturatePerChannel', 'IntegerLinearSaturatePerChannel', bnns2017),
  ('softmax', 'Softmax', bnns2017),
])}

${renameEnumMembers('BNNSFlags', bnns2016, [('useClientPointer', 'UseClientPtr', bnns2016)])}

${available(bnns2016)}
extension BNNSImageStackDescriptor {
  ${available(bnns2016)}
  public init(width: Int,
              height: Int,
              channels: Int,
              row_stride: Int,
              image_stride: Int,
              data_type: BNNSDataType) {

    _precondition(data_type != .indexed8,
                  "Image stacks cannot use the indexed8 data type.")

    self.init(width: width,
              height: height,
              channels: channels,
              row_stride: row_stride,
              image_stride: image_stride,
              data_type: data_type,
              data_scale: 1,
              data_bias: 0)
  }
}

${available(bnns2016)}
extension BNNSVectorDescriptor {
  ${available(bnns2016)}
  public init(size: Int,
              data_type: BNNSDataType) {

    _precondition(data_type != .indexed8,
                  "Vectors cannot use the indexed8 data type.")

    self.init(size: size,
              data_type: data_type,
              data_scale: 1,
              data_bias: 0)
  }
}

${available(bnns2016)}
extension BNNSLayerData {
  ${available(bnns2016)}
  public init(data: UnsafeRawPointer?,
              data_type: BNNSDataType,
              data_scale: Float = 1,
              data_bias: Float = 0) {

    _precondition(data_type != .indexed8,
                  "This initializer cannot be used with the indexed8 data type; use BNNSLayerData.indexed8 instead.")

    self.init(data: data,
              data_type: data_type,
              data_scale: data_scale,
              data_bias: data_bias,
              data_table: nil)
  }

  ${available(bnns2016)}
  public static var zero: BNNSLayerData {
    return BNNSLayerData()
  }

  /// A BNNSLayerData object with the indexed8 data type.
  ${available(bnns2016)}
  public static func indexed8(data: UnsafePointer<Int8>?,
                              data_table: UnsafePointer<Float>)
                              -> BNNSLayerData {
    return BNNSLayerData(data: data,
                         data_type: .indexed8,
                         data_scale: 1, // unused
                         data_bias: 0, // unused
                         data_table: data_table)
  }
}

${available(bnns2016)}
extension BNNSActivation {

  ${available(bnns2016)}
  public init(function: BNNSActivationFunction,
              alpha: Float = .nan,
              beta: Float = .nan) {
    if #available(OSX 10.13, iOS 11.0, tvOS 11.0, watchOS 4.0, *) {
      _precondition(function != .integerLinearSaturate,
                    "This initializer cannot be used with the integerLinearSaturate activation function; use BNNSActivation.integerLinearSaturate(scale:Int32, offset:Int32, shift:Int32) instead.")
      _precondition(function != .integerLinearSaturatePerChannel,
                    "This initializer cannot be used with the integerLinearSaturatePerChannel activation function; use BNNSActivation.integerLinearSaturatePerChannel(scale:UnsafePointer<Int32>, offset:UnsafePointer<Int32>, shift:UnsafePointer<Int32>) instead.")
    }
    self.init(function: function,
              alpha: alpha,
              beta: beta,
              iscale: 1,                // unused
              ioffset: 0,               // unused
              ishift: 0,                // unused
              iscale_per_channel: nil,  // unused
              ioffset_per_channel: nil, // unused
              ishift_per_channel: nil)  // unused
  }

  /// A BNNSActivation object that uses the identity activation function.
  ${available(bnns2016)}
  public static var identity: BNNSActivation {
    return BNNSActivation(function: .identity)
  }

  /// A BNNSActivation object that uses the integerLinearSaturate
  /// activation function.
  ${available(bnns2017)}
  public static func integerLinearSaturate(
    scale: Int32 = 1,
    offset: Int32 = 0,
    shift: Int32 = 0)
    -> BNNSActivation {
    return BNNSActivation(function: .integerLinearSaturate,
                          alpha: .nan,     // unused
                          beta: .nan,      // unused
                          iscale: scale,
                          ioffset: offset,
                          ishift: shift,
                          iscale_per_channel: nil, // unused
                          ioffset_per_channel: nil,// unused
                          ishift_per_channel: nil) // unused
  }

  /// A BNNSActivation object that uses the integerLinearSaturatePerChannel
  /// activation function.
  ///
  /// `scale`, `offset`, and `shift` must each point to a buffer with count
  /// equal to the number of channels on which this activation object operates.
  ${available(bnns2017)}
  public static func integerLinearSaturatePerChannel(
    scale:  UnsafePointer<Int32>,
    offset: UnsafePointer<Int32>,
    shift:  UnsafePointer<Int32>)
    -> BNNSActivation {
    return BNNSActivation(function: .integerLinearSaturatePerChannel,
                          alpha: .nan,     // unused
                          beta: .nan,      // unused
                          iscale: 1,       // unused
                          ioffset: 0,      // unused
                          ishift: 0,       // unused
                          iscale_per_channel: scale,
                          ioffset_per_channel: offset,
                          ishift_per_channel: shift)
  }
}

${available(bnns2016)}
extension BNNSConvolutionLayerParameters {
  ${available(bnns2016)}
  public init(x_stride: Int,
              y_stride: Int,
              x_padding: Int,
              y_padding: Int,
              k_width: Int,
              k_height: Int,
              in_channels: Int,
              out_channels: Int,
              weights: BNNSLayerData) {
    self.init(x_stride: x_stride,
              y_stride: y_stride,
              x_padding: x_padding,
              y_padding: y_padding,
              k_width: k_width,
              k_height: k_height,
              in_channels: in_channels,
              out_channels: out_channels,
              weights: weights,
              bias: .zero,
              activation: .identity)
  }
}

${available(bnns2016)}
extension BNNSPoolingLayerParameters {
  ${available(bnns2016)}
  public init(x_stride: Int,
              y_stride: Int,
              x_padding: Int,
              y_padding: Int,
              k_width: Int,
              k_height: Int,
              in_channels: Int,
              out_channels: Int,
              pooling_function: BNNSPoolingFunction) {
    self.init(x_stride: x_stride,
              y_stride: y_stride,
              x_padding: x_padding,
              y_padding: y_padding,
              k_width: k_width,
              k_height: k_height,
              in_channels: in_channels,
              out_channels: out_channels,
              pooling_function: pooling_function,
              bias: .zero,
              activation: .identity)
  }
}

${available(bnns2016)}
extension BNNSFullyConnectedLayerParameters {
  ${available(bnns2016)}
  public init(in_size: Int,
              out_size: Int,
              weights: BNNSLayerData) {
    self.init(in_size: in_size,
              out_size: out_size,
              weights: weights,
              bias: .zero,
              activation: .identity)
  }
}