// Autogenerated from Pigeon (v26.0.2), do not edit directly.
// See also: https://pub.dev/packages/pigeon

import Foundation

#if os(iOS)
  import Flutter
#elseif os(macOS)
  import FlutterMacOS
#else
  #error("Unsupported platform.")
#endif

private func wrapResult(_ result: Any?) -> [Any?] {
  return [result]
}

private func wrapError(_ error: Any) -> [Any?] {
  if let pigeonError = error as? PigeonError {
    return [
      pigeonError.code,
      pigeonError.message,
      pigeonError.details,
    ]
  }
  if let flutterError = error as? FlutterError {
    return [
      flutterError.code,
      flutterError.message,
      flutterError.details,
    ]
  }
  return [
    "\(error)",
    "\(type(of: error))",
    "Stacktrace: \(Thread.callStackSymbols)",
  ]
}

private func isNullish(_ value: Any?) -> Bool {
  return value is NSNull || value == nil
}

private func nilOrValue<T>(_ value: Any?) -> T? {
  if value is NSNull { return nil }
  return value as! T?
}

func deepEqualsUploadTask(_ lhs: Any?, _ rhs: Any?) -> Bool {
  let cleanLhs = nilOrValue(lhs) as Any?
  let cleanRhs = nilOrValue(rhs) as Any?
  switch (cleanLhs, cleanRhs) {
  case (nil, nil):
    return true

  case (nil, _), (_, nil):
    return false

  case is (Void, Void):
    return true

  case let (cleanLhsHashable, cleanRhsHashable) as (AnyHashable, AnyHashable):
    return cleanLhsHashable == cleanRhsHashable

  case let (cleanLhsArray, cleanRhsArray) as ([Any?], [Any?]):
    guard cleanLhsArray.count == cleanRhsArray.count else { return false }
    for (index, element) in cleanLhsArray.enumerated() {
      if !deepEqualsUploadTask(element, cleanRhsArray[index]) {
        return false
      }
    }
    return true

  case let (cleanLhsDictionary, cleanRhsDictionary) as ([AnyHashable: Any?], [AnyHashable: Any?]):
    guard cleanLhsDictionary.count == cleanRhsDictionary.count else { return false }
    for (key, cleanLhsValue) in cleanLhsDictionary {
      guard cleanRhsDictionary.index(forKey: key) != nil else { return false }
      if !deepEqualsUploadTask(cleanLhsValue, cleanRhsDictionary[key]!) {
        return false
      }
    }
    return true

  default:
    // Any other type shouldn't be able to be used with pigeon. File an issue if you find this to be untrue.
    return false
  }
}

func deepHashUploadTask(value: Any?, hasher: inout Hasher) {
  if let valueList = value as? [AnyHashable] {
     for item in valueList { deepHashUploadTask(value: item, hasher: &hasher) }
     return
  }

  if let valueDict = value as? [AnyHashable: AnyHashable] {
    for key in valueDict.keys { 
      hasher.combine(key)
      deepHashUploadTask(value: valueDict[key]!, hasher: &hasher)
    }
    return
  }

  if let hashableValue = value as? AnyHashable {
    hasher.combine(hashableValue.hashValue)
  }

  return hasher.combine(String(describing: value))
}

    

enum UploadApiErrorCode: Int {
  case unknown = 0
  case assetNotFound = 1
  case fileNotFound = 2
  case resourceNotFound = 3
  case invalidResource = 4
  case encodingFailed = 5
  case writeFailed = 6
  case notEnoughSpace = 7
  case networkError = 8
  case photosInternalError = 9
  case photosUnknownError = 10
  case interrupted = 11
  case cancelled = 12
  case downloadStalled = 13
  case forceQuit = 14
  case outOfResources = 15
  case backgroundUpdatesDisabled = 16
  case uploadTimeout = 17
  case iCloudRateLimit = 18
  case iCloudThrottled = 19
  case invalidResponse = 20
  case badRequest = 21
  case internalServerError = 22
  case unauthorized = 23
}

enum UploadApiStatus: Int {
  case downloadPending = 0
  case downloadQueued = 1
  case downloadFailed = 2
  case uploadPending = 3
  case uploadQueued = 4
  case uploadFailed = 5
  case uploadComplete = 6
  case uploadSkipped = 7
}

/// Generated class from Pigeon that represents data sent in messages.
struct UploadApiTaskStatus: Hashable {
  var id: String
  var filename: String
  var status: UploadApiStatus
  var errorCode: UploadApiErrorCode? = nil
  var httpStatusCode: Int64? = nil


