payfrit-beacon-ios/PayfritBeacon/Provisioners/BlueCharmProvisioner.swift

import Foundation
import CoreBluetooth

/// Provisioner for BlueCharm / BC04P hardware
/// Uses FFF0 service with similar auth/write flow to KBeacon
final class BlueCharmProvisioner: NSObject, BeaconProvisioner {

    // MARK: - Constants

    private static let passwords: [Data] = [
        Data(repeating: 0, count: 16),
        "0000000000000000".data(using: .utf8)!,
        "1234567890123456".data(using: .utf8)!,
    ]

    private enum CMD: UInt8 {
        case auth       = 0x01
        case writeParams = 0x03
        case save       = 0x04
    }

    private enum ParamID: UInt8 {
        case uuid        = 0x10
        case major       = 0x11
        case minor       = 0x12
        case txPower     = 0x13
        case advInterval = 0x14
    }

    // MARK: - State

    private let peripheral: CBPeripheral
    private let centralManager: CBCentralManager
    private var writeChar: CBCharacteristic?
    private var notifyChar: CBCharacteristic?

    private var connectionContinuation: CheckedContinuation<Void, Error>?
    private var serviceContinuation: CheckedContinuation<Void, Error>?
    private var writeContinuation: CheckedContinuation<Data, Error>?

    private(set) var isConnected = false

    // MARK: - Init

    init(peripheral: CBPeripheral, centralManager: CBCentralManager) {
        self.peripheral = peripheral
        self.centralManager = centralManager
        super.init()
        self.peripheral.delegate = self
    }

    // MARK: - BeaconProvisioner

    func connect() async throws {
        for attempt in 1...GATTConstants.maxRetries {
            do {
                try await connectOnce()
                try await discoverServices()
                try await authenticate()
                isConnected = true
                return
            } catch {
                disconnect()
                if attempt < GATTConstants.maxRetries {
                    try await Task.sleep(nanoseconds: UInt64(GATTConstants.retryDelay * 1_000_000_000))
                } else {
                    throw error
                }
            }
        }
    }

    func writeConfig(_ config: BeaconConfig) async throws {
        guard isConnected, let writeChar else {
            throw ProvisionError.notConnected
        }

        var params = Data()

        // UUID (16 bytes)
        params.append(ParamID.uuid.rawValue)
        params.append(contentsOf: config.uuid.hexToBytes)

        // Major
        params.append(ParamID.major.rawValue)
        params.append(UInt8(config.major >> 8))
        params.append(UInt8(config.major & 0xFF))

        // Minor
        params.append(ParamID.minor.rawValue)
        params.append(UInt8(config.minor >> 8))
        params.append(UInt8(config.minor & 0xFF))

        // TX Power
        params.append(ParamID.txPower.rawValue)
        params.append(config.txPower)

        // Adv Interval
        params.append(ParamID.advInterval.rawValue)
        params.append(UInt8(config.advInterval >> 8))
        params.append(UInt8(config.advInterval & 0xFF))

        let writeCmd = Data([CMD.writeParams.rawValue]) + params
        let writeResp = try await sendCommand(writeCmd)
        guard writeResp.first == CMD.writeParams.rawValue else {
            throw ProvisionError.writeFailed("Unexpected write response")
        }

        let saveResp = try await sendCommand(Data([CMD.save.rawValue]))
        guard saveResp.first == CMD.save.rawValue else {
            throw ProvisionError.saveFailed
        }
    }

    func disconnect() {
        if peripheral.state == .connected || peripheral.state == .connecting {
            centralManager.cancelPeripheralConnection(peripheral)
        }
        isConnected = false
    }

    // MARK: - Private

    private func connectOnce() async throws {
        try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
            connectionContinuation = cont
            centralManager.connect(peripheral, options: nil)

            DispatchQueue.main.asyncAfter(deadline: .now() + GATTConstants.connectionTimeout) { [weak self] in
                if let c = self?.connectionContinuation {
                    self?.connectionContinuation = nil
                    c.resume(throwing: ProvisionError.connectionTimeout)
                }
            }
        }
    }

    private func discoverServices() async throws {
        try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
            serviceContinuation = cont
            peripheral.discoverServices([GATTConstants.fff0Service, GATTConstants.fea0Service])

            DispatchQueue.main.asyncAfter(deadline: .now() + GATTConstants.operationTimeout) { [weak self] in
                if let c = self?.serviceContinuation {
                    self?.serviceContinuation = nil
                    c.resume(throwing: ProvisionError.serviceDiscoveryTimeout)
                }
            }
        }
    }

    private func authenticate() async throws {
        for password in Self.passwords {
            let cmd = Data([CMD.auth.rawValue]) + password
            do {
                let resp = try await sendCommand(cmd)
                if resp.first == CMD.auth.rawValue && resp.count > 1 && resp[1] == 0x00 {
                    return
                }
            } catch {
                continue
            }
        }
        throw ProvisionError.authFailed
    }

    private func sendCommand(_ data: Data) async throws -> Data {
        guard let writeChar else { throw ProvisionError.notConnected }

        return try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Data, Error>) in
            writeContinuation = cont
            peripheral.writeValue(data, for: writeChar, type: .withResponse)

            DispatchQueue.main.asyncAfter(deadline: .now() + GATTConstants.operationTimeout) { [weak self] in
                if let c = self?.writeContinuation {
                    self?.writeContinuation = nil
                    c.resume(throwing: ProvisionError.operationTimeout)
                }
            }
        }
    }
}

// MARK: - CBPeripheralDelegate

extension BlueCharmProvisioner: CBPeripheralDelegate {

    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
        if let error {
            serviceContinuation?.resume(throwing: error)
            serviceContinuation = nil
            return
        }

        // Look for FFF0 or FEA0 service
        guard let service = peripheral.services?.first(where: {
            $0.uuid == GATTConstants.fff0Service || $0.uuid == GATTConstants.fea0Service
        }) else {
            serviceContinuation?.resume(throwing: ProvisionError.serviceNotFound)
            serviceContinuation = nil
            return
        }

        peripheral.discoverCharacteristics(nil, for: service)
    }

    func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
        if let error {
            serviceContinuation?.resume(throwing: error)
            serviceContinuation = nil
            return
        }

        for char in service.characteristics ?? [] {
            if char.properties.contains(.write) || char.properties.contains(.writeWithoutResponse) {
                if writeChar == nil { writeChar = char }
            }
            if char.properties.contains(.notify) {
                notifyChar = char
                peripheral.setNotifyValue(true, for: char)
            }
        }

        if writeChar != nil {
            serviceContinuation?.resume()
            serviceContinuation = nil
        } else {
            serviceContinuation?.resume(throwing: ProvisionError.characteristicNotFound)
            serviceContinuation = nil
        }
    }

    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
        guard let data = characteristic.value else { return }
        if let cont = writeContinuation {
            writeContinuation = nil
            cont.resume(returning: data)
        }
    }

    func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?) {
        if let error, let cont = writeContinuation {
            writeContinuation = nil
            cont.resume(throwing: error)
        }
    }
}