using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Reflection;
using System.Threading;
using Windows.Devices.Enumeration;
using Windows.Devices.Bluetooth;
using Windows.Devices.Bluetooth.Advertisement;
using Windows.Foundation;

class DeviceTarget {
    public string Key;         // "K370", "M240"
    public string Name;        // "LOGI K370 B", "LOGI M240 B"
    public bool IsKeyboard;
    public BluetoothLEDevice PairedBle;
    public string Status = ""; // "CONNECTED", "PAIRED_WAITING", "SEARCHING_FOR_PAIR"

    public DeviceTarget(string key, string name, bool isKeyboard) {
        this.Key = key;
        this.Name = name;
        this.IsKeyboard = isKeyboard;
    }
}

class BlePairer {
    static MethodInfo asTaskGeneric = null;
    static Dictionary<string, DeviceTarget> targets = new Dictionary<string, DeviceTarget>() {
        { "K370", new DeviceTarget("K370", "LOGI K370 B", true) },
        { "M240", new DeviceTarget("M240", "LOGI M240 B", false) }
    };

    static ConcurrentDictionary<string, DateTime> liveRfMacs = new ConcurrentDictionary<string, DateTime>();
    static ConcurrentDictionary<string, DeviceInformation> uncollectedDevices = new ConcurrentDictionary<string, DeviceInformation>();

    static object pairingLock = new object();
    static bool isPairingInProgress = false;
    static string activePairingKey = "";

    static BluetoothLEAdvertisementWatcher advWatcher = null;
    static DeviceWatcher devWatcher = null;
    static bool isScanningActive = false;
    static object scanLock = new object();

    static T AwaitOp<T>(object asyncOp, int timeoutMs) {
        if (asyncOp == null) return default(T);
        if (asTaskGeneric == null) {
            var methods = typeof(System.WindowsRuntimeSystemExtensions).GetMethods();
            foreach (var m in methods) {
                if (m.Name == "AsTask" && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType.Name == "IAsyncOperation`1") {
                    asTaskGeneric = m;
                    break;
                }
            }
        }
        var method = asTaskGeneric.MakeGenericMethod(typeof(T));
        object task = method.Invoke(null, new object[] { asyncOp });
        var waitMethod = task.GetType().GetMethod("Wait", new Type[] { typeof(int) });
        bool finished = (bool)waitMethod.Invoke(task, new object[] { timeoutMs });
        if (finished) {
            var resultProp = task.GetType().GetProperty("Result");
            return (T)resultProp.GetValue(task, null);
        }
        return default(T);
    }

    static string FormatMac(ulong rawAddr) {
        string hex = rawAddr.ToString("X12").ToLower();
        return string.Format("{0}:{1}:{2}:{3}:{4}:{5}",
            hex.Substring(0, 2), hex.Substring(2, 2), hex.Substring(4, 2),
            hex.Substring(6, 2), hex.Substring(8, 2), hex.Substring(10, 2));
    }

    static DeviceTarget GetTargetForName(string name) {
        if (string.IsNullOrEmpty(name)) return null;
        string upper = name.ToUpper();
        if (upper.Contains("K370")) return targets["K370"];
        if (upper.Contains("M240")) return targets["M240"];
        return null;
    }

    static void SetDeviceStatus(DeviceTarget target, string newStatus) {
        lock (scanLock) {
            if (target.Status != newStatus) {
                target.Status = newStatus;
                Console.WriteLine("STATUS:" + target.Key + ":" + newStatus);
                UpdateScannerState();
            }
        }
    }

    static void UpdateScannerState() {
        lock (scanLock) {
            bool allConnected = true;
            foreach (var t in targets.Values) {
                if (t.Status != "CONNECTED") {
                    allConnected = false;
                    break;
                }
            }

            if (allConnected) {
                StopScanners();
            } else {
                StartScanners();
            }
        }
    }

