import CoreMotion
import DolphinMoveSDK

#if canImport(DolphinMoveSDKHealth)
import DolphinMoveSDKHealth
#endif

/// Move SDK instance singleton delegate.
@objc public protocol MoveSDKDelegate {
	/// Send event to observer.
	/// - Parameters:
	///   - event: Event key.
	///   - data: Event object.
	@objc func send(event: String, data: Any)
}

/// Wrapper `MoveOptions` key.
@objc public enum MoveSdkOptionKey: Int {
	public typealias RawValue = Int
	case startDelay
	case interval
	case duration
	case stopScanOnFirstDiscovered
	case motionPermissionMandatory
	case backgroundLocationPermissionMandatory
	case useBackendConfig
	case ensureSynced
}

/// Wrapper `MoveOptions` key value pair.
@objc public class MoveSdkOption: NSObject {
	@objc let key: MoveSdkOptionKey
	@objc let value: NSNumber

	@objc public init(key: MoveSdkOptionKey, value: NSNumber) {
		self.key = key
		self.value = value
		super.init()
	}

	override public init() {
		fatalError()
	}
}

/// Wrapper error object.
@objc public class MoveSdkError: NSObject {
	@objc public let title: String
	@objc public let text: String

	init(_ title: String, text: String? = nil) {
		self.title = title
		self.text = text ?? title
		super.init()
	}

	/// Address resolution failed.
	static var resolveFailed = MoveSdkError("RESOLVE_FAILED")
	/// Service unavailable.
	static var serviceUnavailable = MoveSdkError("SERVICE_UNAVAILABLE")
	/// Thershold reached.
	static var thresholdReached = MoveSdkError("THRESHOLD_REACHED")
	/// Geolookup error.
	static var geocodeError = MoveSdkError("GEOCODE_ERROR")
	/// SDK Authentication invalid.
	static var authInvalid = MoveSdkError("AUTH_INVALID")
	/// Initialization error.
	static var initializationError = MoveSdkError("INITIALIZATION_ERROR")
	/// Location error.
	static var locationError = MoveSdkError("LOCATION_ERROR")
	/// Network error.
	static var networkError = MoveSdkError("NETWORK_ERROR")
	/// Assistance call failed.
	static var assistanceCallError = MoveSdkError("ASSISTANCE_CALL_ERROR")
	/// Configuration error.
	static var configurationError = MoveSdkError("CONFIGURATION_ERROR")
	/// SDK uninitialized.
	static var uninitialized = MoveSdkError("UNINITIALIZED")

	/// Other error.
	static func otherError(title: String, text: String) -> MoveSdkError {
		MoveSdkError(title, text: text)
	}

	/// SDK setup error.
	static func setupError(text: String) -> MoveSdkError {
		MoveSdkError("SETUP_ERROR", text: text)
	}
}

/// Singleton Move SDK instance wrapper.
@objc public class MoveSDKInstance: NSObject {
	public typealias ErrorListItem = [String: Any]

	/// Sent event identifiers to React Native.
	internal enum Event: String, CaseIterable {
		/// App event.
		case appEvent = "MOVE_SDK_APP_EVENT"
		/// SDK state change event.
		case sdkState = "MOVE_SDK_STATE"
		/// SDK trip state change event.
		case tripState = "MOVE_SDK_TRIP_STATE"
		/// SDK auth state change event.
		case authState = "MOVE_SDK_AUTH_STATE"
		/// SDK warning listener event.
		case warning = "MOVE_SDK_WARNINGS"
		/// SDK failure listener event.
		case failure = "MOVE_SDK_ERRORS"
		/// SDK detected devices event.
		case devices = "MOVE_SDK_DEVICES"
		/// Device scanning event.
		case scanResult = "MOVE_SDK_SCAN_RESULT"
		/// Device state event.
		case deviceState = "MOVE_SDK_DEVICE_STATE"
		/// SDK configuration update event.
		case configUpdate = "MOVE_SDK_CONFIG_UPDATE"
		/// SDK trip start event.
		case tripStart = "MOVE_SDK_TRIP_START"
		/// Log event.
		case logEvent = "MOVE_SDK_LOG"
		/// SDK health listener event.
		case health = "MOVE_SDK_HEALTH"
	}

