//===----------------------------------------------------------------------===//
//
// 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 Foundation // Clang module
@_implementationOnly import _SwiftFoundationOverlayShims

// We don't check for NSCopying here for performance reasons. We would
// just crash anyway, and NSMutableDictionary will still do that when
// it tries to call -copyWithZone: and it's not there
private func duckCastToNSCopying(_ x: Any) -> NSCopying {
  return _unsafeReferenceCast(x as AnyObject, to: NSCopying.self)
}

//===----------------------------------------------------------------------===//
// Dictionaries
//===----------------------------------------------------------------------===//

extension NSDictionary : ExpressibleByDictionaryLiteral {
  public required convenience init(
    dictionaryLiteral elements: (Any, Any)...
  ) {
    
    self.init(
      objects: elements.map { $0.1 as AnyObject },
      forKeys: elements.map { duckCastToNSCopying($0.0) },
      count: elements.count)
  }
}

extension Dictionary {
  /// Private initializer used for bridging.
  ///
  /// The provided `NSDictionary` will be copied to ensure that the copy can
  /// not be mutated by other code.
  private init(_cocoaDictionary: __shared NSDictionary) {
    assert(
      _isBridgedVerbatimToObjectiveC(Key.self) &&
      _isBridgedVerbatimToObjectiveC(Value.self),
      "Dictionary can be backed by NSDictionary storage only when both key and value are bridged verbatim to Objective-C")
    // FIXME: We would like to call CFDictionaryCreateCopy() to avoid doing an
    // objc_msgSend() for instances of CoreFoundation types.  We can't do that
    // today because CFDictionaryCreateCopy() copies dictionary contents
    // unconditionally, resulting in O(n) copies even for immutable dictionaries.
    //
    // <rdar://problem/20690755> CFDictionaryCreateCopy() does not call copyWithZone:
    //
    // The bug is fixed in: OS X 10.11.0, iOS 9.0, all versions of tvOS
    // and watchOS.
    self = Dictionary(
      _immutableCocoaDictionary: _cocoaDictionary.copy(with: nil) as AnyObject)
  }
}

// Dictionary<Key, Value> is conditionally bridged to NSDictionary
extension Dictionary : _ObjectiveCBridgeable {
  @_semantics("convertToObjectiveC")
  public func _bridgeToObjectiveC() -> NSDictionary {
    return unsafeBitCast(_bridgeToObjectiveCImpl(),
                         to: NSDictionary.self)
  }

  /***
  Precondition: `buffer` points to a region of memory bound to `AnyObject`,
    with a capacity large enough to fit at least `index`+1 elements of type `T`
  
  _bridgeInitialize rebinds the `index`th `T` of `buffer` to `T`,
    and initializes it to `value`

  Note: *not* the `index`th element of `buffer`, since T and AnyObject may be
  different sizes. e.g. if T is String (2 words) then given a buffer like so:

  [object:AnyObject, object:AnyObject, uninitialized, uninitialized]

  `_bridgeInitialize(1, of: buffer, to: buffer[1] as! T)` will leave it as:

  [object:AnyObject, object:AnyObject, string:String]

  and `_bridgeInitialize(0, of: buffer, to: buffer[0] as! T)` will then leave:

  [string:String, string:String]

  Doing this in reverse order as shown above is required if T and AnyObject are
  different sizes. Here's what we get if instead of 1, 0 we did 0, 1:

  [object:AnyObject, object:AnyObject, uninitialized, uninitialized]
  [string:String, uninitialized, uninitialized]
  <segfault trying to treat the second word of 'string' as an AnyObject>

  Note: if you have retained any of the objects in `buffer`, you must release
  them separately, _bridgeInitialize will overwrite them without releasing them
  */
  @inline(__always)
  private static func _bridgeInitialize<T>(index:Int,
    of buffer: UnsafePointer<AnyObject>, to value: T) {
    let typedBase = UnsafeMutableRawPointer(mutating:
                      buffer).assumingMemoryBound(to: T.self)
    let rawTarget = UnsafeMutableRawPointer(mutating: typedBase + index)
    rawTarget.initializeMemory(as: T.self, repeating: value, count: 1)
  }