    static void StartScanners() {
        lock (scanLock) {
            if (isScanningActive) return;

            try {
                if (advWatcher != null) {
                    advWatcher.ScanningMode = BluetoothLEScanningMode.Passive; // Passive 모드: 전파 송출 없이 청취만 수행
                    advWatcher.Start();
                }
                if (devWatcher != null && devWatcher.Status != DeviceWatcherStatus.Started && devWatcher.Status != DeviceWatcherStatus.EnumerationCompleted) {
                    devWatcher.Start();
                }
                isScanningActive = true;
                Console.WriteLine("[DEBUG] Scanners started (Passive mode, zero radio contention)");
            } catch (Exception ex) {
                Console.WriteLine("[DEBUG] StartScanners error: " + ex.Message);
            }
        }
    }

    static void StopScanners() {
        lock (scanLock) {
            if (!isScanningActive) return;

            try {
                if (advWatcher != null) {
                    advWatcher.Stop();
                }
                if (devWatcher != null && (devWatcher.Status == DeviceWatcherStatus.Started || devWatcher.Status == DeviceWatcherStatus.EnumerationCompleted)) {
                    devWatcher.Stop();
                }
                isScanningActive = false;
                Console.WriteLine("[DEBUG] Scanners stopped (All devices connected, radio fully released)");
            } catch (Exception ex) {
                Console.WriteLine("[DEBUG] StopScanners error: " + ex.Message);
            }
        }
    }

    static void AttachPairedDevice(DeviceTarget target, BluetoothLEDevice ble) {
        if (ble == null) return;
        lock (scanLock) {
            if (target.PairedBle != null && target.PairedBle.DeviceId != ble.DeviceId) {
                try { target.PairedBle.Dispose(); } catch {}
            }
            target.PairedBle = ble;
            target.PairedBle.ConnectionStatusChanged += (s, e) => {
                Console.WriteLine("[DEBUG] " + target.Name + " ConnectionStatusChanged: " + s.ConnectionStatus);
                if (s.ConnectionStatus == BluetoothConnectionStatus.Connected) {
                    SetDeviceStatus(target, "CONNECTED");
                } else {
                    SetDeviceStatus(target, "PAIRED_WAITING");
                }
            };

            Console.WriteLine("[DEBUG] Attached to " + target.Name + " (" + FormatMac(ble.BluetoothAddress) + "), Conn: " + ble.ConnectionStatus);
            if (ble.ConnectionStatus == BluetoothConnectionStatus.Connected) {
                SetDeviceStatus(target, "CONNECTED");
            } else {
                SetDeviceStatus(target, "PAIRED_WAITING");
            }
        }
    }

    static void OnPairingRequested(DeviceInformationCustomPairing sender, DevicePairingRequestedEventArgs eventArgs) {
        Console.WriteLine("[DEBUG] PairingRequested fired! Mode: " + eventArgs.PairingKind);
        switch (eventArgs.PairingKind) {
            case DevicePairingKinds.ConfirmOnly:
                eventArgs.Accept();
                break;
            case DevicePairingKinds.ProvidePin:
                Console.WriteLine("[DEBUG] ProvidePin requested: using '0000'");
                eventArgs.Accept("0000");
                break;
            case DevicePairingKinds.ConfirmPinMatch:
            case DevicePairingKinds.DisplayPin:
                if (!string.IsNullOrEmpty(eventArgs.Pin)) {
                    Console.WriteLine("PIN_REQUIRED:" + activePairingKey + ":" + eventArgs.Pin);
                }
                eventArgs.Accept();
                break;
            default:
                eventArgs.Accept();
                break;
        }
    }