	/// Move SDK service identifiers.
	private enum ServiceName: String {
		/// Driving detection service.
		case driving = "DRIVING"
		/// Driving behavior subservice.
		case drivingBehavior = "DRIVING_BEHAVIOUR"
		/// Distraction free driving subservice.
		case distractionFreeDriving = "DISTRACTION_FREE_DRIVING"
		/// Device discovery subservice.
		case deviceDiscovery = "DEVICE_DISCOVERY"
		/// Walking detection service.
		case walking = "WALKING"
		/// Walking location subservice.
		case walkingLocation = "WALKING_LOCATION"
		/// Cycling detection service.
		case cycling = "CYCLING"
		/// Public transport service.
		case publicTransport = "PUBLIC_TRANSPORT"
		/// Places service.
		case places = "PLACES"
		/// Assistance call service.
		case assistanceCall = "ASSISTANCE_CALL"
		/// Points of interest service.
		case pointsOfInterest = "POINTS_OF_INTEREST"
		/// Automatic impact detection.
		case automaticImpactDetection = "AUTOMATIC_IMPACT_DETECTION"
		/// Health steps service.
		case health = "HEALTH"
	}

	/// User defaults kets.
	private enum DefaultsKey: String {
		/// Persisted auth object.
		case auth = "MOVE.WRAPPER.AUTH"
		/// Persisted config object.
		case config = "MOVE.WRAPPER.CONFIG"
		/// Persisted trip metadata.
		case metaData = "MOVE.WRAPPER.TRIP.METADATA"
	}

	/// Shared wrapper instance.
	@objc public static let shared = MoveSDKInstance()

	/// Device Scanner.
	private lazy var scanner = MoveSdkDeviceScanner()

	/// Motion mananger for motion permission.
	private lazy var motionManager = CMMotionActivityManager()

	/// Bluetooth manager for permission.
	private lazy var bluetoothManager = MoveSdkBluetoothManager()

	/// Move SDK Singleton.
	private let sdk: MoveSDK

	/// Pending events triggered before event observer registered.
	private var pendingEvents: [Event: Any]

	/// Persisted trip metadata.
	private var tripMetaData: [String: String] {
		didSet {
			MoveSDKInstance.encode(tripMetaData, forKey: .metaData)
		}
	}

	/// Objc delegate.
	@objc public weak var delegate: MoveSDKDelegate? {
		didSet {
			for (key, value) in pendingEvents {
				delegate?.send(event: key.rawValue, data: value)
			}
		}
	}

	/// NSObject init function.
	public override init() {
		sdk = MoveSDK.shared
		pendingEvents = [:]
		delegate = nil
		tripMetaData = MoveSDKInstance.decode(.metaData) ?? [:]

		super.init()

		sdk.setSDKStateListener { state in
			let value = "\(state)".uppercased()
			self.send(event: .sdkState, data: ["state": "\(value)"])
		}

		sdk.setTripStateListener { state in
			let value = "\(state)".uppercased()
			self.send(event: .tripState, data: ["state": "\(value)"])
		}

		sdk.setTripStartListener { date in
			self.send(event: .tripStart, data: Int64(date.timeIntervalSince1970 * 1000.0))
		}

		sdk.setAuthStateUpdateListener { state in
			let value = "\(state)".uppercased()
			self.send(event: .authState, data: ["state": "\(value)"])
		}

		sdk.setServiceFailureListener { failures in
			let data: [String: Any] = ["errors": self.convert(failures: failures)]
			self.send(event: .failure, data: data)
		}

		sdk.setServiceWarningListener { warnings in
			let data: [String: Any] = ["warnings": self.convert(warnings: warnings)]
			self.send(event: .warning, data: data)
		}

		sdk.setDeviceDiscoveryListener { scanResults in
			let data = self.convert(scanResults: scanResults)
			self.send(event: .scanResult, data: data)
		}

		sdk.setDeviceStateListener { results in
			let data = self.convert(devices: results)
			self.send(event: .deviceState, data: data)
		}

		sdk.setRemoteConfigChangeListener { config in
			let services: [String] = config.services.reduce([]) { $0 + self.convert(service: $1, base: true) }
			let data = ["services": services]
			self.send(event: .configUpdate, data: data)
		}

		sdk.setTripMetaDataListener { tripStart, tripEnd in
			let metadata = self.tripMetaData
			self.tripMetaData = [:]
			return metadata
		}

		sdk.setLogListener { (event, value) in
			DispatchQueue.main.async {
				var data: [String: Any] = ["message": event]

				if let value = value {
					data["value"] = value
				}

				self.send(event: .logEvent, data: data)
			}
		}

		sdk.setHealthScoreListener { items in
			let data: [[String: String]] = items.map {
				["reason": $0.reason.rawValue.snakeCased(), "description": $0.description]
			}
			self.send(event: .health, data: data)
		}
	}

