from server.services.adb import Adb
from server.services.device import DeviceProfile
from server.services.profile_poller import profile_poller
from server.services.rapt import rapt
from server.services.sessions import sessions


class LoginService:
    def guest(self, raw_device: dict | None) -> dict:
        device = DeviceProfile.merge(raw_device)
        token = rapt.guest_token(device)
        return self._finish(token, device)

    def password(self, email: str, password: str, raw_device: dict | None) -> dict:
        device = DeviceProfile.merge(raw_device)
        token = rapt.email_token(email.strip(), password, device)
        return self._finish(token, device)

    def adb(self, serial: str, adb_path: str, source: str, raw_device: dict | None) -> dict:
        if not serial.strip():
            raise RuntimeError("请选择设备")
        adb = Adb.locate(adb_path.strip())
        if source == "device":
            device = adb.read_profile(serial.strip())
            chosen = DeviceProfile.merge(raw_device) if raw_device else None
            if chosen is not None and raw_device:
                if (raw_device.get("fingerprint") or "").strip():
                    device.fingerprint = chosen.fingerprint
                if (raw_device.get("language") or "").strip():
                    device.language = chosen.language
        else:
            device = DeviceProfile.merge(raw_device)
        token = adb.read_token(serial.strip())
        return self._finish(token, device)

    def current(self, token: str, raw_device: dict | None) -> dict:
        token = token.strip()
        if not token:
            raise RuntimeError("请先登录")
        device = sessions.bind(token, DeviceProfile.merge(raw_device))
        profile = rapt.user_info(token, device)
        self._watch(token, profile)
        return {"token": token, "profile": profile, "device": device.as_dict()}

    def _finish(self, token: str, device: DeviceProfile) -> dict:
        bound = sessions.bind(token, device, replace=True)
        profile = rapt.user_info(token, bound)
        self._watch(token, profile)
        return {"token": token, "profile": profile, "device": bound.as_dict()}

    @staticmethod
    def _watch(token: str, profile: dict) -> None:
        sessions.remember(token, profile)
        profile_poller.ensure(token)


login = LoginService()