    static void TryPairDevice(DeviceInformation dev, string mac, DeviceTarget target) {
        lock (pairingLock) {
            if (isPairingInProgress) return;
            isPairingInProgress = true;
            activePairingKey = target.Key;
        }

        try {
            Console.WriteLine("DEVICE_DETECTED:" + target.Key + ":" + mac);
            Console.WriteLine("[DEBUG] Initiating pairing with live " + target.Name + ": " + mac);

            var customPairing = dev.Pairing.Custom;
            customPairing.PairingRequested += new TypedEventHandler<DeviceInformationCustomPairing, DevicePairingRequestedEventArgs>(OnPairingRequested);

            var kinds = DevicePairingKinds.ConfirmOnly |
                        DevicePairingKinds.ProvidePin |
                        DevicePairingKinds.ConfirmPinMatch |
                        DevicePairingKinds.DisplayPin;

            var opPair = customPairing.PairAsync(kinds, DevicePairingProtectionLevel.Default);
            var res = AwaitOp<DevicePairingResult>(opPair, 60000); // Wait up to 60s for PIN if keyboard

            if (res != null && (res.Status == DevicePairingResultStatus.Paired || res.Status == DevicePairingResultStatus.AlreadyPaired)) {
                Console.WriteLine("PAIRED_AND_CONNECTED:" + target.Key + ":" + mac);

                // 새 장치로 BluetoothLEDevice 바인딩
                try {
                    var opBle = BluetoothLEDevice.FromIdAsync(dev.Id);
                    var newBle = AwaitOp<BluetoothLEDevice>(opBle, 2000);
                    if (newBle != null) {
                        AttachPairedDevice(target, newBle);
                    }
                } catch {}

                // 이전 구버전 MAC 인스턴스 정리
                try {
                    var opAll = DeviceInformation.FindAllAsync(BluetoothLEDevice.GetDeviceSelector());
                    var allDevs = AwaitOp<DeviceInformationCollection>(opAll, 3000);
                    if (allDevs != null) {
                        foreach (var d in allDevs) {
                            if (d.Id != dev.Id && GetTargetForName(d.Name) == target) {
                                var opOld = BluetoothLEDevice.FromIdAsync(d.Id);
                                var oldBle = AwaitOp<BluetoothLEDevice>(opOld, 2000);
                                if (oldBle != null) {
                                    if (oldBle.DeviceInformation.Pairing.IsPaired) {
                                        string oldMac = FormatMac(oldBle.BluetoothAddress);
                                        if (oldMac != mac) {
                                            Console.WriteLine("[DEBUG] Cleaning up stale paired instance: " + oldMac);
                                            var unpairOp = oldBle.DeviceInformation.Pairing.UnpairAsync();
                                            AwaitOp<DeviceUnpairingResult>(unpairOp, 3000);
                                        }
                                    }
                                    oldBle.Dispose();
                                }
                            }
                        }
                    }
                } catch {}
            } else {
                Console.WriteLine("[DEBUG] Pairing result for " + target.Name + ": " + (res != null ? res.Status.ToString() : "Timeout"));
            }
        } catch (Exception ex) {
            Console.WriteLine("[DEBUG] TryPairDevice exception: " + ex.Message);
        } finally {
            lock (pairingLock) {
                isPairingInProgress = false;
                activePairingKey = "";
            }
        }
    }

    static void CheckAndTriggerPair(DeviceInformation dev, string mac) {
        if (dev == null || string.IsNullOrEmpty(mac)) return;
        var target = GetTargetForName(dev.Name);
        if (target == null) return;

        DateTime lastSeen;
        if (liveRfMacs.TryGetValue(mac, out lastSeen)) {
            if ((DateTime.UtcNow - lastSeen).TotalSeconds < 10) {
                new Thread(() => TryPairDevice(dev, mac, target)).Start();
            }
        }
    }

    static void RefreshPairedDevices() {
        try {
            var op = DeviceInformation.FindAllAsync(BluetoothLEDevice.GetDeviceSelector());
            var devices = AwaitOp<DeviceInformationCollection>(op, 2000);
            if (devices != null) {
                foreach (var dev in devices) {
                    var target = GetTargetForName(dev.Name);
                    if (target != null) {
                        var opBle = BluetoothLEDevice.FromIdAsync(dev.Id);
                        var ble = AwaitOp<BluetoothLEDevice>(opBle, 2000);
                        if (ble != null) {
                            if (ble.DeviceInformation.Pairing.IsPaired) {
                                if (target.PairedBle == null || target.PairedBle.DeviceId != ble.DeviceId) {
                                    AttachPairedDevice(target, ble);
                                } else {
                                    if (target.PairedBle.ConnectionStatus == BluetoothConnectionStatus.Connected) {
                                        SetDeviceStatus(target, "CONNECTED");
                                    } else {
                                        SetDeviceStatus(target, "PAIRED_WAITING");
                                    }
                                    ble.Dispose();
                                }
                            } else {
                                ble.Dispose();
                            }
                        }
                    }
                }
            }
        } catch (Exception ex) {
            Console.WriteLine("[DEBUG] RefreshPairedDevices error: " + ex.Message);
        }

        foreach (var t in targets.Values) {
            if (t.PairedBle == null) {
                SetDeviceStatus(t, "SEARCHING_FOR_PAIR");
            }
        }
    }

