📶 Core Bluetooth

import CoreBluetooth
import SwiftUI

@Observable
class BluetoothManager: NSObject {
    private var centralManager: CBCentralManager!
    var discoveredPeripherals: [CBPeripheral] = []
    var connectedPeripheral: CBPeripheral?
    var isBluetoothOn = false
    var isScanning = false

    override init() {
        super.init()
        // Central Manager 생성
        centralManager = CBCentralManager(delegate: self, queue: nil)
    }

    // 스캔 시작
    func startScanning() {
        guard isBluetoothOn else {
            print("⚠️ Bluetooth가 꺼져 있습니다")
            return
        }

        discoveredPeripherals.removeAll()
        isScanning = true

        // 모든 BLE 기기 스캔 (서비스 필터 없음)
        centralManager.scanForPeripherals(
            withServices: nil,
            options: [CBCentralManagerScanOptionAllowDuplicatesKey: false]
        )

        print("🔍 BLE 기기 스캔 시작")
    }

    // 특정 서비스만 스캔
    func scanForDevices(withServices serviceUUIDs: [CBUUID]) {
        guard isBluetoothOn else { return }

        discoveredPeripherals.removeAll()
        isScanning = true

        centralManager.scanForPeripherals(withServices: serviceUUIDs, options: nil)
        print("🔍 특정 서비스 스캔: \(serviceUUIDs)")
    }

    // 스캔 중지
    func stopScanning() {
        centralManager.stopScan()
        isScanning = false
        print("⏹️ 스캔 중지")
    }

    // Peripheral 연결
    func connect(peripheral: CBPeripheral) {
        stopScanning()
        centralManager.connect(peripheral, options: nil)
        print("🔗 연결 시도: \(peripheral.name ?? "Unknown")")
    }

    // 연결 해제
    func disconnect() {
        guard let peripheral = connectedPeripheral else { return }
        centralManager.cancelPeripheralConnection(peripheral)
        print("❌ 연결 해제")
    }
}

import CoreBluetooth

extension BluetoothManager: CBCentralManagerDelegate {
    // Bluetooth 상태 변화
    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        switch central.state {
        case .poweredOn:
            print("✅ Bluetooth 켜짐")
            isBluetoothOn = true
        case .poweredOff:
            print("❌ Bluetooth 꺼짐")
            isBluetoothOn = false
        case .unauthorized:
            print("⚠️ Bluetooth 권한 없음")
            isBluetoothOn = false
        case .unsupported:
            print("❌ Bluetooth 미지원")
            isBluetoothOn = false
        case .resetting:
            print("🔄 Bluetooth 재설정 중")
        case .unknown:
            print("❓ Bluetooth 상태 불명")
        @unknown default:
            break
        }
    }

    // Peripheral 발견
    func centralManager(
        _ central: CBCentralManager,
        didDiscover peripheral: CBPeripheral,
        advertisementData: [String: Any],
        rssi RSSI: NSNumber
    ) {
        // 이미 발견된 기기는 추가하지 않음
        guard !discoveredPeripherals.contains(where: { $0.identifier == peripheral.identifier }) else {
            return
        }

        discoveredPeripherals.append(peripheral)

        let deviceName = peripheral.name ?? "Unknown Device"
        let signalStrength = RSSI.intValue
        print("📶 발견: \(deviceName) (RSSI: \(signalStrength)dBm)")

        // Advertisement Data 출력
        if let localName = advertisementData[CBAdvertisementDataLocalNameKey] as? String {
            print("  Local Name: \(localName)")
        }
        if let serviceUUIDs = advertisementData[CBAdvertisementDataServiceUUIDsKey] as? [CBUUID] {
            print("  Services: \(serviceUUIDs)")
        }
    }

    // 연결 성공
    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
        print("✅ 연결 성공: \(peripheral.name ?? "Unknown")")
        connectedPeripheral = peripheral
        peripheral.delegate = self

        // 서비스 탐색
        peripheral.discoverServices(nil)
    }

    // 연결 실패
    func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
        print("❌ 연결 실패: \(error?.localizedDescription ?? "Unknown error")")
        connectedPeripheral = nil
    }

    // 연결 해제
    func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
        print("❌ 연결 해제: \(peripheral.name ?? "Unknown")")
        connectedPeripheral = nil

        if let error = error {
            print("  Error: \(error.localizedDescription)")
        }
    }
}