	/// Convert service strings to config subroutine.
	/// - Parameters:
	///   - timelineDetectionServices: Timeline services strings.
	///   - drivingServices: Driving services strings.
	///   - walkingServices: Walking services strings
	/// - Returns: `MoveConfig` for setup.
	private func convert(timelineDetectionServices: Array<String>,
						 drivingServices: Array<String>,
						 walkingServices: Array<String>) -> MoveConfig {

		let transformedServices: [MoveConfig.DrivingService] = drivingServices.compactMap {
			switch $0 {
			case ServiceName.distractionFreeDriving.rawValue:
				return .distractionFreeDriving
			case ServiceName.drivingBehavior.rawValue:
				return .drivingBehavior
			case ServiceName.deviceDiscovery.rawValue:
				return .deviceDiscovery
			default:
				return nil
			}
		}

		let transformedWalkingServices: [MoveConfig.WalkingService] = walkingServices.compactMap {
			if $0 == ServiceName.walkingLocation.rawValue {
				return .location
			}
			return nil
		}

		let transformedDetectionServices: [MoveConfig.DetectionService] = timelineDetectionServices.compactMap {
			switch $0 {
			case ServiceName.driving.rawValue:
				return .driving(transformedServices)
			case ServiceName.walking.rawValue:
				return .walking(transformedWalkingServices)
			case ServiceName.cycling.rawValue:
				return .cycling
			case ServiceName.publicTransport.rawValue:
				return .publicTransport
			case ServiceName.assistanceCall.rawValue:
				return .assistanceCall
			case ServiceName.pointsOfInterest.rawValue:
				return .pointsOfInterest
			case ServiceName.places.rawValue:
				return .places
			case ServiceName.automaticImpactDetection.rawValue:
				return .automaticImpactDetection
			case ServiceName.health.rawValue:
				return .health
			default:
				return nil
			}
		}

		return MoveConfig(detectionService: transformedDetectionServices)
	}

	/// Convert options json dict to `MoveOptions` object.
	/// - Returns: Converted options object.
	private func convert(options: [MoveSdkOption]) -> MoveOptions {
		let moveOptions = MoveOptions()

		for option in options {
			switch option.key {
			case .startDelay:
				moveOptions.deviceDiscovery.startDelay = option.value.doubleValue
			case .interval:
				moveOptions.deviceDiscovery.interval = option.value.doubleValue
			case .duration:
				moveOptions.deviceDiscovery.duration = option.value.doubleValue
			case .stopScanOnFirstDiscovered:
				moveOptions.deviceDiscovery.stopScanOnFirstDiscovered = option.value.boolValue
			case .ensureSynced:
				moveOptions.deviceDiscovery.ensureSynced = option.value.boolValue
			case .motionPermissionMandatory:
				moveOptions.motionPermissionMandatory = option.value.boolValue
			case .backgroundLocationPermissionMandatory:
				moveOptions.backgroundLocationPermissionMandatory = option.value.boolValue
			case .useBackendConfig:
				moveOptions.useBackendConfig = option.value.boolValue
			}
		}

		return moveOptions
	}


	/// Serialize SDK service failures.
	/// - Parameters:
	///   - failures: Move service failures to be serialized.
	///
	/// - Returns: List of error list items.
	///
	/// Used in `MoveSDK.getServiceFailures()` and service failure listener.
	fileprivate func convert(failures: [DolphinMoveSDK.MoveServiceFailure]) -> [ErrorListItem] {
		var converted: [ErrorListItem] = []

		for failure in failures {
			var reasons: [String] = []
			switch failure.reason {
			case let .missingPermission(permissions):
				let content: [String] = permissions.map { self.permissionString($0) }
				reasons = content
			case .unauthorized:
				reasons = ["Unauthorized"]
			}
			let services = convert(service: failure.service)
			for service in services {
				converted.append(["service": service, "reasons": reasons])
			}
		}

		return converted
	}

	/// Serialize detection service.
	/// - Parameter detectionService: Detection service.
	/// - Returns: Service name for wrapper.
	fileprivate func convert(detectionService: DolphinMoveSDK.MoveConfig.DetectionService) -> String {
		switch detectionService {
		case .driving:
			return ServiceName.driving.rawValue
		case .cycling:
			return ServiceName.cycling.rawValue
		case .walking:
			return ServiceName.walking.rawValue
		case .places:
			return ServiceName.places.rawValue
		case .publicTransport:
			return ServiceName.publicTransport.rawValue
		case .pointsOfInterest:
			return ServiceName.pointsOfInterest.rawValue
		case .automaticImpactDetection:
			return ServiceName.automaticImpactDetection.rawValue
		case .assistanceCall:
			return ServiceName.assistanceCall.rawValue
		case .health:
			return ServiceName.health.rawValue
		@unknown default:
			return detectionService.debugDescription
		}
	}

