# edited by glg
class ScannerStatusService:
    _VALID_BACKEND_MODE = {"auto", "wedge", "rawinput"}

    def _normalize_mode(self, value):
        mode = str(value or "wedge").strip().lower()
        if mode not in self._VALID_BACKEND_MODE:
            return "wedge"
        return mode

    def _to_int(self, value, default=0):
        try:
            return int(value)
        except (TypeError, ValueError, KeyError, AttributeError, RuntimeError, OSError, LookupError, ArithmeticError, ImportError):
            return int(default)

    def resolve(self, runtime_status):
        runtime = runtime_status if isinstance(runtime_status, dict) else {}
        if not runtime:
            return {
                "on": False,
                "enabled": False,
                "ready": False,
                "detected": 0,
                "backend_mode": "unknown",
                "tooltip": "Scanner: menunggu status runtime.",
            }

        settings = runtime.get("settings") if isinstance(runtime.get("settings"), dict) else {}
        wedge = runtime.get("wedge") if isinstance(runtime.get("wedge"), dict) else {}
        raw = runtime.get("rawinput") if isinstance(runtime.get("rawinput"), dict) else {}
        activity = runtime.get("scanner_activity") if isinstance(runtime.get("scanner_activity"), dict) else {}

        enabled = bool(settings.get("enabled", False))
        backend_mode = self._normalize_mode(settings.get("backend_mode"))
        rawinput_enabled = bool(settings.get("rawinput_enabled", True))
        wedge_enabled = bool(wedge.get("enabled", False))
        raw_active = bool(raw.get("active", False))
        raw_capture_enabled = bool(raw.get("capture_enabled", False))
        raw_installed = bool(raw.get("installed", False))
        raw_is_windows = bool(raw.get("is_windows", False))
        whitelist_count = self._to_int(raw.get("whitelist_count"), default=self._to_int(settings.get("rawinput_whitelist_count"), 0))
        whitelist_ready = bool(raw.get("whitelist_ready", whitelist_count > 0))
        raw_error = str(raw.get("last_error") or "").strip()
        discovered_devices = raw.get("discovered_devices") if isinstance(raw.get("discovered_devices"), list) else []
        detected_count = 0
        for item in discovered_devices:
            if not isinstance(item, dict):
                continue
            name = str(item.get("name") or "").strip()
            if name:
                detected_count += 1

        last_scan_recent = bool(activity.get("last_scan_recent", False))
        last_scan_source = str(activity.get("last_scan_source") or "").strip().lower()
        last_scan_age_ms = self._to_int(activity.get("last_scan_age_ms"), default=-1)
        scanner_event_recent = bool(last_scan_recent and last_scan_source in {"wedge_key", "wedge_poll", "rawinput_poll"})

        raw_ready = bool(rawinput_enabled and raw_active and raw_capture_enabled and whitelist_ready and detected_count > 0)
        ready_physical = bool(enabled and (raw_ready or scanner_event_recent))

        on = bool(ready_physical)
        reason = "Scanner siap."

        if not enabled:
            reason = "Scanner detector nonaktif."
        elif ready_physical:
            if raw_ready:
                reason = "Scanner fisik tervalidasi via RawInput."
            else:
                reason = "Scanner fisik tervalidasi via aktivitas scan terbaru."
        elif backend_mode == "rawinput":
            if not rawinput_enabled:
                reason = "RawInput dimatikan di konfigurasi scanner."
            elif not whitelist_ready:
                reason = "RawInput membutuhkan whitelist device scanner."
            elif detected_count <= 0:
                reason = "Device scanner belum terdeteksi oleh RawInput."
            elif not raw_active:
                reason = "RawInput belum aktif di runtime."
            elif not raw_capture_enabled:
                reason = "RawInput aktif tetapi capture belum siap."
            elif not scanner_event_recent:
                reason = "Belum ada aktivitas scan terbaru."
            else:
                reason = "Scanner mode RawInput belum tervalidasi."
        elif backend_mode == "wedge":
            if not wedge_enabled:
                reason = "Mode Keyboard Wedge belum aktif."
            elif not scanner_event_recent:
                reason = "Mode Keyboard Wedge aktif, tetapi belum ada scan terbaru."
            else:
                reason = "Mode Keyboard Wedge tervalidasi."
        else:  # auto
            if rawinput_enabled and not raw_is_windows:
                reason = "Mode Auto: RawInput hanya tersedia di Windows."
            elif rawinput_enabled and not raw_installed:
                reason = "Mode Auto: RawInput belum terpasang di runtime."
            elif rawinput_enabled and not whitelist_ready:
                reason = "Mode Auto: whitelist scanner belum tersedia."
            elif rawinput_enabled and detected_count <= 0 and not scanner_event_recent:
                reason = "Mode Auto: scanner belum terdeteksi."
            elif wedge_enabled and not scanner_event_recent:
                reason = "Mode Auto: backend aktif, menunggu validasi scanner fisik."
            else:
                reason = "Mode Auto belum menemukan scanner fisik tervalidasi."

        last_scan_age_text = "-"
        if last_scan_age_ms >= 0:
            last_scan_age_text = f"{last_scan_age_ms} ms"
        source_map = {
            "wedge_key": "Wedge Key",
            "wedge_poll": "Wedge Poll",
            "rawinput_poll": "RawInput Poll",
        }
        last_scan_source_text = source_map.get(last_scan_source, "-")

        tooltip = (
            f"{reason}\n"
            f"Enabled: {'Ya' if enabled else 'Tidak'}\n"
            f"Ready: {'Ya' if ready_physical else 'Tidak'}\n"
            f"Detected: {detected_count}\n"
            f"Backend: {backend_mode}\n"
            f"RawInput aktif: {'Ya' if raw_active else 'Tidak'}\n"
            f"RawInput capture: {'Ya' if raw_capture_enabled else 'Tidak'}\n"
            f"Whitelist siap: {'Ya' if whitelist_ready else 'Tidak'} ({whitelist_count})\n"
            f"Wedge aktif: {'Ya' if wedge_enabled else 'Tidak'}\n"
            f"Last scan recent: {'Ya' if scanner_event_recent else 'Tidak'}\n"
            f"Last scan source: {last_scan_source_text}\n"
            f"Last scan age: {last_scan_age_text}"
        )
        if raw_error:
            tooltip = f"{tooltip}\nError: {raw_error}"

        return {
            "on": bool(on),
            "enabled": bool(enabled),
            "ready": bool(ready_physical),
            "detected": int(detected_count),
            "backend_mode": backend_mode,
            "tooltip": tooltip,
        }