import CoreBluetooth

extension BluetoothManager: CBPeripheralDelegate {
    // 서비스 발견
    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
        if let error = error {
            print("❌ 서비스 발견 실패: \(error.localizedDescription)")
            return
        }

        guard let services = peripheral.services else { return }

        print("🔍 발견된 서비스: \(services.count)개")

        for service in services {
            print("  Service UUID: \(service.uuid)")
            // 각 서비스의 특성 탐색
            peripheral.discoverCharacteristics(nil, for: service)
        }
    }

    // 특성 발견
    func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
        if let error = error {
            print("❌ 특성 발견 실패: \(error.localizedDescription)")
            return
        }

        guard let characteristics = service.characteristics else { return }

        print("🔍 서비스 \(service.uuid)의 특성: \(characteristics.count)개")

        for characteristic in characteristics {
            print("  Characteristic UUID: \(characteristic.uuid)")
            print("  Properties: \(characteristic.properties)")

            // 읽기 가능하면 읽기
            if characteristic.properties.contains(.read) {
                peripheral.readValue(for: characteristic)
            }

            // Notify 가능하면 구독
            if characteristic.properties.contains(.notify) {
                peripheral.setNotifyValue(true, for: characteristic)
                print("  📬 Notification 구독")
            }
        }
    }

    // 특성 값 읽기 완료
    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
        if let error = error {
            print("❌ 값 읽기 실패: \(error.localizedDescription)")
            return
        }

        guard let data = characteristic.value else {
            print("⚠️ 데이터 없음")
            return
        }

        print("📥 데이터 수신 (\(characteristic.uuid)): \(data.hexString)")

        // String으로 변환 시도
        if let stringValue = String(data: data, encoding: .utf8) {
            print("  String: \(stringValue)")
        }

        // 특정 서비스별 파싱
        parseCharacteristicValue(characteristic, data: data)
    }

    // 특성 값 쓰기 완료
    func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?) {
        if let error = error {
            print("❌ 쓰기 실패: \(error.localizedDescription)")
            return
        }

        print("✅ 쓰기 성공 (\(characteristic.uuid))")
    }

    // Notification 상태 변경
    func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error: Error?) {
        if let error = error {
            print("❌ Notification 설정 실패: \(error.localizedDescription)")
            return
        }

        if characteristic.isNotifying {
            print("✅ Notification 활성화 (\(characteristic.uuid))")
        } else {
            print("❌ Notification 비활성화 (\(characteristic.uuid))")
        }
    }

    // 특성 값 파싱 (서비스별 처리)
    private func parseCharacteristicValue(_ characteristic: CBCharacteristic, data: Data) {
        // Heart Rate Service (0x180D)
        if characteristic.uuid == CBUUID(string: "2A37") {
            let heartRate = parseHeartRate(data)
            print("  ❤️ Heart Rate: \(heartRate) bpm")
        }
        // Battery Level (0x2A19)
        else if characteristic.uuid == CBUUID(string: "2A19") {
            if let batteryLevel = data.first {
                print("  🔋 Battery: \(batteryLevel)%")
            }
        }
    }

    // Heart Rate 데이터 파싱
    private func parseHeartRate(_ data: Data) -> Int {
        guard data.count > 1 else { return 0 }
        let flags = data[0]
        let is16Bit = (flags & 0x01) == 0x01

        if is16Bit {
            return Int(data[1]) | (Int(data[2]) << 8)
        } else {
            return Int(data[1])
        }
    }
}

// Data Extension
extension Data {
    var hexString: String {
        map { String(format: "%02X", $0) }.joined(separator: " ")
    }
}

import CoreBluetooth

extension BluetoothManager {
    // 문자열 데이터 전송
    func writeString(_ string: String, to characteristic: CBCharacteristic) {
        guard let data = string.data(using: .utf8) else {
            print("❌ 문자열 변환 실패")
            return
        }

        writeData(data, to: characteristic)
    }

