import AVFoundation
import CoreBluetooth
import CoreLocation
import Foundation
import DolphinMoveSDK

internal protocol MoveSdkDeviceScannerDelegate: AnyObject {
	func didDiscover(devices: [MoveDevice])
}

internal class MoveSdkDeviceScanner: NSObject {
	private let allowedPorts: [AVAudioSession.Port] = [.bluetoothA2DP, .bluetoothHFP, .bluetoothLE, .carAudio]

	private let session = AVAudioSession.sharedInstance()
	private let locationManager = CLLocationManager()
	private var devices: [MoveDevice] = []
	private var timer: Timer?
	private var beaconRegion: CLBeaconRegion?
	internal var delegate: MoveSdkDeviceScannerDelegate?

	override init() {
		super.init()
		locationManager.delegate = self
		do {
			try session.setCategory(.playAndRecord, options: [.allowAirPlay, .allowBluetoothA2DP, .allowBluetooth])
		} catch {
			print("\(error)")
		}
	}

	func scanAudioPorts() {
		let devices: [MoveDevice] = (session.availableInputs ?? []).compactMap {
			if !allowedPorts.contains($0.portType) { return nil }
			return MoveDevice(name: $0.portName, id: $0.uid)
		}

		add(devices: devices)
	}

	func scanBeacons(uuid: UUID) {
		let beaconRegion = CLBeaconRegion(proximityUUID: uuid, identifier: "beacons [\(uuid)]")
		locationManager.startRangingBeacons(in: beaconRegion)
		locationManager.requestState(for: beaconRegion)
		self.beaconRegion = beaconRegion
	}

	func add(devices: [MoveDevice]) {
		let devices = devices.filter { device in
			!self.devices.contains { $0 == device }
		}

		if !devices.isEmpty {
			self.devices += devices
			delegate?.didDiscover(devices: devices)
		}
	}

	func startScanning(filter: [String], uuid uuidString: String? = nil) {
		devices = []
		let audioFilter = Set(["paired", "connected"])

		if !audioFilter.intersection(filter).isEmpty {
			self.scanAudioPorts()

			let timer = Timer(timeInterval: 1.0, repeats: true) { _ in
				self.scanAudioPorts()
			}

			self.timer = timer

			RunLoop.main.add(timer, forMode: .default)
		}

		if filter.contains("beacon"), let uuidString, let uuid = UUID(uuidString: uuidString) {
			scanBeacons(uuid: uuid)
		}
	}

	func stopScanning() {
		if let beaconRegion = self.beaconRegion {
			locationManager.stopRangingBeacons(in: beaconRegion)
		}
		timer?.invalidate()
		timer = nil
	}
}

extension MoveSdkDeviceScanner: CLLocationManagerDelegate {
	func locationManager(_ manager: CLLocationManager, didRangeBeacons beacons: [CLBeacon], in region: CLBeaconRegion) {

		let devices = beacons.map {
			let name = "Beacon \($0.major):\($0.minor)"
			let device = MoveDevice(name: name, proximityUUID: $0.proximityUUID, major: UInt16(truncating: $0.major), minor: UInt16(truncating: $0.minor))
			return device
		}

		add(devices: devices)
	}

	func locationManager(_ manager: CLLocationManager, rangingBeaconsDidFailFor region: CLBeaconRegion, withError error: Error) {
		print("rangingBeaconsDidFailFor: \(region)")
	}

	func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
		print("fail: \(error)")
	}

	func locationManager(_ manager: CLLocationManager, monitoringDidFailFor region: CLRegion?, withError error: Error) {
		print("monitoringDidFailFor: \(String(describing: region)) \(error)")
	}

	func locationManager(_ manager: CLLocationManager, didEnterRegion region: CLRegion) {
		print("didEnterRegion: \(region)")
	}

	func locationManager(_ manager: CLLocationManager, didExitRegion region: CLRegion) {
		print("didExitRegion: \(region)")
	}

	func locationManager(_ manager: CLLocationManager, didDetermineState state: CLRegionState, for region: CLRegion) {
		print("didDetermineState: \(region) : \(state)")
	}
}

internal class MoveSdkBluetoothManager: NSObject, CBCentralManagerDelegate {

	private var stateCallback: ((CBManagerState) -> Void)?
	private var manager: CBCentralManager?

	func getBluetoothState(_ callback: @escaping(CBManagerState) -> Void) {
		stateCallback = callback
		manager = CBCentralManager(delegate: self, queue: nil, options: [CBCentralManagerOptionShowPowerAlertKey: false])
	}

	func centralManagerDidUpdateState(_ central: CBCentralManager) {
		stateCallback?(central.state)
		stateCallback = nil
	}
}