	/// Serialize walking service.
	/// - Parameter walkingService: Walking subservice.
	/// - Returns: Walking service name for wrapper.
	fileprivate func convert(walkingService: DolphinMoveSDK.MoveConfig.WalkingService) -> String {
		switch walkingService {
		case .location:
			return ServiceName.walkingLocation.rawValue
		@unknown default:
			return walkingService.debugDescription
		}
	}
	
	/// Serialize driving service.
	/// - Parameter drivingService: Driving subservice.
	/// - Returns: Driving service name for wrapper.
	fileprivate func convert(drivingService: DolphinMoveSDK.MoveConfig.DrivingService) -> String {
		switch drivingService {
		case .drivingBehavior:
			return ServiceName.drivingBehavior.rawValue
		case .distractionFreeDriving:
			return ServiceName.distractionFreeDriving.rawValue
		case .deviceDiscovery:
			return ServiceName.deviceDiscovery.rawValue
		@unknown default:
			return drivingService.debugDescription
		}
	}

	/// Serialize config object.
	/// - Parameter config: MoveConfig to convert.
	/// - Returns: Wrapper compatible json object.
	fileprivate func convert(config: DolphinMoveSDK.MoveConfig) -> [String: [String]] {
		var timelineDetectionServices: [String] = []
		var drivingServices: [String] = []
		var walkingServices: [String] = []

		for service in config.services {
			switch service {
			case let .driving(subs):
				drivingServices = subs.map { convert(drivingService: $0) }
			case let .walking(subs):
				walkingServices = subs.map { convert(walkingService: $0) }
			default:
				break
			}
		}

		timelineDetectionServices = config.services.map { convert(detectionService: $0) }

		return [
			"timelineDetectionServices": timelineDetectionServices,
			"drivingServices": drivingServices,
			"walkingServices": walkingServices
		]
	}

	/// Serialize detection service.
	/// - Parameters:
	///   - service: Move service to be serialized.
	///
	/// - Returns: List of one or more service strings for service and subservices.
	fileprivate func convert(service: DolphinMoveSDK.MoveConfig.DetectionService, base: Bool = false) -> [String] {
		switch service {
		case let .driving(subs):
			var services: [String] = base || subs.isEmpty ? [ServiceName.driving.rawValue] : []
			services += subs.map { convert(drivingService: $0) }
			return services
		case let .walking(subs):
			var services: [String] = base || subs.isEmpty ? [ServiceName.walking.rawValue] : []
			services += subs.map { convert(walkingService: $0) }
			return services
		default:
			return [convert(detectionService: service)]
		}
	}

	/// Serialize SDK service warnings.
	/// - Parameters:
	///   - failures: Move service warnings to be serialized.
	///
	/// - Returns: List of error list items.
	///
	/// Used in `MoveSDK.getServiceWarnings()` and service warning listener.
	fileprivate func convert(warnings: [DolphinMoveSDK.MoveServiceWarning]) -> [ErrorListItem] {
		var converted: [ErrorListItem] = []

		for warning in warnings {
			var reasons: [String] = []
			switch warning.reason {
			case let .missingPermission(permissions):
				let content: [String] = permissions.compactMap {
					self.permissionString($0)
				}
				reasons = content
			}
			let services = convert(service: warning.service)
			for service in services {
				converted.append(["service": service, "reasons": reasons])
			}
		}

		return converted
	}
	
	/// Serialize device state for React Native events.
	/// - Parameter deviceState: Device state.
	/// - Returns: Device state string.
	fileprivate func convert(deviceState: MoveDeviceState) -> String {
		switch deviceState {
		case .ok: return "OK"
		case .notSynchronized: return "NOT_SYNCHRONIZED"
		}
	}

	/// Serialize device objects for React Native events.
	/// - Parameters:
	///   - devices: `MoveDevice` list.
	/// - Returns: List of serialized device objects.
	///
	/// Used from `getRegisteredDevices()` or from device scanner.
	fileprivate func convert(devices: [MoveDevice]) -> [[String:String]] {
		var deviceList: [[String: String]] = []
		for device in devices {
			let encoder = JSONEncoder()
			do {
				let data = try encoder.encode(device)
				let str = String(data: data, encoding: .utf8) ?? ""
				let info: [String: String] = ["displayName": device.displayName, "name": device.name, "data": str, "id": device.id, "isConnected": "\(device.isConnected)", "state": convert(deviceState: device.state)]
				deviceList.append(info)
			} catch {
				print(error.localizedDescription)
			}
		}

		return deviceList
	}