  // swift-format-ignore: AlwaysUseLowerCamelCase
  static func fromList(_ pigeonVar_list: [Any?]) -> UploadApiTaskStatus? {
    let id = pigeonVar_list[0] as! String
    let filename = pigeonVar_list[1] as! String
    let status = pigeonVar_list[2] as! UploadApiStatus
    let errorCode: UploadApiErrorCode? = nilOrValue(pigeonVar_list[3])
    let httpStatusCode: Int64? = nilOrValue(pigeonVar_list[4])

    return UploadApiTaskStatus(
      id: id,
      filename: filename,
      status: status,
      errorCode: errorCode,
      httpStatusCode: httpStatusCode
    )
  }
  func toList() -> [Any?] {
    return [
      id,
      filename,
      status,
      errorCode,
      httpStatusCode,
    ]
  }
  static func == (lhs: UploadApiTaskStatus, rhs: UploadApiTaskStatus) -> Bool {
    return deepEqualsUploadTask(lhs.toList(), rhs.toList())  }
  func hash(into hasher: inout Hasher) {
    deepHashUploadTask(value: toList(), hasher: &hasher)
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct UploadApiTaskProgress: Hashable {
  var id: String
  var progress: Double
  var speed: Double? = nil
  var totalBytes: Int64? = nil


  // swift-format-ignore: AlwaysUseLowerCamelCase
  static func fromList(_ pigeonVar_list: [Any?]) -> UploadApiTaskProgress? {
    let id = pigeonVar_list[0] as! String
    let progress = pigeonVar_list[1] as! Double
    let speed: Double? = nilOrValue(pigeonVar_list[2])
    let totalBytes: Int64? = nilOrValue(pigeonVar_list[3])

    return UploadApiTaskProgress(
      id: id,
      progress: progress,
      speed: speed,
      totalBytes: totalBytes
    )
  }
  func toList() -> [Any?] {
    return [
      id,
      progress,
      speed,
      totalBytes,
    ]
  }
  static func == (lhs: UploadApiTaskProgress, rhs: UploadApiTaskProgress) -> Bool {
    return deepEqualsUploadTask(lhs.toList(), rhs.toList())  }
  func hash(into hasher: inout Hasher) {
    deepHashUploadTask(value: toList(), hasher: &hasher)
  }
}

private class UploadTaskPigeonCodecReader: FlutterStandardReader {
  override func readValue(ofType type: UInt8) -> Any? {
    switch type {
    case 129:
      let enumResultAsInt: Int? = nilOrValue(self.readValue() as! Int?)
      if let enumResultAsInt = enumResultAsInt {
        return UploadApiErrorCode(rawValue: enumResultAsInt)
      }
      return nil
    case 130:
      let enumResultAsInt: Int? = nilOrValue(self.readValue() as! Int?)
      if let enumResultAsInt = enumResultAsInt {
        return UploadApiStatus(rawValue: enumResultAsInt)
      }
      return nil
    case 131:
      return UploadApiTaskStatus.fromList(self.readValue() as! [Any?])
    case 132:
      return UploadApiTaskProgress.fromList(self.readValue() as! [Any?])
    default:
      return super.readValue(ofType: type)
    }
  }
}

private class UploadTaskPigeonCodecWriter: FlutterStandardWriter {
  override func writeValue(_ value: Any) {
    if let value = value as? UploadApiErrorCode {
      super.writeByte(129)
      super.writeValue(value.rawValue)
    } else if let value = value as? UploadApiStatus {
      super.writeByte(130)
      super.writeValue(value.rawValue)
    } else if let value = value as? UploadApiTaskStatus {
      super.writeByte(131)
      super.writeValue(value.toList())
    } else if let value = value as? UploadApiTaskProgress {
      super.writeByte(132)
      super.writeValue(value.toList())
    } else {
      super.writeValue(value)
    }
  }
}

private class UploadTaskPigeonCodecReaderWriter: FlutterStandardReaderWriter {
  override func reader(with data: Data) -> FlutterStandardReader {
    return UploadTaskPigeonCodecReader(data: data)
  }

  override func writer(with data: NSMutableData) -> FlutterStandardWriter {
    return UploadTaskPigeonCodecWriter(data: data)
  }
}

class UploadTaskPigeonCodec: FlutterStandardMessageCodec, @unchecked Sendable {
  static let shared = UploadTaskPigeonCodec(readerWriter: UploadTaskPigeonCodecReaderWriter())
}

var uploadTaskPigeonMethodCodec = FlutterStandardMethodCodec(readerWriter: UploadTaskPigeonCodecReaderWriter());


/// Generated protocol from Pigeon that represents a handler of messages from Flutter.
protocol UploadApi {
  func initialize(completion: @escaping (Result<Void, Error>) -> Void)
  func refresh(completion: @escaping (Result<Void, Error>) -> Void)
  func cancelAll(completion: @escaping (Result<Void, Error>) -> Void)
  func enqueueAssets(localIds: [String], completion: @escaping (Result<Void, Error>) -> Void)
  func enqueueFiles(paths: [String], completion: @escaping (Result<Void, Error>) -> Void)
  func onConfigChange(key: Int64, completion: @escaping (Result<Void, Error>) -> Void)
}

/// Generated setup class from Pigeon to handle messages through the `binaryMessenger`.
class UploadApiSetup {
  static var codec: FlutterStandardMessageCodec { UploadTaskPigeonCodec.shared }
  /// Sets up an instance of `UploadApi` to handle messages through the `binaryMessenger`.
  static func setUp(binaryMessenger: FlutterBinaryMessenger, api: UploadApi?, messageChannelSuffix: String = "") {
    let channelSuffix = messageChannelSuffix.count > 0 ? ".\(messageChannelSuffix)" : ""
    let initializeChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.UploadApi.initialize\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      initializeChannel.setMessageHandler { _, reply in
        api.initialize { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      initializeChannel.setMessageHandler(nil)
    }
    let refreshChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.UploadApi.refresh\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      refreshChannel.setMessageHandler { _, reply in
        api.refresh { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      refreshChannel.setMessageHandler(nil)
    }
    let cancelAllChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.UploadApi.cancelAll\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      cancelAllChannel.setMessageHandler { _, reply in
        api.cancelAll { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      cancelAllChannel.setMessageHandler(nil)
    }
    let enqueueAssetsChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.UploadApi.enqueueAssets\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      enqueueAssetsChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let localIdsArg = args[0] as! [String]
        api.enqueueAssets(localIds: localIdsArg) { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      enqueueAssetsChannel.setMessageHandler(nil)
    }
    let enqueueFilesChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.UploadApi.enqueueFiles\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      enqueueFilesChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let pathsArg = args[0] as! [String]
        api.enqueueFiles(paths: pathsArg) { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      enqueueFilesChannel.setMessageHandler(nil)
    }
    let onConfigChangeChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.UploadApi.onConfigChange\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      onConfigChangeChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let keyArg = args[0] as! Int64
        api.onConfigChange(key: keyArg) { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      onConfigChangeChannel.setMessageHandler(nil)
    }
  }
}

private class PigeonStreamHandler<ReturnType>: NSObject, FlutterStreamHandler {
  private let wrapper: PigeonEventChannelWrapper<ReturnType>
  private var pigeonSink: PigeonEventSink<ReturnType>? = nil

  init(wrapper: PigeonEventChannelWrapper<ReturnType>) {
    self.wrapper = wrapper
  }

  func onListen(withArguments arguments: Any?, eventSink events: @escaping FlutterEventSink)
    -> FlutterError?
  {
    pigeonSink = PigeonEventSink<ReturnType>(events)
    wrapper.onListen(withArguments: arguments, sink: pigeonSink!)
    return nil
  }

  func onCancel(withArguments arguments: Any?) -> FlutterError? {
    pigeonSink = nil
    wrapper.onCancel(withArguments: arguments)
    return nil
  }
}

class PigeonEventChannelWrapper<ReturnType> {
  func onListen(withArguments arguments: Any?, sink: PigeonEventSink<ReturnType>) {}
  func onCancel(withArguments arguments: Any?) {}
}

class PigeonEventSink<ReturnType> {
  private let sink: FlutterEventSink

  init(_ sink: @escaping FlutterEventSink) {
    self.sink = sink
  }

  func success(_ value: ReturnType) {
    sink(value)
  }

  func error(code: String, message: String?, details: Any?) {
    sink(FlutterError(code: code, message: message, details: details))
  }

  func endOfStream() {
    sink(FlutterEndOfEventStream)
  }

}

class StreamStatusStreamHandler: PigeonEventChannelWrapper<UploadApiTaskStatus> {
  static func register(with messenger: FlutterBinaryMessenger,
                      instanceName: String = "",
                      streamHandler: StreamStatusStreamHandler) {
    var channelName = "dev.flutter.pigeon.immich_mobile.UploadFlutterApi.streamStatus"
    if !instanceName.isEmpty {
      channelName += ".\(instanceName)"
    }
    let internalStreamHandler = PigeonStreamHandler<UploadApiTaskStatus>(wrapper: streamHandler)
    let channel = FlutterEventChannel(name: channelName, binaryMessenger: messenger, codec: uploadTaskPigeonMethodCodec)
    channel.setStreamHandler(internalStreamHandler)
  }
}
      
class StreamProgressStreamHandler: PigeonEventChannelWrapper<UploadApiTaskProgress> {
  static func register(with messenger: FlutterBinaryMessenger,
                      instanceName: String = "",
                      streamHandler: StreamProgressStreamHandler) {
    var channelName = "dev.flutter.pigeon.immich_mobile.UploadFlutterApi.streamProgress"
    if !instanceName.isEmpty {
      channelName += ".\(instanceName)"
    }
    let internalStreamHandler = PigeonStreamHandler<UploadApiTaskProgress>(wrapper: streamHandler)
    let channel = FlutterEventChannel(name: channelName, binaryMessenger: messenger, codec: uploadTaskPigeonMethodCodec)
    channel.setStreamHandler(internalStreamHandler)
  }
}