    // 바이트 데이터 전송
    func writeData(_ data: Data, to characteristic: CBCharacteristic) {
        guard let peripheral = connectedPeripheral else {
            print("❌ 연결된 기기 없음")
            return
        }

        // 쓰기 가능 여부 확인
        guard characteristic.properties.contains(.write) || characteristic.properties.contains(.writeWithoutResponse) else {
            print("❌ 쓰기 불가능한 특성")
            return
        }

        // 쓰기 타입 결정
        let writeType: CBCharacteristicWriteType = characteristic.properties.contains(.write) ? .withResponse : .withoutResponse

        peripheral.writeValue(data, for: characteristic, type: writeType)
        print("📤 데이터 전송: \(data.hexString)")
    }

    // LED 제어 예제
    func toggleLED(characteristic: CBCharacteristic, isOn: Bool) {
        let command: UInt8 = isOn ? 0x01 : 0x00
        let data = Data([command])
        writeData(data, to: characteristic)
    }
}

import SwiftUI
import CoreBluetooth

struct BLEScannerView: View {
    @State private var bluetoothManager = BluetoothManager()

    var body: some View {
        NavigationStack {
            VStack(spacing: 0) {
                // 상태 표시
                statusHeader

                // 기기 목록
                if bluetoothManager.discoveredPeripherals.isEmpty {
                    emptyState
                } else {
                    deviceList
                }
            }
            .navigationTitle("BLE 스캐너")
            .toolbar {
                ToolbarItem(placement: .topBarTrailing) {
                    scanButton
                }
            }
        }
    }

    // 상태 헤더
    private var statusHeader: some View {
        VStack(spacing: 8) {
            HStack {
                Circle()
                    .fill(bluetoothManager.isBluetoothOn ? Color.green : Color.red)
                    .frame(width: 12, height: 12)

                Text(bluetoothManager.isBluetoothOn ? "Bluetooth 활성" : "Bluetooth 비활성")
                    .font(.subheadline)
                    .foregroundStyle(.secondary)

                Spacer()

                if bluetoothManager.isScanning {
                    ProgressView()
                        .controlSize(.small)
                    Text("스캔 중...")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }
            }
            .padding()

            if let connected = bluetoothManager.connectedPeripheral {
                HStack {
                    Image(systemName: "checkmark.circle.fill")
                        .foregroundStyle(.green)
                    Text("연결됨: \(connected.name ?? "Unknown")")
                        .font(.subheadline)
                    Spacer()
                    Button("연결 해제") {
                        bluetoothManager.disconnect()
                    }
                    .font(.caption)
                    .buttonStyle(.bordered)
                }
                .padding(.horizontal)
                .padding(.bottom)
            }
        }
        .background(Color(.systemGroupedBackground))
    }

    // 스캔 버튼
    private var scanButton: some View {
        Button {
            if bluetoothManager.isScanning {
                bluetoothManager.stopScanning()
            } else {
                bluetoothManager.startScanning()
            }
        } label: {
            Image(systemName: bluetoothManager.isScanning ? "stop.circle" : "arrow.clockwise")
        }
        .disabled(!bluetoothManager.isBluetoothOn)
    }

    // 빈 상태
    private var emptyState: some View {
        ContentUnavailableView {
            Label("BLE 기기를 찾을 수 없습니다", systemImage: "antenna.radiowaves.left.and.right.slash")
        } description: {
            Text("스캔 버튼을 눌러 주변 BLE 기기를 검색하세요")
        }
    }

    // 기기 목록
    private var deviceList: some View {
        List(bluetoothManager.discoveredPeripherals, id: \.identifier) { peripheral in
            Button {
                bluetoothManager.connect(peripheral: peripheral)
            } label: {
                HStack {
                    VStack(alignment: .leading, spacing: 4) {
                        Text(peripheral.name ?? "Unknown Device")
                            .font(.headline)

                        Text(peripheral.identifier.uuidString)
                            .font(.caption)
                            .foregroundStyle(.secondary)

                        if peripheral.state == .connected {
                            Text("연결됨")
                                .font(.caption2)
                                .foregroundStyle(.green)
                        }
                    }

                    Spacer()

                    Image(systemName: "chevron.right")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }
            }
            .disabled(peripheral.state == .connected)
        }
    }
}