	/// Deserialize device objects from React Native function arguments.
	/// - Parameters:
	///   - devices: React Native function arguments list.
	///
	/// - Returns: List of deserialized `MoveDevice` objects.
	///
	/// Passed to `register(devices)` or `unregister(devices)`.
	fileprivate func convert(devices: [Any]) -> [MoveDevice] {
		return devices.compactMap { values in
			guard let values = values as? [String: String] else { return nil }
			let encoded: String = values["data"] ?? ""
			let displayName: String = values["displayName"] ?? ""
			let decoder = JSONDecoder()
			guard let data = encoded.data(using: .utf8) else { return nil }
			do {
				let device = try decoder.decode(MoveDevice.self, from: data)
				/* keep device name from info */
				device.displayName = displayName
				return device
			} catch {
				if let info = try? decoder.decode([String:String].self, from: data),
				   let uuid = UUID(uuidString: info["uuid"] ?? "") {
					let device = MoveDevice(proximityUUID: uuid)
					device.displayName = displayName
					return device
				}
				/* invalid beeacon device, rejected in register */
				let device = MoveDevice(proximityUUID: UUID())
				device.displayName = ""
				device.name = ""
				return device
			}
		}
	}

	/// Serialize device scan results for React Native events.
	/// - Parameters:
	///   - scanResults: `MoveScanResult` list.
	///
	/// - Returns: List of serialized device objects.
	///
	/// Used from device detection listener.
	fileprivate func convert(scanResults: [MoveScanResult]) -> [[String: Any]] {
		var deviceList: [[String: Any]] = []
		for result in scanResults {
			let encoder = JSONEncoder()
			do {
				let data = try encoder.encode(result.device)
				let str = String(data: data, encoding: .utf8) ?? ""
				let info: [String: Any] = ["name": result.device.name, "device": str, "id": result.device.id, "isDiscovered": result.isDiscovered]
				deviceList.append(info)
			} catch {
				print(error.localizedDescription)
			}
		}

		return deviceList
	}

	/// Decode from user defaults.
	/// - Parameters:
	///   - key: User defaults string key.
	///
	/// - Returns: Decoded object.
	private static func decode<T>(_ key: DefaultsKey) -> T? where T: Decodable {
		let decoder = PropertyListDecoder()

		if let data = UserDefaults.standard.object(forKey: key.rawValue) as? Data {
			return try? decoder.decode(T.self, from: data)
		}

		return nil
	}

	/// Encode to user defaults.
	/// - Parameters:
	///   - key: User defaults string key.
	private static func encode<T>(_ encodable: T?, forKey key: DefaultsKey) where T: Encodable {
		if let encodable = encodable {
			let encoder = PropertyListEncoder()
			if let data = try? encoder.encode(encodable) {
				UserDefaults.standard.set(data, forKey: key.rawValue)
			}
		} else {
			UserDefaults.standard.removeObject(forKey: key.rawValue)
		}
	}

	/// Serialize move permission object into string.
	/// - Parameters:
	///   - permission: Permission object to serialize.
	///
	/// - Returns: Service permission string passed to React Native.
	fileprivate func permissionString(_ permission: DolphinMoveSDK.MovePermission) -> String {
		switch permission {
		case .location:
			return "LOCATION_PERMISSION_MISSING"
		case .backgroundLocation:
			return "BACKGROUND_LOCATION_PERMISSION_MISSING"
		case .preciseLocation:
			return "PRECISE_LOCATION_PERMISSION_MISSING"
		case .motionActivity:
			return "MOTION_PERMISSION_MISSING"
		case .gyroscope:
			return "GYROSCOPE_MISSING"
		case .accelerometer:
			return "ACCELEROMETER_MISSING"
		case .bluetooth:
			return "BLUETOOTH_TURNED_OFF"
		case .bluetoothScan:
			return "BLUETOOTH_PERMISSION_MISSING"
		case .steps:
			return "HEALTHKIT_NO_STEPS_DETECTED"
		case .health:
			return "HEALTH_DEPENDENCY_MISSING"
		case .magnetometer:
			return "MAGNETOMETER_MISSING"
		case .notifications:
			return "NOTIFICATIONS_MISSING"
		@unknown default:
			return "UNKNOWN"
		}
	}

	/// Send event to observer.
	/// - Parameters:
	///   - event: Event key.
	///   - data: Event object.
	///
	/// Events are buffered when there is no observer.
	private func send(event: Event, data: Any) {
		if let delegate {
			delegate.send(event: event.rawValue, data: data)
		}

		pendingEvents[event] = data
	}
}

extension MoveSDKInstance: MoveSdkDeviceScannerDelegate {
	func didDiscover(devices: [DolphinMoveSDK.MoveDevice]) {
		send(event: .devices, data: convert(devices: devices))
	}
}