  @inline(__always)
  private static func _verbatimForceBridge<T>(
    _ buffer: UnsafeMutablePointer<AnyObject>,
    count: Int,
    to: T.Type
  ) {
    //doesn't have to iterate in reverse because sizeof(T) == sizeof(AnyObject)
    for i in 0..<count {
      _bridgeInitialize(index: i, of: buffer, to: buffer[i] as! T)
    }
  }

  @inline(__always)
  private static func _verbatimBridge<T>(
    _ buffer: UnsafeMutablePointer<AnyObject>,
    count: Int,
    to type: T.Type
  ) -> Int {
    var numUninitialized = count
    while numUninitialized > 0 {
      guard let bridged = buffer[numUninitialized - 1] as? T else {
        return numUninitialized
      }
      numUninitialized -= 1
      _bridgeInitialize(index: numUninitialized, of: buffer, to: bridged)
    }
    return numUninitialized
  }

  @inline(__always)
  private static func _nonVerbatimForceBridge<T>(
    _ buffer: UnsafeMutablePointer<AnyObject>,
    count: Int,
    to: T.Type
  ) {
    for i in (0..<count).reversed() {
      let bridged = buffer[i] as! T
      _bridgeInitialize(index: i, of: buffer, to: bridged)
    }
  }
  
  @inline(__always)
  private static func _nonVerbatimBridge<T>(
    _ buffer: UnsafeMutablePointer<AnyObject>,
    count: Int,
    to: T.Type
  ) -> Int {
    var numUninitialized = count
    while numUninitialized > 0 {
      guard let bridged = Swift._conditionallyBridgeFromObjectiveC(
        buffer[numUninitialized - 1], T.self)
        else {
        return numUninitialized
      }
      numUninitialized -= 1
      _bridgeInitialize(index: numUninitialized, of: buffer, to: bridged)
    }
    return numUninitialized
  }

  @inline(__always)
  private static func _forceBridge<T>(
    _ buffer: UnsafeMutablePointer<AnyObject>,
    count: Int,
    to: T.Type
  ) {
    if _isBridgedVerbatimToObjectiveC(T.self) {
      _verbatimForceBridge(buffer, count: count, to: T.self)
    } else {
      _nonVerbatimForceBridge(buffer, count: count, to: T.self)
    }
  }
  
  @inline(__always)
  private static func _conditionallyBridge<T>(
    _ buffer: UnsafeMutablePointer<AnyObject>,
    count: Int,
    to: T.Type
  ) -> Bool {
    let numUninitialized:Int
    if _isBridgedVerbatimToObjectiveC(T.self) {
      numUninitialized = _verbatimBridge(buffer, count: count, to: T.self)
    } else {
      numUninitialized = _nonVerbatimBridge(buffer, count: count, to: T.self)
    }
    if numUninitialized == 0 {
      return true
    }
    let numInitialized = count - numUninitialized
    (UnsafeMutableRawPointer(mutating: buffer).assumingMemoryBound(to:
      T.self) + numUninitialized).deinitialize(count: numInitialized)
    return false
  }

  @_specialize(where Key == String, Value == Any)
  public static func _forceBridgeFromObjectiveC(
    _ d: NSDictionary,
    result: inout Dictionary?
  ) {
    if let native = [Key : Value]._bridgeFromObjectiveCAdoptingNativeStorageOf(
        d as AnyObject) {
      result = native
      return
    }

    if _isBridgedVerbatimToObjectiveC(Key.self) &&
       _isBridgedVerbatimToObjectiveC(Value.self) {
      //Lazily type-checked on access
      result = [Key : Value](_cocoaDictionary: d)
      return
    }

    let keyStride = MemoryLayout<Key>.stride
    let valueStride = MemoryLayout<Value>.stride
    let objectStride = MemoryLayout<AnyObject>.stride

    //If Key or Value are smaller than AnyObject, a Dictionary with N elements
    //doesn't have large enough backing stores to hold the objects to be bridged
    //For now we just handle that case the slow way.
    if keyStride < objectStride || valueStride < objectStride {
      var builder = _DictionaryBuilder<Key, Value>(count: d.count)
      d.enumerateKeysAndObjects({ (anyKey: Any, anyValue: Any, _) in
        builder.add(
          key: anyKey as! Key,
          value: anyValue as! Value)
      })
      result = builder.take()
    } else {
      defer { _fixLifetime(d) }
    
      let numElems = d.count
      
      // String and NSString have different concepts of equality, so
      // string-keyed NSDictionaries may generate key collisions when bridged
      // over to Swift. See rdar://problem/35995647
      let handleDuplicates = (Key.self == String.self)
      
      result = Dictionary(_unsafeUninitializedCapacity: numElems,
        allowingDuplicates: handleDuplicates) { keys, vals in
        
        let objectKeys = UnsafeMutableRawPointer(mutating:
          keys.baseAddress!).assumingMemoryBound(to: AnyObject.self)
        let objectVals = UnsafeMutableRawPointer(mutating:
          vals.baseAddress!).assumingMemoryBound(to: AnyObject.self)

        //This initializes the first N AnyObjects of the Dictionary buffers.
        //Any unused buffer space is left uninitialized
        //This is fixed up in-place as we bridge elements, by _bridgeInitialize
        __NSDictionaryGetObjects(d, objectVals, objectKeys, numElems)

        _forceBridge(objectKeys, count: numElems, to: Key.self)
        _forceBridge(objectVals, count: numElems, to: Value.self)
        
        return numElems
      }
    }
  }
  
