# edited by glg
import platform
import uuid


class ScannerDiagnosticService:
    # edited by glg
    @staticmethod
    def _new_trace_id(scope: str = "scanner_diag") -> str:
        return f"scanner-{str(scope or 'diag').strip().lower()}-{uuid.uuid4().hex[:10]}"

    # edited by glg
    @staticmethod
    def _to_int(value, default=0, min_value=None):
        try:
            parsed = int(float(value))
        except (TypeError, ValueError, KeyError, AttributeError, RuntimeError, OSError, LookupError, ArithmeticError, ImportError):
            parsed = int(default)
        if min_value is not None and parsed < int(min_value):
            return int(default)
        return int(parsed)

    # edited by glg
    @staticmethod
    def _to_bool(value, default=False):
        if value is None:
            return bool(default)
        if isinstance(value, bool):
            return value
        text = str(value).strip().lower()
        if text in {"1", "true", "yes", "on"}:
            return True
        if text in {"0", "false", "no", "off"}:
            return False
        try:
            return int(float(value)) > 0
        except (TypeError, ValueError, KeyError, AttributeError, RuntimeError, OSError, LookupError, ArithmeticError, ImportError):
            return bool(default)

    def run(self, settings, runtime=None):
        trace_id = self._new_trace_id("run")
        cfg = settings if isinstance(settings, dict) else {}
        rt = runtime if isinstance(runtime, dict) else {}

        enabled = self._to_bool(cfg.get("enabled"), False)
        backend_mode = str(cfg.get("backend_mode") or "wedge").strip().lower()
        rawinput_enabled = self._to_bool(cfg.get("rawinput_enabled"), True)
        whitelist = cfg.get("rawinput_whitelist") if isinstance(cfg.get("rawinput_whitelist"), list) else []
        duplicate_guard_ms = self._to_int(cfg.get("duplicate_guard_ms", 180), 180, min_value=1)
        is_windows = platform.system().lower() == "windows"

        checks = []
        checks.append(
            {
                "name": "detector_enabled",
                "status": "PASS" if enabled else "WARN",
                "message": "Deteksi scanner aktif." if enabled else "Deteksi scanner nonaktif.",
            }
        )
        checks.append(
            {
                "name": "platform_windows",
                "status": "PASS" if is_windows else "WARN",
                "message": "Platform Windows terdeteksi." if is_windows else "RawInput hanya tersedia di Windows.",
            }
        )
        checks.append(
            {
                "name": "backend_mode",
                "status": "PASS" if backend_mode in {"auto", "wedge", "rawinput"} else "FAIL",
                "message": f"Mode backend scanner: {backend_mode}.",
            }
        )

        if backend_mode in {"auto", "rawinput"}:
            whitelist_status = "PASS"
            whitelist_message = f"Whitelist perangkat terisi {len(whitelist)} token."
            if len(whitelist) == 0:
                if backend_mode == "rawinput" and rawinput_enabled:
                    whitelist_status = "FAIL"
                    whitelist_message = "Mode RawInput wajib whitelist device scanner."
                else:
                    whitelist_status = "WARN"
                    whitelist_message = "Whitelist kosong. Mode Auto akan bergantung pada fallback keyboard."
            checks.append(
                {
                    "name": "rawinput_enabled",
                    "status": "PASS" if rawinput_enabled else "WARN",
                    "message": "RawInput diaktifkan." if rawinput_enabled else "RawInput dinonaktifkan pada konfigurasi.",
                }
            )
            checks.append(
                {
                    "name": "rawinput_whitelist",
                    "status": whitelist_status,
                    "message": whitelist_message,
                }
            )

        rawinput_rt = rt.get("rawinput") if isinstance(rt.get("rawinput"), dict) else {}
        if rawinput_rt:
            active = bool(rawinput_rt.get("active", False))
            capture_enabled = bool(rawinput_rt.get("capture_enabled", False))
            checks.append(
                {
                    "name": "rawinput_runtime",
                    "status": "PASS" if active and capture_enabled else "WARN",
                    "message": "RawInput runtime aktif untuk capture barcode." if active and capture_enabled else "RawInput runtime belum siap capture barcode.",
                }
            )

        pass_count = sum(1 for c in checks if c.get("status") == "PASS")
        warn_count = sum(1 for c in checks if c.get("status") == "WARN")
        fail_count = sum(1 for c in checks if c.get("status") == "FAIL")
        overall = "PASS" if fail_count == 0 and warn_count == 0 else ("WARN" if fail_count == 0 else "FAIL")

        return {
            "overall_status": overall,
            "error_code": "" if overall == "PASS" else "SCANNER_DIAGNOSTIC_WARN_OR_FAIL",
            "reason": "ok" if overall == "PASS" else "scanner_diagnostic_requires_attention",
            "trace_id": trace_id,
            "checks": checks,
            "settings": {
                "enabled": enabled,
                "backend_mode": backend_mode,
                "rawinput_enabled": rawinput_enabled,
                "duplicate_guard_ms": duplicate_guard_ms,
                "rawinput_whitelist_count": len(whitelist),
            },
            "runtime": rt,
            "summary": {
                "pass": pass_count,
                "warn": warn_count,
                "fail": fail_count,
            },
        }