import MMTToolForNordicTool

class ViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Configure DFU manager
        MMTToolForNordicDFUTool.configManager()
        
        // Add DFU delegate
        MMTToolForNordicDFUTool.addDelegate(self)
        
        // Configure log system
        MMTToolForNordicLog.configure { config in
            config.minimumLevel = .debug
            config.enableConsole = true
            config.cacheEnabled = true
            config.cacheLimit = 500
            config.enableColors = true
        }
        
        // Set custom log handler
        MMTToolForNordicLog.setCustomHandler { [weak self] entry in
            DispatchQueue.main.async {
                self?.addLogToUI(entry.simplifiedMessage)
            }
        }
    }
    
    deinit {
        // Remove delegate
        MMTToolForNordicDFUTool.removeDelegate(self)
    }
}

extension ViewController: CBCentralManagerDelegate {
    
    /// Start scanning for Bluetooth devices
    private func startScanning() {
        guard centralManager.state == .poweredOn else {
            updateStatus("Bluetooth is not powered on")
            return
        }
        
        // Clear old data
        discoveredDevices.removeAll()
        deviceMACMap.removeAll()
        deviceNameMap.removeAll()
        deviceRSSIMap.removeAll()
        macToDeviceMap.removeAll()
        
        // Start scanning
        centralManager.scanForPeripherals(withServices: nil, options: [
            CBCentralManagerScanOptionAllowDuplicatesKey: false
        ])
    }
    
    /// Device discovery callback
    func centralManager(_ central: CBCentralManager, 
                       didDiscover peripheral: CBPeripheral,
                       advertisementData: [String: Any], 
                       rssi RSSI: NSNumber) {
        
        // Extract device name
        let localName = peripheral.name ?? ""
        let peripheralName = advertisementData["kCBAdvDataLocalName"] as? String ?? localName
        
        // Extract MAC address
        var mac: String?
        var macExtra: String?
        if let macData = advertisementData["kCBAdvDataManufacturerData"] as? Data {
            let macList = macData.map({ String(format: "%02x", $0).uppercased() })
            mac = macList[0..<6].joined(separator: ":")
            if macList.count > 6 {
                macExtra = macList[6..<macList.count].joined(separator: ":")
            }
        }
        
        // Deduplicate by MAC address, keep device with highest RSSI
        if let macAddress = mac {
            if let existingDeviceId = macToDeviceMap[macAddress] {
                if let existingRSSI = deviceRSSIMap[existingDeviceId] {
                    if RSSI.intValue > existingRSSI.intValue {
                        // Replace with device having stronger signal
                        updateDevice(peripheral, macAddress, macExtra, peripheralName, RSSI)
                    }
                }
            } else {
                // Add new device
                addDevice(peripheral, macAddress, macExtra, peripheralName, RSSI)
            }
        }
    }
}

extension ViewController {
    
    /// Device connected
    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
        isConnected = true
        peripheral.delegate = self
        
        // Automatically scan services and characteristics
        peripheral.discoverServices(nil)
    }
}

extension ViewController: CBPeripheralDelegate {
    
    /// Services discovered callback
    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
        guard let services = peripheral.services else { return }
        discoveredServices = services
        
        // Scan characteristics for each service
        for service in services {
            peripheral.discoverCharacteristics(nil, for: service)
        }
    }
    
    /// Characteristics discovered callback
    func peripheral(_ peripheral: CBPeripheral, 
                   didDiscoverCharacteristicsFor service: CBService, 
                   error: Error?) {
        guard let characteristics = service.characteristics else { return }
        
        // Store characteristics
        serviceCharacteristicsMap[service.uuid] = characteristics
        
        // Subscribe to notifications
        for characteristic in characteristics {
            peripheral.setNotifyValue(true, for: characteristic)
        }
    }
}

extension ViewController {
    