  @_specialize(where Key == String, Value == Any)
  public static func _conditionallyBridgeFromObjectiveC(
    _ x: NSDictionary,
    result: inout Dictionary?
  ) -> Bool {

    if let native = [Key : Value]._bridgeFromObjectiveCAdoptingNativeStorageOf(
        x as AnyObject) {
      result = native
      return true
    }

    let keyStride = MemoryLayout<Key>.stride
    let valueStride = MemoryLayout<Value>.stride
    let objectStride = MemoryLayout<AnyObject>.stride

    //If Key or Value are smaller than AnyObject, a Dictionary with N elements
    //doesn't have large enough backing stores to hold the objects to be bridged
    //For now we just handle that case the slow way.
    if keyStride < objectStride || valueStride < objectStride {
      result = x as [NSObject : AnyObject] as? Dictionary
      return result != nil
    }

    defer { _fixLifetime(x) }
    
    let numElems = x.count
    var success = true
    
    // String and NSString have different concepts of equality, so
    // string-keyed NSDictionaries may generate key collisions when bridged
    // over to Swift. See rdar://problem/35995647
    let handleDuplicates = (Key.self == String.self)
    
    let tmpResult = Dictionary(_unsafeUninitializedCapacity: numElems,
      allowingDuplicates: handleDuplicates) { keys, vals in
      
      let objectKeys = UnsafeMutableRawPointer(mutating:
        keys.baseAddress!).assumingMemoryBound(to: AnyObject.self)
      let objectVals = UnsafeMutableRawPointer(mutating:
        vals.baseAddress!).assumingMemoryBound(to: AnyObject.self)

      //This initializes the first N AnyObjects of the Dictionary buffers.
      //Any unused buffer space is left uninitialized
      //This is fixed up in-place as we bridge elements, by _bridgeInitialize
      __NSDictionaryGetObjects(x, objectVals, objectKeys, numElems)

      success = _conditionallyBridge(objectKeys, count: numElems, to: Key.self)
      if success {
        success = _conditionallyBridge(objectVals,
                                       count: numElems, to: Value.self)
        if !success {
          (UnsafeMutableRawPointer(mutating: objectKeys).assumingMemoryBound(to:
            Key.self)).deinitialize(count: numElems)
        }
      }
      return success ? numElems : 0
    }
    
    result = success ? tmpResult : nil
    return success
  }

  @_effects(readonly)
  public static func _unconditionallyBridgeFromObjectiveC(
    _ d: NSDictionary?
  ) -> Dictionary {
    // `nil` has historically been used as a stand-in for an empty
    // dictionary; map it to an empty dictionary.
    if _slowPath(d == nil) { return Dictionary() }

    var result: Dictionary? = nil
    _forceBridgeFromObjectiveC(d!, result: &result)
    return result!
  }
}

extension NSDictionary : _HasCustomAnyHashableRepresentation {
  // Must be @nonobjc to avoid infinite recursion during bridging
  @nonobjc
  public func _toCustomAnyHashable() -> AnyHashable? {
    return AnyHashable(self as! Dictionary<AnyHashable, AnyHashable>)
  }
}

