from __future__ import annotations

"""
Android Service Autofill 组件 — AutofillService, FillRequest, FillResponse,
SaveRequest, SaveInfo, Dataset, AutofillFieldClassificationService 等
方法签名完全对齐 Android SDK (android.service.autofill 包)
"""

import time
from typing import Any, Callable, Dict, List, Optional, Set

from .._core import Stub, AndroidOnlyError


# ═══════════════════════════════════════════════════════════════
# FillRequest
# ═══════════════════════════════════════════════════════════════

class FillRequest(Stub):
    """FillRequest — 自动填充请求"""

    # 请求标志
    FLAG_MANUAL_REQUEST = 0x0001
    FLAG_COMPATIBILITY_MODE_REQUEST = 0x0002

    def __init__(self, request_id: int = 0, flags: int = 0,
                 fill_contexts: Optional[List[Any]] = None):
        super().__init__()
        self._request_id = request_id
        self._flags = flags
        self._fill_contexts = fill_contexts or []
        self._client_state: Optional[Any] = None

    def getId(self) -> int:
        """获取请求 ID"""
        return self._request_id

    def getFlags(self) -> int:
        """获取标志"""
        return self._flags

    def getFillContexts(self) -> List[Any]:
        """获取填充上下文"""
        return list(self._fill_contexts)

    def getClientState(self) -> Optional[Any]:
        return self._client_state

    def setClientState(self, state: Any):
        self._client_state = state

    def toString(self) -> str:
        return (f"FillRequest(id={self._request_id}, "
                f"flags={self._flags}, contexts={len(self._fill_contexts)})")

    def hashCode(self) -> int:
        return self._request_id & 0x7FFFFFFF

    def equals(self, other) -> bool:
        if not isinstance(other, FillRequest):
            return False
        return self._request_id == other._request_id


# ═══════════════════════════════════════════════════════════════
# Dataset
# ═══════════════════════════════════════════════════════════════

class Dataset(Stub):
    """Dataset — 自动填充数据集"""

    def __init__(self):
        super().__init__()
        self._field_values: Dict[Any, Any] = {}
        self._id: Optional[Any] = None
        self._authentication: Optional[Any] = None

    def getFieldValues(self) -> Dict[Any, Any]:
        return dict(self._field_values)

    def getId(self) -> Optional[Any]:
        return self._id

    def setId(self, id: Any):
        self._id = id

    def toString(self) -> str:
        return f"Dataset(fields={len(self._field_values)}, id={self._id})"

    def hashCode(self) -> int:
        return hash(str(self._id)) & 0x7FFFFFFF

    def equals(self, other) -> bool:
        if not isinstance(other, Dataset):
            return False
        return self._id == other._id

    # ── Builder ──

    class Builder(Stub):
        """Builder — Dataset 构建器"""

        def __init__(self):
            super().__init__()
            self._dataset = Dataset()

        def setId(self, id: Any) -> "Dataset.Builder":
            self._dataset._id = id
            return self

        def setValue(self, id: Any, value: Any) -> "Dataset.Builder":
            self._dataset._field_values[id] = value
            return self

        def setAuthentication(self, authentication: Any) -> "Dataset.Builder":
            self._dataset._authentication = authentication
            return self

        def build(self) -> Dataset:
            return self._dataset


# ═══════════════════════════════════════════════════════════════
# SaveInfo
# ═══════════════════════════════════════════════════════════════