    /// Start DFU upgrade
    private func startDFUUpgrade() {
        guard let device = selectedDevice,
              let firmwareURL = selectedFirmwareURL,
              isConnected else {
            return
        }
        
        let deviceUUID = device.identifier.uuidString
        let macInfo = deviceMACMap[device.identifier]
        let deviceMac = macInfo?.mac ?? ""
        let deviceMacExtra = macInfo?.macExtra ?? ""
        let filePath = firmwareURL.path
        let startAddress = "01080000"  // Start address
        
        // Start DFU upgrade
        MMTToolForNordicDFUTool.startDfu(
            deviceUUID: deviceUUID,
            deviceMac: deviceMac,
            deviceMacExtra: deviceMacExtra,
            peripheral: device,
            startAddress: startAddress,
            filePath: filePath
        )
    }
}

// MARK: - DFU Delegate Implementation
extension ViewController: MMTToolForNordicDFUDelegate {
    
    /// DFU mode entered successfully
    func mmtToolForNordicUnitDidEnter(_ unit: MMTToolForNordicDFUToolUnit?) {
        print("✅ DFU Unit entered successfully")
        updateStatus("DFU mode ready")
    }
    
    /// DFU mode entry failed
    func mmtToolForNordicUnitDidFailToEnter(_ unit: MMTToolForNordicDFUToolUnit?, error: Error?) {
        print("❌ DFU Unit entry failed: \(error?.localizedDescription ?? "")")
        updateStatus("DFU mode entry failed")
    }
    
    /// DFU upgrade started
    func mmtToolForNordicUnitDFUDidBegin(_ unit: MMTToolForNordicDFUToolUnit?) {
        print("🚀 DFU started")
        updateStatus("DFU upgrade in progress...")
    }
    
    /// DFU progress changed
    func mmtToolForNordicUnitDFUDidChangeProgress(_ unit: MMTToolForNordicDFUToolUnit?, progress: Int) {
        print("📊 DFU progress: \(progress)%")
        updateStatus("DFU progress: \(progress)%")
    }
    
    /// DFU completed
    func mmtToolForNordicUnitDFUDidEnd(_ unit: MMTToolForNordicDFUToolUnit?, progress: Int?, error: Error?) {
        if let error = error {
            print("❌ DFU failed: \(error.localizedDescription)")
            updateStatus("DFU failed: \(error.localizedDescription)")
        } else {
            print("✅ DFU completed, progress: \(progress ?? 100)%")
            updateStatus("DFU upgrade completed!")
        }
    }
    
    /// Get DFU service and characteristics
    func mmtToolForNordicUnitGetUUID(_ unit: MMTToolForNordicDFUToolUnit?) -> MMTToolForNordicDFUDelegate.DFUServerTurple? {
        guard let device = selectedDevice else { return nil }
        
        // Iterate through discovered services
        for service in discoveredServices {
            guard let characteristics = serviceCharacteristicsMap[service.uuid] else {
                continue
            }
            
            // Find DFU related characteristics
            var readCharacter: CBCharacteristic?
            var writeCharacter: CBCharacteristic?
            var controlCharacter: CBCharacteristic?
            
            for char in characteristics {
                let charUUID = char.uuid.uuidString.uppercased()
                
                // Match DFU characteristics by UUID
                if charUUID.contains("8EC9") || charUUID.contains("0001") {
                    controlCharacter = char
                } else if charUUID.contains("0002") {
                    writeCharacter = char
                } else if charUUID.contains("0003") {
                    readCharacter = char
                }
            }
            
            if readCharacter != nil || writeCharacter != nil || controlCharacter != nil {
                return (service, readCharacter, writeCharacter, controlCharacter)
            }
        }
        
        return nil
    }
    
    /// Get currently selected device
    func mmtToolForNordicUnitGetPeripheral(_ unit: MMTToolForNordicDFUToolUnit?) -> CBPeripheral? {
        return selectedDevice
    }
}

// Extract device name from advertisement data (prefer kCBAdvDataLocalName)
let peripheralName = advertisementData["kCBAdvDataLocalName"] as? String ?? peripheral.name ?? ""

// Extract MAC address from manufacturer data
if let macData = advertisementData["kCBAdvDataManufacturerData"] as? Data {
    let macList = macData.map({ String(format: "%02x", $0).uppercased() })
    let mac = macList[0..<6].joined(separator: ":")
}