/// Wrapper extensions for ObjC interface.
@objc public extension MoveSDKInstance {
	/// Event emitter supported events.
	static var supportedEvents: [String] {
		Event.allCases.map { $0.rawValue }
	}

	/// Global initialization function.
	func initialize() {
#if canImport(DolphinMoveSDKHealth)
		print("import DolphinMoveSDKHealth")
		sdk.enable(healthKit: MoveSDKHealth.shared)
#endif
		let options = (Bundle.main.object(forInfoDictionaryKey: "MoveSdkMaxQueueSizeMB") as? Int).map {
			MoveInitOptions(maxQueueSizeMB: $0)
		}
		sdk.initialize(launchOptions: nil, options: options)
	}

	/// Module wrapper.
	var sdkState: String {
		"\(sdk.getSDKState())".uppercased()
	}

	/// Module wrapper.
	var tripState: String {
		"\(sdk.getTripState())".uppercased()
	}

	/// Module wrapper.
	var authState: String {
		return "\(sdk.getAuthState())".uppercased()
	}

	/// Module wrapper.
	var warnings: [ErrorListItem] {
		convert(warnings: sdk.getServiceWarnings())
	}

	/// Module wrapper.
	var failures: [ErrorListItem] {
		convert(failures: sdk.getServiceFailures())
	}

	/// Wrapper for `MoveSDK.setup(auth:config:options)`.
	/// - Parameters:
	///   - contractId: Authentication user ID.
	///   - accessToken: Authentication user token.
	///   - refreshToken: Authentication refresh token.
	///   - productId: Authentication project ID.
	///   - timelineDetectionServices: List of timeline detection services.
	///   - drivingServices: List of driving services.
	///   - walkingServices: List of walking services.
	///   - options: Options dictionary object.
	func setup(_ contractId: String,
			   accessToken: String,
			   refreshToken: String,
			   productId: Int64,
			   timelineDetectionServices: [String],
			   drivingServices: [String],
			   walkingServices: [String],
			   options: [MoveSdkOption]) {

		let sdkConfig = convert(timelineDetectionServices: timelineDetectionServices, drivingServices: drivingServices, walkingServices: walkingServices)
		let moveOptions = convert(options: options)

		let auth = MoveAuth(userToken: accessToken, refreshToken: refreshToken, userID: contractId, projectID: productId)

		sdk.setup(auth: auth, config: sdkConfig, options: moveOptions)
	}

	/// Wrapper for `MoveSDK.setup(authCode:config:options:callback)`.
	/// - Parameters:
	///   - authCode: Authentication code.
	///   - timelineDetectionServices: List of timeline detection services.
	///   - drivingServices: List of driving services.
	///   - walkingServices: List of walking services.
	///   - options: Options dictionary object.
	///   - callback: Error callback.
	func setup(_ authCode: String,
			   timelineDetectionServices: [String],
			   drivingServices: [String],
			   walkingServices: [String],
			   options: [MoveSdkOption],
			   callback: @escaping(MoveSdkError?)->Void) {

		let sdkConfig = convert(timelineDetectionServices: timelineDetectionServices, drivingServices: drivingServices, walkingServices: walkingServices)
		let moveOptions = convert(options: options)

		sdk.setup(authCode: authCode, config: sdkConfig, options: moveOptions) { result in
			switch result {
			case .success:
				callback(nil)
			case .networkError:
				callback(.networkError)
			case let .invalidCode(error):
				callback(.setupError(text: "\(error)"))
			}
		}
	}

	/// Wrapper for `MoveSDK.update(config:)`.
	/// - Parameters:
	///   - timelineDetectionServices: Timeline detection services strings.
	///   - drivingServices: Driving services strings.
	///   - walkingServices: Walking services strings.
	func updateConfig(_ timelineDetectionServices: Array<String>,
					  drivingServices: Array<String>,
					  walkingServices: Array<String>,
					  options: [MoveSdkOption]) {

		let sdkConfig = convert(timelineDetectionServices: timelineDetectionServices, drivingServices: drivingServices, walkingServices: walkingServices)
		let moveOptions = convert(options: options)
		sdk.update(config: sdkConfig, options: moveOptions)
	}
	
	/// Wrapper for `MoveSDK.getMoveConfig()`.
	/// - Returns: MoveSdkConfig wrapper object.
	func getMoveConfig() -> Dictionary<String, Array<String>>? {
		guard let config = sdk.getMoveConfig() else {
			return nil
		}
		return self.convert(config: config)
	}

