//

//  BTManager.swift

//  USB Meter

//

//  Created by Bogdan Timofte on 01/03/2020.

//  Copyright © 2020 Bogdan Timofte. All rights reserved.

//

import CoreBluetooth

class BluetoothManager : NSObject, ObservableObject {

    @Published var managerState = CBManagerState.unknown

    override init () {

        super.init()

    }

        }

            guard let self else { return }

            defer { self.isStarting = false }

            guard self.manager == nil else {

                return

            }

            self.manager = CBCentralManager(delegate: self, queue: nil)

        }

    private func scanForMeters() {

            track("Scan requested before Bluetooth manager was started")

            return

        }

            track( "Scan requested but Bluetooth state is \(manager.state)")

            return

        }

        //manager.scanForPeripherals(withServices: allBluetoothRadioServices(), options: [ CBCentralManagerScanOptionAllowDuplicatesKey: true ])

        manager.scanForPeripherals(withServices: allBluetoothRadioServices(), options: [ CBCentralManagerScanOptionAllowDuplicatesKey: true ])

    }

    func discoveredMeter(peripheral: CBPeripheral, advertising advertismentData: [String : Any], rssi RSSI: NSNumber) {

            return

        }

        guard let manufacturerData = resolvedManufacturerData(from: advertismentData), manufacturerData.count > 2 else {

            return

        }

        }

        let macAddress = MACAddress(from: manufacturerData.suffix(from: 2))

        if appData.meters[peripheral.identifier] == nil {

            track("adding new USB Meter named '\(peripheralName)' with MAC Address: '\(macAddress)'")

            m[peripheral.identifier] = meter

            meter.lastSeen = Date()

            if meter.name == macAddress, let syncedName = appData.meterName(for: macAddress), syncedName != macAddress {

                meter.updateNameFromStore(syncedName)

            }

                peripheral.delegate = meter.btSerial

            }

        }

    }

    private func resolvedPeripheralName(for peripheral: CBPeripheral, advertising advertismentData: [String : Any]) -> String? {

        let candidates = [

            (advertismentData[CBAdvertisementDataLocalNameKey] as? String),

            peripheral.name

        ]

        for candidate in candidates {

            if let trimmed = candidate?.trimmingCharacters(in: .whitespacesAndNewlines), !trimmed.isEmpty {

                return trimmed

        }

        return nil

    }

    private func resolvedManufacturerData(from advertismentData: [String : Any]) -> Data? {

        if let data = advertismentData[CBAdvertisementDataManufacturerDataKey] as? Data {

            return data

            return data

        }

        return nil

}

extension BluetoothManager : CBCentralManagerDelegate {

    // MARK:  CBCentralManager state Changed

    func centralManagerDidUpdateState(_ central: CBCentralManager) {

        managerState = central.state;

        track("\(central.state)")

            meter.btSerial.centralStateChanged(to: central.state)

        }

        switch central.state {

        case .poweredOff:

        case .poweredOn:

            // note that "didDisconnectPeripheral" won't be called if BLE is turned off while connected

            // connectedPeripheral = nil

            // pendingPeripheral = nil

        case .unauthorized:

        case .unknown:

        case .unsupported:

        default:

        }

    }

    // MARK:  CBCentralManager didDiscover peripheral

    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {

        let completeAdvertisementData = self.advertisementDataCache.append(peripheral: peripheral, advertisementData: advertisementData)

        //track("Device discoverded UUID: '\(peripheral.identifier)' named '\(peripheral.name ?? "Unknown")'); RSSI: \(RSSI) dBm; Advertisment data: \(advertisementData)")

        discoveredMeter(peripheral: peripheral, advertising: completeAdvertisementData, rssi: RSSI )

    }

    // MARK:  CBCentralManager didConnect peripheral

    internal func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {

        //track("Connected to peripheral: '\(peripheral.identifier)'")

        if let usbMeter = appData.meters[peripheral.identifier] {

            usbMeter.btSerial.connectionEstablished()

        }

        else {

    }

    // MARK:  CBCentralManager didDisconnectPeripheral peripheral

    internal func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {

        track("Disconnected from peripheral: '\(peripheral.identifier)' with error: \(error.debugDescription)")

        if let usbMeter = appData.meters[peripheral.identifier] {

            usbMeter.btSerial.connectionClosed()

        }

        else {

    }

    internal func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {

        track("Failed to connect to peripheral: '\(peripheral.identifier)' with error: \(error.debugDescription)")

        if let usbMeter = appData.meters[peripheral.identifier] {

            usbMeter.btSerial.connectionClosed()

        } else {

    }

private class AdvertisementDataCache {

    func append(peripheral: CBPeripheral, advertisementData: [String: Any]) -> [String: Any] {

        var ad = (map[peripheral.identifier]) ?? [String: Any]()

            ad[CBAdvertisementDataLocalNameKey] = localName

        }

            ad[key] = value

        }

        map[peripheral.identifier] = ad

        return ad

    }

    func clear() {

        map.removeAll()

    }

}