class SaveInfo(Stub):
    """SaveInfo — 保存信息"""

    # 保存类型
    SAVE_DATA_TYPE_EMAIL = 0x0001
    SAVE_DATA_TYPE_PASSWORD = 0x0002
    SAVE_DATA_TYPE_USERNAME = 0x0004
    SAVE_DATA_TYPE_CREDIT_CARD = 0x0008
    SAVE_DATA_TYPE_ADDRESS = 0x0010
    SAVE_DATA_TYPE_GENERIC = 0x0020
    SAVE_DATA_TYPE_PASSWORD_V2 = 0x0040
    SAVE_DATA_TYPE_SMS_2FA = 0x0080
    SAVE_DATA_TYPE_BIRTH_DATE = 0x0100
    SAVE_DATA_TYPE_EMAIL_ADDRESS = 0x0200
    SAVE_DATA_TYPE_PHONE = 0x0400
    SAVE_DATA_TYPE_USERNAME_V2 = 0x0800
    SAVE_DATA_TYPE_CARD_NUMBER = 0x1000
    SAVE_DATA_TYPE_CARD_EXPIRATION_DATE = 0x2000
    SAVE_DATA_TYPE_CARD_SECURITY_CODE = 0x4000
    SAVE_DATA_TYPE_FI_ACCOUNT_NUMBER = 0x8000
    SAVE_DATA_TYPE_FI_ROUTING_NUMBER = 0x10000
    SAVE_DATA_TYPE_PASSPORT = 0x20000
    SAVE_DATA_TYPE_DRIVERS_LICENSE = 0x40000
    SAVE_DATA_TYPE_SSN = 0x80000

    # 标志
    FLAG_SAVE_ON_ALL_VIEWS_INVISIBLE = 0x0001

    def __init__(self):
        super().__init__()
        self._type: int = SaveInfo.SAVE_DATA_TYPE_GENERIC
        self._required_ids: List[Any] = []
        self._optional_ids: List[Any] = []
        self._description: Optional[Any] = None
        self._flags: int = 0
        self._trigger_ids: List[Any] = []
        self._validator: Optional[Any] = None

    def getType(self) -> int:
        return self._type

    def getRequiredIds(self) -> List[Any]:
        return list(self._required_ids)

    def getOptionalIds(self) -> List[Any]:
        return list(self._optional_ids)

    def getDescription(self) -> Optional[Any]:
        return self._description

    def getFlags(self) -> int:
        return self._flags

    def toString(self) -> str:
        return (f"SaveInfo(type={self._type}, required={len(self._required_ids)}, "
                f"optional={len(self._optional_ids)})")

    def hashCode(self) -> int:
        return hash((self._type, tuple(self._required_ids))) & 0x7FFFFFFF

    def equals(self, other) -> bool:
        if not isinstance(other, SaveInfo):
            return False
        return self._type == other._type

    # ── Builder ──

    class Builder(Stub):
        """Builder — SaveInfo 构建器"""

        def __init__(self, type_: int, required_ids: List[Any]):
            super().__init__()
            self._save_info = SaveInfo()
            self._save_info._type = type_
            self._save_info._required_ids = list(required_ids)

        def setOptionalIds(self, optional_ids: List[Any]) -> "SaveInfo.Builder":
            self._save_info._optional_ids = list(optional_ids)
            return self

        def setDescription(self, description: Any) -> "SaveInfo.Builder":
            self._save_info._description = description
            return self

        def setFlags(self, flags: int) -> "SaveInfo.Builder":
            self._save_info._flags = flags
            return self

        def setTriggerIds(self, trigger_ids: List[Any]) -> "SaveInfo.Builder":
            self._save_info._trigger_ids = list(trigger_ids)
            return self

        def setValidator(self, validator: Any) -> "SaveInfo.Builder":
            self._save_info._validator = validator
            return self

        def build(self) -> SaveInfo:
            return self._save_info


# ═══════════════════════════════════════════════════════════════
# FillResponse
# ═══════════════════════════════════════════════════════════════

class FillResponse(Stub):
    """FillResponse — 自动填充响应"""

    def __init__(self):
        super().__init__()
        self._datasets: List[Dataset] = []
        self._save_info: Optional[SaveInfo] = None
        self._client_state: Optional[Any] = None
        self._authentication_result: Optional[Any] = None

    def getDatasets(self) -> List[Dataset]:
        return list(self._datasets)

    def getSaveInfo(self) -> Optional[SaveInfo]:
        return self._save_info

    def getClientState(self) -> Optional[Any]:
        return self._client_state

    def toString(self) -> str:
        return (f"FillResponse(datasets={len(self._datasets)}, "
                f"saveInfo={'set' if self._save_info else 'none'})")

    def hashCode(self) -> int:
        return id(self) & 0x7FFFFFFF

    def equals(self, other) -> bool:
        return self is other

    # ── Builder ──

    class Builder(Stub):
        """Builder — FillResponse 构建器"""

        def __init__(self):
            super().__init__()
            self._response = FillResponse()

        def addDataset(self, dataset: Dataset) -> "FillResponse.Builder":
            self._response._datasets.append(dataset)
            return self

        def setDatasets(self, datasets: List[Dataset]) -> "FillResponse.Builder":
            self._response._datasets = list(datasets)
            return self

        def setSaveInfo(self, save_info: SaveInfo) -> "FillResponse.Builder":
            self._response._save_info = save_info
            return self

        def setClientState(self, client_state: Any) -> "FillResponse.Builder":
            self._response._client_state = client_state
            return self

        def setAuthenticationResult(self, result: Any) -> "FillResponse.Builder":
            self._response._authentication_result = result
            return self

        def build(self) -> FillResponse:
            return self._response