	/// Wrapper for `MoveSDK.shutDown()`.
	/// - Parameters:
	///   - force: Force shutdown with possible data loss.
	///   - timeout: Time in seconds to wait for pending data upload before giving up.
	///   - callback: Error callback.
	func shutdown(_ force: Bool, timeout: NSNumber?, callback: @escaping(MoveSdkError?)->Void) {
		sdk.shutDown(force: force, timeout: timeout?.doubleValue ?? 0) { status in
			switch status {
			case .success:
				callback(nil)
			case .uninitialized:
				callback(.uninitialized)
			case .networkError:
				callback(.networkError)
			}
		}
	}

	/// Wrapper for `MoveSDK.updateAuth(auth)`.
	/// - Parameters:
	///   - contractId: Authentication user ID.
	///   - accessToken: Authentication user token.
	///   - refreshToken: Authentication refresh token.
	///   - productId: Authentication project ID.
	///   - callback: Error callback.
	func updateAuth(
		_ contractId: String,
		accessToken: String,
		refreshToken: String,
		productId: Int64,
		callback: @escaping(MoveSdkError?)->Void
	) {
		let auth = MoveAuth(userToken: accessToken, refreshToken: refreshToken, userID: contractId, projectID: productId)

		sdk.update(auth: auth) { configurationError in
			if let configurationError = configurationError {
				switch configurationError {
				case .authInvalid:
					callback(.authInvalid)
				default:
					callback(.configurationError)
				}
			} else {
				callback(nil)
			}
		}
	}

	/// Wrapper for `MoveSDK.geocode(latitude:longitude)`.
	/// - Parameters:
	///   - latitude: Geocoord degrees latitude.
	///   - longitude: Geocoord degrees longitude.
	///   - callback: Error callback.
	func geocode(latitude: Double, longitude: Double, callback: @escaping(String?, MoveSdkError?)->Void) {
		sdk.geocode(latitude: latitude, longitude: longitude) { result in
			switch result {
			case let .success(value):
				callback(value, nil)
			case let .failure(err):
				switch err {
				case .resolveFailed:
					callback(nil, .resolveFailed)
				case .serviceUnreachable:
					callback(nil, .serviceUnavailable)
				case .thresholdReached:
					callback(nil, .thresholdReached)
				}
			}
		}
	}

	/// Wrapper for `MoveSDK.initiateAssistanceCall()`.
	///   - callback: Error callback.
	func initiateAssistanceCall(callback: @escaping(MoveSdkError?)->Void) {
		sdk.initiateAssistanceCall { status in
			switch status {
			case .success:
				callback(nil)
			case .initializationError:
				callback(.initializationError)
			case .networkError:
				callback(.networkError)
			}
		}
	}

	/// Wrapper for `MoveSDK.isAuthValid()`.
	/// - Returns: Is authentication valid.
	///
	/// Authentication is invalid incase of `.invalid` and `.expired`.
	func isAuthValid() -> Bool {
		switch sdk.getAuthState() {
		case .invalid, .expired:
			return false
		default:
			return true
		}
	}

	/// Wrapper for `MoveSDK.setLiveLocationTag(:)`.
	/// - Parameter tag: Tag. `NULL` = clear.
	/// - Returns: Success.
	func setLiveLocationTag(_ tag: String?) -> Bool {
		sdk.setLiveLocationTag(tag)
	}

	/// Wrapper for `MoveSDK.startAutomaticDetection()`.
	/// - Returns: Success.
	func startAutomaticDetection() -> Bool {
		sdk.startAutomaticDetection()
	}

	/// Wrapper for `MoveSDK.stopAutomaticDetection()`
	/// - Returns: Success.
	func stopAutomaticDetection() -> Bool {
		sdk.stopAutomaticDetection()
	}

	/// Wrapper for `MoveSDK.startTrip(metadata:)`.
	/// - Parameter metadata: Trip metadata.
	/// - Returns: Success.
	func startTrip(_ metadata: [String: String]?) -> Bool {
		sdk.startTrip(metadata: metadata ?? [:])
	}

	/// Wrapper for `MoveSDK.synchronizeUserData()`.
	/// - Parameters:
	///   - callback: Error callback.
	func synchronizeUserData(_ callback: @escaping(Bool) -> Void) {
		sdk.fetchUserConfig()
		sdk.synchronizeUserData() { success in
			callback(success)
		}
	}

	/// Start device scanner.
	/// - Parameters:
	///   - filter: Device type filter.
	///   - uuid: iBeacon UUID.
	func startScanningDevices(_ filter: [String], uuid: String?) {
		DispatchQueue.main.async {
			self.scanner.delegate = self
			self.scanner.startScanning(filter: filter, uuid: uuid)
		}
	}