extension NSDictionary : Sequence {
  // FIXME: A class because we can't pass a struct with class fields through an
  // [objc] interface without prematurely destroying the references.
  // NOTE: older runtimes had
  // _TtCE10FoundationCSo12NSDictionary8Iterator as the ObjC name. The
  // two must coexist, so it was renamed. The old name must not be used
  // in the new runtime.
  @_objcRuntimeName(_TtCE10FoundationCSo12NSDictionary9_Iterator)
  final public class Iterator : IteratorProtocol {
    var _fastIterator: NSFastEnumerationIterator
    var _dictionary: NSDictionary {
      return _fastIterator.enumerable as! NSDictionary
    }

    public func next() -> (key: Any, value: Any)? {
      if let key = _fastIterator.next() {
        // Deliberately avoid the subscript operator in case the dictionary
        // contains non-copyable keys. This is rare since NSMutableDictionary
        // requires them, but we don't want to paint ourselves into a corner.
        return (key: key, value: _dictionary.object(forKey: key)!)
      }
      return nil
    }

    internal init(_ _dict: __shared NSDictionary) {
      _fastIterator = NSFastEnumerationIterator(_dict)
    }
  }

  // Bridging subscript.
  @objc
  public subscript(key: Any) -> Any? {
    @objc(__swift_objectForKeyedSubscript:)
    get {
      // Deliberately avoid the subscript operator in case the dictionary
      // contains non-copyable keys. This is rare since NSMutableDictionary
      // requires them, but we don't want to paint ourselves into a corner.
      return self.object(forKey: key)
    }
  }

  /// Return an *iterator* over the elements of this *sequence*.
  ///
  /// - Complexity: O(1).
  public func makeIterator() -> Iterator {
    return Iterator(self)
  }
}

extension NSMutableDictionary {
  // Bridging subscript.
  @objc override public subscript(key: Any) -> Any? {
    @objc(__swift_objectForKeyedSubscript:)
    get {
      return self.object(forKey: key)
    }
    @objc(__swift_setObject:forKeyedSubscript:)
    set {
      let copyingKey = duckCastToNSCopying(key)
      if let newValue = newValue {
        self.setObject(newValue, forKey: copyingKey)
      } else {
        self.removeObject(forKey: copyingKey)
      }
    }
  }
}

extension NSDictionary {
  /// Initializes a newly allocated dictionary and adds to it objects from
  /// another given dictionary.
  ///
  /// - Returns: An initialized dictionary--which might be different
  ///   than the original receiver--containing the keys and values
  ///   found in `otherDictionary`.
  @objc(__swiftInitWithDictionary_NSDictionary:)
  public convenience init(dictionary otherDictionary: __shared NSDictionary) {
    // FIXME(performance)(compiler limitation): we actually want to do just
    // `self = otherDictionary.copy()`, but Swift does not have factory
    // initializers right now.
    let numElems = otherDictionary.count
    let stride = MemoryLayout<AnyObject>.stride
    let alignment = MemoryLayout<AnyObject>.alignment
    let singleSize = stride * numElems
    let totalSize = singleSize * 2
    assert(stride == MemoryLayout<NSCopying>.stride)
    assert(alignment == MemoryLayout<NSCopying>.alignment)

    // Allocate a buffer containing both the keys and values.
    let buffer = UnsafeMutableRawPointer.allocate(
      byteCount: totalSize, alignment: alignment)
    defer {
      buffer.deallocate()
      _fixLifetime(otherDictionary)
    }

    let valueBuffer = buffer.bindMemory(to: AnyObject.self, capacity: numElems)
    let buffer2 = buffer + singleSize

    __NSDictionaryGetObjects(otherDictionary, buffer, buffer2, numElems)

    let keyBufferCopying = buffer2.assumingMemoryBound(to: NSCopying.self)
    self.init(objects: valueBuffer, forKeys: keyBufferCopying, count: numElems)
  }
}

extension NSDictionary : CustomReflectable {
  public var customMirror: Mirror {
    return Mirror(reflecting: self as [NSObject : AnyObject])
  }
}

extension Dictionary: CVarArg {}