    static void RunMonitorDaemon() {
        Console.WriteLine("[DEBUG] Initializing BlePairer multi-device daemon (K370 Keyboard + M240 Mouse)...");

        // 1. Passive Advertisement Watcher (무선 송신 없이 신호만 청취)
        advWatcher = new BluetoothLEAdvertisementWatcher();
        advWatcher.ScanningMode = BluetoothLEScanningMode.Passive;
        advWatcher.Received += (s, e) => {
            string rawMac = e.BluetoothAddress.ToString("X12").ToLower();
            string macWithColons = FormatMac(e.BluetoothAddress);
            DateTime now = DateTime.UtcNow;
            liveRfMacs[macWithColons] = now;
            liveRfMacs[rawMac] = now;

            DeviceInformation pendingDev;
            if (uncollectedDevices.TryGetValue(macWithColons, out pendingDev)) {
                CheckAndTriggerPair(pendingDev, macWithColons);
            }
        };

        // 2. DeviceWatcher
        string[] requestedProps = {
            "System.Devices.Aep.DeviceAddress",
            "System.Devices.Aep.IsConnected",
            "System.Devices.Aep.IsPresent",
            "System.Devices.Aep.CanPair",
            "System.Devices.Aep.IsPaired",
            "System.Devices.Aep.SignalStrength"
        };
        string selector = "System.Devices.DevObjectType:=5 AND System.Devices.Aep.ProtocolId:=\"{BB7BB05E-5972-42B5-94FC-76EAA7084D49}\"";
        devWatcher = DeviceInformation.CreateWatcher(selector, requestedProps, DeviceInformationKind.AssociationEndpoint);

        Action<DeviceInformation> handleDevice = (dev) => {
            if (dev == null || string.IsNullOrEmpty(dev.Name)) return;
            var target = GetTargetForName(dev.Name);
            if (target == null) return;

            string addr = "";
            if (dev.Properties.ContainsKey("System.Devices.Aep.DeviceAddress") && dev.Properties["System.Devices.Aep.DeviceAddress"] != null) {
                addr = dev.Properties["System.Devices.Aep.DeviceAddress"].ToString().ToLower();
            }

            bool isPaired = dev.Pairing != null && dev.Pairing.IsPaired;
            bool canPair = dev.Pairing != null && dev.Pairing.CanPair;

            if (!isPaired && canPair && !string.IsNullOrEmpty(addr)) {
                uncollectedDevices[addr] = dev;
                CheckAndTriggerPair(dev, addr);
            }
        };

        devWatcher.Added += (s, dev) => handleDevice(dev);
        devWatcher.Updated += (s, upd) => {
            foreach (var kv in uncollectedDevices) {
                if (upd.Id.ToLower().Contains(kv.Key.Replace(":", ""))) {
                    CheckAndTriggerPair(kv.Value, kv.Key);
                }
            }
        };

        // 초기 시스템 등록 상태 확인
        RefreshPairedDevices();

        // 메인 폴링 루프 (2초 주기): 이벤트 누락 방지용 가벼운 헬스체크
        while (true) {
            Thread.Sleep(2000);

            foreach (var t in targets.Values) {
                if (t.PairedBle != null) {
                    var connStatus = t.PairedBle.ConnectionStatus;
                    if (connStatus == BluetoothConnectionStatus.Connected) {
                        SetDeviceStatus(t, "CONNECTED");
                    } else {
                        SetDeviceStatus(t, "PAIRED_WAITING");
                    }
                } else {
                    RefreshPairedDevices();
                }
            }
        }
    }

    static int Main(string[] args) {
        try {
            if (args.Length >= 1 && args[0].ToLower() == "monitor") {
                RunMonitorDaemon();
                return 0;
            }

            RefreshPairedDevices();
            foreach (var t in targets.Values) {
                Console.WriteLine(t.Key + ":" + t.Status);
            }
            return 0;
        } catch (Exception ex) {
            Console.WriteLine("[DEBUG] Main exception: " + ex.ToString());
            return 99;
        }
    }
}