	/// Stop device scanner.
	func stopScanningDevices() {
		DispatchQueue.main.async {
			self.scanner.stopScanning()
		}
	}

	func requestHealthPermissions(_ callback: @escaping([String: String])->Void) {
#if canImport(DolphinMoveSDKHealth)
		MoveSDKHealth.shared.requestStepsPermission { error in
			if let error {
				callback(["technicalMessage":"error", "message":"\(error.localizedDescription)"])
			} else {
				callback(["technicalMessage":"permission_result", "message":"true"])
			}
		}
#else
	callback(["technicalMessage":"error", "message":"missing framework 'DolphinMoveSDKHealth'"])
#endif
	}

	/// Request bluetooth permission.
	func requestBluetoothAlwaysUsagePermission() {
		bluetoothManager.getBluetoothState() { _ in }
	}

	/// Request motion permission.
	func requestMotionPermission() {
		motionManager.queryActivityStarting(from: Date(), to: Date(), to: OperationQueue.main) { _, error in
		}
	}

	/// Get bluetooth permission.
	/// - Parameter resolve: Is bluetooth permitted.
	func getBluetoothPermission(_ resolve: @escaping (Bool)->Void) {
		bluetoothManager.getBluetoothState() { state in
			switch state {
			case .unknown:
				resolve(false)
			case .resetting:
				resolve(false)
			case .unsupported:
				resolve(false)
			case .unauthorized:
				resolve(false)
			case .poweredOff:
				resolve(true)
			case .poweredOn:
				resolve(true)
			@unknown default:
				resolve(false)
			}
		}
	}

	/// Get bluetooth state.
	/// - Parameter resolve: Is bluetooth on.
	///
	/// Undefined without permission.
	func getBluetoothState(_ resolve: @escaping (Bool)->Void) {
		bluetoothManager.getBluetoothState() { state in
			switch state {
			case .unknown:
				resolve(false)
			case .resetting:
				resolve(false)
			case .unsupported:
				resolve(false)
			case .unauthorized:
				resolve(false)
			case .poweredOff:
				resolve(false)
			case .poweredOn:
				resolve(true)
			@unknown default:
				resolve(false)
			}
		}
	}

	/// Wrapper for `MoveSDK.ignoreCurrentTrip()`.
	func ignoreCurrentTrip() {
		sdk.ignoreCurrentTrip()
	}

	/// Wrapper for `MoveSDK.finishCurrentTrip()`.
	func finishCurrentTrip() {
		sdk.finishCurrentTrip()
	}

	/// Wrapper for `MoveSDK.resolveSDKStateError()`.
	func resolveError() {
		sdk.resolveSDKStateError()
	}

	/// Wrapper for `MoveSDK.setAssistanceMetaData(_)`
	func setAssistanceMetaData(_ metadata: String) {
		sdk.setAssistanceMetaData(metadata)
	}

	/// Wrapper for `MoveSDK.getDeviceQualifier()`.
	/// Identifier uniquely identifying device, for when device data is transferred to a new phone.
	func getDeviceQualifier() -> String {
		sdk.getDeviceQualifier()
	}

	/// Wrapper for `MoveSDK.getRegisteredDevices()`.
	func getRegisteredDevices() -> [[String:String]] {
		return convert(devices: sdk.getRegisteredDevices())
	}

	/// Wrapper for `MoveSDK.register(devices)`.
	func registerDevices(_ devices: [Any]) -> Bool {
		let devices = convert(devices: devices)
		do {
			try sdk.register(devices: devices)
			return true
		} catch {
			return false
		}
	}

	/// Wrapper for `MoveSDK.unregister(devices)`.
	func unregisterDevices(_ devices: [Any]) {
		let devices = convert(devices: devices)
		sdk.unregister(devices: devices)
	}

	/// Add trip metadata.
	/// - Parameter metadata: Meta data strings dictionary.
	func setTrip(metadata: [String: String]) {
		var data = self.tripMetaData
		for (key, value) in metadata {
			data[key] = value
		}
		self.tripMetaData = data
	}

	/// Wrapper for `MoveSDK.forceTripRecognition()`.
	func forceTripRecognition() {
		sdk.forceTripRecognition()
	}
}

extension String {
	func snakeCased() -> String {
		let pattern = "([a-z0-9])([A-Z])"

		if let regex = try? NSRegularExpression(pattern: pattern, options: []) {
			let range = NSRange(location: 0, length: count)
			return regex.stringByReplacingMatches(in: self, options: [], range: range, withTemplate: "$1_$2").uppercased()
		}

		return uppercased()
	}
}
