import Foundation

/// CodableVariable wraps a `Codable` instance to make it compatible with @objc methods.
///
/// `Codable` documentation: https://developer.apple.com/documentation/swift/codable
///
/// The Swift compiler doesn't allow developers to declare an @objc method for eDO as below:
///
///   ```
///   @objc public FooClass : NSObject {
///     @objc public func callBar(value: Int?) // Compile Error!
///   }
///   ```
///
/// The same issue also applies to other auto-synthesized Codable types, including classes, structs
/// and enums (Swift 5.5+). This is because Optional<Int> is a pure Swift type that cannot be
/// represented in Objective-C land. As a workaround, developers can declare a new method in the
/// class extension as below:
///
///   ```
///   extension FooClass {
///     @objc public func callBar(codedValue: CodableVariable) throws {
///       self.callBar(value: try codedValue.unwrap(Int?.self))
///     }
///   }
///   ```
///
/// The new method is compatible with @objc and forwards the coded variables to the original method.
/// So developers can use the new method in the remote call:
///
///   ```
///   var value : Int?
///   // Do something...
///   try remoteFooInstance.callBar(codedValue: try CodableVariable.wrap(value))
///   ```
@objc(EDOCodableVariable)
public class CodableVariable: NSObject, NSSecureCoding, Codable {

  /// Error thrown by `CodableVariable` during the decoding.
  public enum DecodingError: Error, LocalizedError {
    /// The type of encoded data doesn't match the caller's expecting type.
    /// - expectedType: The type expected by the decoding method caller.
    /// - actualType: The type of the encoded data.
    case typeUnmatched(expectedType: String, actualType: String)

    public var errorDescription: String? {
      switch self {
      case let .typeUnmatched(expectedType, actualType):
        return "Expecting to decode \(expectedType) but the codable variable is \(actualType)."
      }
    }
  }

  internal static let typeKey = "EDOTypeKey"
  internal let data: Data
  internal let type: String

  /// Creates `CodableVariable` instance with a `Codable` instance.
  ///
  /// - Parameter parameter: The Codable instance to be wrapped.
  /// - Returns: A `CodableVariable` instance.
  /// - Throws: Errors propagated from JSONEncoder when encoding `parameter`.
  public static func wrap<T: Encodable>(_ parameter: T) throws -> CodableVariable {
    let encoder = JSONEncoder()
    return CodableVariable(data: try encoder.encode(parameter), type: String(describing: T.self))
  }

  internal init(data: Data, type: String) {
    self.data = data
    self.type = type
  }

  /// Decodes the Codable instance.
  ///
  /// - Parameter type: The expected type of the decoded instance.
  /// - Returns: The decoded instance of `type`.
  /// - Throws: `CodableVariable.DecodingError` if decoding fails.
  public func unwrap<T: Decodable>() throws -> T {
    guard self.type == String(describing: T.self) else {
      throw DecodingError.typeUnmatched(
        expectedType: self.type,
        actualType: String(describing: T.self))
    }
    let decoder = JSONDecoder()
    return try decoder.decode(T.self, from: data)
  }

  // MARK - NSSecureCoding

  public required init?(coder: NSCoder) {
    guard let data = coder.decodeData(),
      let type = coder.decodeObject(forKey: CodableVariable.typeKey) as? String
    else {
      return nil
    }
    self.data = data
    self.type = type
  }

  public func encode(with coder: NSCoder) {
    coder.encode(data)
    coder.encode(type, forKey: CodableVariable.typeKey)
  }

  @objc public override var edo_isEDOValueType: Bool { return true }

  @objc public static var supportsSecureCoding: Bool { return true }
}

/// Extends Encodable to easily produce `CodableVariable` from the instance.
extension Encodable {
  /// Produces a `CodableVariable` instance from `self`.
  public var eDOCodableVariable: CodableVariable {
    // try! is used here because`CodableVariable.wrap` only throws programmer errors when
    // JSONEncoder fails to encode a `Encodable` type.
    return try! CodableVariable.wrap(self)
  }
}

extension Array where Element: AnyObject {
  // Workaround to interact with a Swift array obtained via eDO to avoid the type mismatch failure
  // when bridging between NSArray and Swift Array.
  public var localArray: Self {
    (self as [AnyObject]).map { unsafeBitCast($0, to: Element.self) }
  }
}