// // Copyright 2013 The Flutter Authors. All rights reserved.
// Autogenerated from Pigeon (v25.5.0), 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 deepEqualsWearEngineApi(_ 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 !deepEqualsWearEngineApi(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 !deepEqualsWearEngineApi(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 deepHashWearEngineApi(value: Any?, hasher: inout Hasher) {
  if let valueList = value as? [AnyHashable] {
     for item in valueList { deepHashWearEngineApi(value: item, hasher: &hasher) }
     return
  }

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

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

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

    

/// Generated class from Pigeon that represents data sent in messages.
struct WearDeviceInfo: Hashable {
  var deviceId: String? = nil
  var deviceName: String? = nil
  var isPaired: Bool? = nil
  var isReachable: Bool? = nil
  var isWatchAppInstalled: Bool? = nil


  // swift-format-ignore: AlwaysUseLowerCamelCase
  static func fromList(_ pigeonVar_list: [Any?]) -> WearDeviceInfo? {
    let deviceId: String? = nilOrValue(pigeonVar_list[0])
    let deviceName: String? = nilOrValue(pigeonVar_list[1])
    let isPaired: Bool? = nilOrValue(pigeonVar_list[2])
    let isReachable: Bool? = nilOrValue(pigeonVar_list[3])
    let isWatchAppInstalled: Bool? = nilOrValue(pigeonVar_list[4])

    return WearDeviceInfo(
      deviceId: deviceId,
      deviceName: deviceName,
      isPaired: isPaired,
      isReachable: isReachable,
      isWatchAppInstalled: isWatchAppInstalled
    )
  }
  func toList() -> [Any?] {
    return [
      deviceId,
      deviceName,
      isPaired,
      isReachable,
      isWatchAppInstalled,
    ]
  }
  static func == (lhs: WearDeviceInfo, rhs: WearDeviceInfo) -> Bool {
    return deepEqualsWearEngineApi(lhs.toList(), rhs.toList())  }
  func hash(into hasher: inout Hasher) {
    deepHashWearEngineApi(value: toList(), hasher: &hasher)
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct WatchTransformTheme: Hashable {
  var themeId: Int64
  var themeName: String
  var energeticDescription: String
  var energeticImage: FlutterStandardTypedData? = nil
  var energeticImageUrl: String? = nil
  var normalDescription: String
  var normalImage: FlutterStandardTypedData? = nil
  var normalImageUrl: String? = nil
  var slightStressfulDescription: String
  var slightStressfulImage: FlutterStandardTypedData? = nil
  var slightStressfulImageUrl: String? = nil
  var stressfulDescription: String
  var stressfulImage: FlutterStandardTypedData? = nil
  var stressfulImageUrl: String? = nil


  // swift-format-ignore: AlwaysUseLowerCamelCase
  static func fromList(_ pigeonVar_list: [Any?]) -> WatchTransformTheme? {
    let themeId = pigeonVar_list[0] as! Int64
    let themeName = pigeonVar_list[1] as! String
    let energeticDescription = pigeonVar_list[2] as! String
    let energeticImage: FlutterStandardTypedData? = nilOrValue(pigeonVar_list[3])
    let energeticImageUrl: String? = nilOrValue(pigeonVar_list[4])
    let normalDescription = pigeonVar_list[5] as! String
    let normalImage: FlutterStandardTypedData? = nilOrValue(pigeonVar_list[6])
    let normalImageUrl: String? = nilOrValue(pigeonVar_list[7])
    let slightStressfulDescription = pigeonVar_list[8] as! String
    let slightStressfulImage: FlutterStandardTypedData? = nilOrValue(pigeonVar_list[9])
    let slightStressfulImageUrl: String? = nilOrValue(pigeonVar_list[10])
    let stressfulDescription = pigeonVar_list[11] as! String
    let stressfulImage: FlutterStandardTypedData? = nilOrValue(pigeonVar_list[12])
    let stressfulImageUrl: String? = nilOrValue(pigeonVar_list[13])

    return WatchTransformTheme(
      themeId: themeId,
      themeName: themeName,
      energeticDescription: energeticDescription,
      energeticImage: energeticImage,
      energeticImageUrl: energeticImageUrl,
      normalDescription: normalDescription,
      normalImage: normalImage,
      normalImageUrl: normalImageUrl,
      slightStressfulDescription: slightStressfulDescription,
      slightStressfulImage: slightStressfulImage,
      slightStressfulImageUrl: slightStressfulImageUrl,
      stressfulDescription: stressfulDescription,
      stressfulImage: stressfulImage,
      stressfulImageUrl: stressfulImageUrl
    )
  }
  func toList() -> [Any?] {
    return [
      themeId,
      themeName,
      energeticDescription,
      energeticImage,
      energeticImageUrl,
      normalDescription,
      normalImage,
      normalImageUrl,
      slightStressfulDescription,
      slightStressfulImage,
      slightStressfulImageUrl,
      stressfulDescription,
      stressfulImage,
      stressfulImageUrl,
    ]
  }
  static func == (lhs: WatchTransformTheme, rhs: WatchTransformTheme) -> Bool {
    return deepEqualsWearEngineApi(lhs.toList(), rhs.toList())  }
  func hash(into hasher: inout Hasher) {
    deepHashWearEngineApi(value: toList(), hasher: &hasher)
  }
}

private class WearEngineApiPigeonCodecReader: FlutterStandardReader {
  override func readValue(ofType type: UInt8) -> Any? {
    switch type {
    case 129:
      return WearDeviceInfo.fromList(self.readValue() as! [Any?])
    case 130:
      return WatchTransformTheme.fromList(self.readValue() as! [Any?])
    default:
      return super.readValue(ofType: type)
    }
  }
}

private class WearEngineApiPigeonCodecWriter: FlutterStandardWriter {
  override func writeValue(_ value: Any) {
    if let value = value as? WearDeviceInfo {
      super.writeByte(129)
      super.writeValue(value.toList())
    } else if let value = value as? WatchTransformTheme {
      super.writeByte(130)
      super.writeValue(value.toList())
    } else {
      super.writeValue(value)
    }
  }
}

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

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

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


/// Generated protocol from Pigeon that represents a handler of messages from Flutter.
protocol WearEngineHostApi {
  func hasAvailableDevices() throws -> Bool
  func checkConnectedDevice(completion: @escaping (Result<WearDeviceInfo?, Error>) -> Void)
  func registerMessageReceiver() throws -> Bool
  func sendTextMessage(message: String) throws -> Bool
  /// 添加表盘
  func addWatchSurface(completion: @escaping (Result<Bool, Error>) -> Void)
  /// 添加或者删除主题
  func syncWatchTheme(theme: WatchTransformTheme?, completion: @escaping (Result<Bool, Error>) -> Void)
  /// Opens the system photo picker and returns a local PNG file path after
  /// removing the image background on the host platform.
  func removeBackground(originImagePath: String, completion: @escaping (Result<String?, Error>) -> Void)
  /// 是否有已安装的表盘
  func hasInstalledWatchSurface(completion: @escaping (Result<Bool, Error>) -> Void)
}

/// Generated setup class from Pigeon to handle messages through the `binaryMessenger`.
class WearEngineHostApiSetup {
  static var codec: FlutterStandardMessageCodec { WearEngineApiPigeonCodec.shared }
  /// Sets up an instance of `WearEngineHostApi` to handle messages through the `binaryMessenger`.
  static func setUp(binaryMessenger: FlutterBinaryMessenger, api: WearEngineHostApi?, messageChannelSuffix: String = "") {
    let channelSuffix = messageChannelSuffix.count > 0 ? ".\(messageChannelSuffix)" : ""
    let hasAvailableDevicesChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.hasAvailableDevices\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      hasAvailableDevicesChannel.setMessageHandler { _, reply in
        do {
          let result = try api.hasAvailableDevices()
          reply(wrapResult(result))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      hasAvailableDevicesChannel.setMessageHandler(nil)
    }
    let checkConnectedDeviceChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.checkConnectedDevice\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      checkConnectedDeviceChannel.setMessageHandler { _, reply in
        api.checkConnectedDevice { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      checkConnectedDeviceChannel.setMessageHandler(nil)
    }
    let registerMessageReceiverChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.registerMessageReceiver\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      registerMessageReceiverChannel.setMessageHandler { _, reply in
        do {
          let result = try api.registerMessageReceiver()
          reply(wrapResult(result))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      registerMessageReceiverChannel.setMessageHandler(nil)
    }
    let sendTextMessageChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.sendTextMessage\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      sendTextMessageChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let messageArg = args[0] as! String
        do {
          let result = try api.sendTextMessage(message: messageArg)
          reply(wrapResult(result))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      sendTextMessageChannel.setMessageHandler(nil)
    }
    /// 添加表盘
    let addWatchSurfaceChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.addWatchSurface\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      addWatchSurfaceChannel.setMessageHandler { _, reply in
        api.addWatchSurface { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      addWatchSurfaceChannel.setMessageHandler(nil)
    }
    /// 添加或者删除主题
    let syncWatchThemeChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.syncWatchTheme\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      syncWatchThemeChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let themeArg: WatchTransformTheme? = nilOrValue(args[0])
        api.syncWatchTheme(theme: themeArg) { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      syncWatchThemeChannel.setMessageHandler(nil)
    }
    /// Opens the system photo picker and returns a local PNG file path after
    /// removing the image background on the host platform.
    let removeBackgroundChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.removeBackground\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      removeBackgroundChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let originImagePathArg = args[0] as! String
        api.removeBackground(originImagePath: originImagePathArg) { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      removeBackgroundChannel.setMessageHandler(nil)
    }
    /// 是否有已安装的表盘
    let hasInstalledWatchSurfaceChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.doublefeel_flutter.WearEngineHostApi.hasInstalledWatchSurface\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      hasInstalledWatchSurfaceChannel.setMessageHandler { _, reply in
        api.hasInstalledWatchSurface { result in
          switch result {
          case .success(let res):
            reply(wrapResult(res))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      hasInstalledWatchSurfaceChannel.setMessageHandler(nil)
    }
  }
}