# ═══════════════════════════════════════════════════════════════
# SaveRequest
# ═══════════════════════════════════════════════════════════════

class SaveRequest(Stub):
    """SaveRequest — 保存请求"""

    def __init__(self, request_id: int = 0,
                 client_state: Optional[Any] = None,
                 fill_contexts: Optional[List[Any]] = None):
        super().__init__()
        self._request_id = request_id
        self._client_state = client_state
        self._fill_contexts = fill_contexts or []

    def getId(self) -> int:
        return self._request_id

    def getClientState(self) -> Optional[Any]:
        return self._client_state

    def getFillContexts(self) -> List[Any]:
        return list(self._fill_contexts)

    def toString(self) -> str:
        return (f"SaveRequest(id={self._request_id}, "
                f"contexts={len(self._fill_contexts)})")

    def hashCode(self) -> int:
        return self._request_id & 0x7FFFFFFF

    def equals(self, other) -> bool:
        if not isinstance(other, SaveRequest):
            return False
        return self._request_id == other._request_id


# ═══════════════════════════════════════════════════════════════
# AutofillService
# ═══════════════════════════════════════════════════════════════

class AutofillService(Stub):
    """AutofillService — 自动填充服务"""

    SERVICE_INTERFACE = "android.service.autofill.AutofillService"
    SERVICE_META_DATA = "android.autofill"

    def __init__(self):
        super().__init__()

    def onFillRequest(self, request: FillRequest,
                       cancellation_signal: Any,
                       callback: Any):
        """填充请求回调"""
        response = FillResponse()
        if callback and hasattr(callback, 'onSuccess'):
            callback.onSuccess(response)

    def onSaveRequest(self, request: SaveRequest, callback: Any):
        """保存请求回调"""
        if callback and hasattr(callback, 'onSuccess'):
            callback.onSuccess()

    def onConnected(self):
        """服务已连接"""
        pass

    def onDisconnected(self):
        """服务已断开"""
        pass

    def onUnbind(self, intent: Any) -> bool:
        return False

    def toString(self) -> str:
        return f"AutofillService@{hex(id(self))}"

    def hashCode(self) -> int:
        return id(self) & 0x7FFFFFFF

    def equals(self, other) -> bool:
        return self is other


# ═══════════════════════════════════════════════════════════════
# AutofillFieldClassificationService
# ═══════════════════════════════════════════════════════════════

class AutofillFieldClassificationService(Stub):
    """AutofillFieldClassificationService — 自动填充字段分类服务"""

    SERVICE_INTERFACE = (
        "android.service.autofill.AutofillFieldClassificationService"
    )

    def __init__(self):
        super().__init__()

    def onConnected(self):
        pass

    def onDisconnected(self):
        pass

    def onClassificationRequest(self, request: Any, callback: Any):
        if callback and hasattr(callback, 'onSuccess'):
            callback.onSuccess(None)

    def toString(self) -> str:
        return f"AutofillFieldClassificationService@{hex(id(self))}"

    def hashCode(self) -> int:
        return id(self) & 0x7FFFFFFF

    def equals(self, other) -> bool:
        return self is other


# ═══════════════════════════════════════════════════════════════
# __all__
# ═══════════════════════════════════════════════════════════════

__all__ = [
    "AutofillService",
    "FillRequest",
    "FillResponse",
    "SaveRequest",
    "SaveInfo",
    "Dataset",
    "AutofillFieldClassificationService",
]