"""
Android app.assist 包 — AssistManager, AssistStructure, AssistContent
方法签名完全对齐 Android SDK
"""

from __future__ import annotations

import sys
from typing import Any, Dict, List, Optional, Tuple

from .._core import Stub, AndroidOnlyError
from ..java.lang import RuntimeException

IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {})

__all__ = [
    "AssistManager",
    "AssistStructure",
    "AssistStructureWindowNode",
    "AssistStructureViewNode",
    "AssistContent",
]


# ═══════════════════════════════════════════════════════════════
# AssistManager
# ═══════════════════════════════════════════════════════════════

class AssistManager(Stub):
    """AssistManager — 辅助管理器 (桌面存根)"""

    EXTRA_ASSIST_STRUCTURE = "android.app.extra.ASSIST_STRUCTURE"
    EXTRA_ASSIST_CONTENT = "android.app.extra.ASSIST_CONTENT"
    EXTRA_ASSIST_INPUT_HINT = "android.app.extra.ASSIST_INPUT_HINT"
    EXTRA_ASSIST_PACKAGE = "android.app.extra.ASSIST_PACKAGE"
    EXTRA_ASSIST_UID = "android.app.extra.ASSIST_UID"
    KEY_RECEIVER_EXTRA = "receiver_extra"
    KEY_DATA = "data"
    KEY_STRUCTURE = "structure"
    KEY_CONTENT = "content"
    KEY_INPUT_HINT = "input_hint"
    KEY_URI = "uri"
    KEY_ACTIVITY_ID = "activity_id"
    KEY_TIMESTAMP = "timestamp"
    KEY_ACTIVITY_NAME = "activity_name"
    ASSIST_STATE_UNKNOWN = 0
    ASSIST_STATE_DISALLOWED = 1
    ASSIST_STATE_SUPPORTED = 2
    ASSIST_STATE_ALLOWED = 3
    ASSIST_STRUCTURE_EXTRA_ARGS = "android.app.extra.ASSIST_STRUCTURE_ARGS"
    ASSIST_CONTENT_EXTRA_ARGS = "android.app.extra.ASSIST_CONTENT_ARGS"

    def __init__(self, context: Any = None):
        super().__init__()
        self._context = context
        self._assist_state = AssistManager.ASSIST_STATE_ALLOWED
        self._assist_content: Optional["AssistContent"] = None

    def showScreenshot(self, screenshot: Any) -> None:
        """显示截图"""
        raise AndroidOnlyError("showScreenshot 仅在 Android 设备上可用")

    def showContext(self, context_data: Any) -> None:
        """显示上下文"""
        pass

    def getAssistContent(self) -> Optional["AssistContent"]:
        """获取辅助内容"""
        return self._assist_content

    def getAssistState(self) -> int:
        """获取辅助状态"""
        return self._assist_state

    def setAssistContent(self, content: "AssistContent") -> None:
        """设置辅助内容"""
        self._assist_content = content

    def getAssistContentForIntent(self, intent: Any) -> Optional["AssistContent"]:
        """获取 Intent 的辅助内容"""
        return None

    def dispatchAssistStructure(self, structure: "AssistStructure") -> None:
        """分发辅助结构"""
        pass

    def isAssistAllowed(self) -> bool:
        """检查是否允许辅助"""
        return self._assist_state == AssistManager.ASSIST_STATE_ALLOWED

    def suggestAssistInput(self, input_data: Any) -> None:
        """建议辅助输入"""
        pass


# ═══════════════════════════════════════════════════════════════
# AssistStructure
# ═══════════════════════════════════════════════════════════════

class AssistStructure(Stub):
    """AssistStructure — 辅助结构 (桌面存根)"""

    def __init__(self):
        super().__init__()
        self._activity_name = ""
        self._package_name = ""
        self._windows: List["AssistStructureWindowNode"] = []
        self._description = ""
        self._activity_id = 0
        self._is_home_activity = False
        self._global_state: Optional[Any] = None
        self._data_valid = True

    def getActivityName(self) -> str:
        """获取活动名称"""
        return self._activity_name

    def getPackageName(self) -> str:
        """获取包名"""
        return self._package_name

    def getWindowNodeCount(self) -> int:
        """获取窗口节点数量"""
        return len(self._windows)

    def getWindowNodeAt(self, index: int) -> Optional["AssistStructureWindowNode"]:
        """获取指定索引的窗口节点"""
        if 0 <= index < len(self._windows):
            return self._windows[index]
        return None

    def getDescription(self) -> str:
        """获取描述"""
        return self._description

    def getActivityId(self) -> int:
        """获取活动 ID"""
        return self._activity_id

    def getIsHomeActivity(self) -> bool:
        """检查是否为桌面活动"""
        return self._is_home_activity

    def getGlobalState(self) -> Optional[Any]:
        """获取全局状态"""
        return self._global_state

    def toString(self) -> str:
        return f"AssistStructure(package={self._package_name}, activity={self._activity_name})"

    @staticmethod
    def longHashCode(value: int) -> int:
        """长哈希码"""
        return value & 0x7FFFFFFF

    def ensureData(self) -> None:
        """确保数据有效"""
        self._data_valid = True

    def populateWindowNodes(self) -> None:
        """填充窗口节点"""
        pass

    def updateClearCallback(self, callback: Any) -> None:
        """更新清除回调"""
        pass


# ═══════════════════════════════════════════════════════════════
# AssistStructure.WindowNode
# ═══════════════════════════════════════════════════════════════

class AssistStructureWindowNode(Stub):
    """AssistStructure.WindowNode — 辅助结构窗口节点"""

    def __init__(self):
        super().__init__()
        self._title = ""
        self._left = 0
        self._top = 0
        self._width = 0
        self._height = 0
        self._display_frame = (0, 0, 0, 0)
        self._root_view_node: Optional["AssistStructureViewNode"] = None

    def getTitle(self) -> str:
        """获取标题"""
        return self._title

    def getLeft(self) -> int:
        """获取左坐标"""
        return self._left

    def getTop(self) -> int:
        """获取顶坐标"""
        return self._top

    def getWidth(self) -> int:
        """获取宽度"""
        return self._width

    def getHeight(self) -> int:
        """获取高度"""
        return self._height

    def getDisplayFrame(self) -> Tuple[int, int, int, int]:
        """获取显示框架"""
        return self._display_frame

    def getRootViewNode(self) -> Optional["AssistStructureViewNode"]:
        """获取根视图节点"""
        return self._root_view_node

    def toString(self) -> str:
        return f"WindowNode(title={self._title}, rect=({self._left},{self._top},{self._width}x{self._height}))"


# ═══════════════════════════════════════════════════════════════
# AssistStructure.ViewNode
# ═══════════════════════════════════════════════════════════════

class AssistStructureViewNode(Stub):
    """AssistStructure.ViewNode — 辅助结构视图节点"""

    def __init__(self):
        super().__init__()
        self._class_name = ""
        self._text = ""
        self._text_size = 0.0
        self._text_color = 0
        self._text_background_color = 0
        self._content_description: Optional[str] = None
        self._input_type = 0
        self._enabled = True
        self._focusable = False
        self._focused = False
        self._accessibility_focused = False
        self._clickable = False
        self._long_clickable = False
        self._selected = False
        self._activated = False
        self._checkable = False
        self._checked = False
        self._context_clickable = False
        self._drawing_order = 0
        self._id = 0
        self._label_for = 0
        self._left = 0
        self._top = 0
        self._scroll_x = 0
        self._scroll_y = 0
        self._width = 0
        self._height = 0
        self._alpha = 1.0
        self._autofill_hints: Optional[List[str]] = None
        self._opaque = True
        self._visibility = 0
        self._assist_blocked = False
        self._important_for_accessibility = 1
        self._children: List["AssistStructureViewNode"] = []

    def getClassName(self) -> str:
        return self._class_name

    def getText(self) -> str:
        return self._text

    def getTextSize(self) -> float:
        return self._text_size

    def getTextColor(self) -> int:
        return self._text_color

    def getTextBackgroundColor(self) -> int:
        return self._text_background_color

    def getContentDescription(self) -> Optional[str]:
        return self._content_description

    def getInputType(self) -> int:
        return self._input_type

    def isEnabled(self) -> bool:
        return self._enabled

    def isFocusable(self) -> bool:
        return self._focusable

    def isFocused(self) -> bool:
        return self._focused

    def isAccessibilityFocused(self) -> bool:
        return self._accessibility_focused

    def isClickable(self) -> bool:
        return self._clickable

    def isLongClickable(self) -> bool:
        return self._long_clickable

    def isSelected(self) -> bool:
        return self._selected

    def isActivated(self) -> bool:
        return self._activated

    def isCheckable(self) -> bool:
        return self._checkable

    def isChecked(self) -> bool:
        return self._checked

    def isContextClickable(self) -> bool:
        return self._context_clickable

    def getDrawingOrder(self) -> int:
        return self._drawing_order

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

    def getLabelFor(self) -> int:
        return self._label_for

    def getLeft(self) -> int:
        return self._left

    def getTop(self) -> int:
        return self._top

    def getScrollX(self) -> int:
        return self._scroll_x

    def getScrollY(self) -> int:
        return self._scroll_y

    def getWidth(self) -> int:
        return self._width

    def getHeight(self) -> int:
        return self._height

    def getAlpha(self) -> float:
        return self._alpha

    def getAutofillHints(self) -> Optional[List[str]]:
        return self._autofill_hints

    def isOpaque(self) -> bool:
        return self._opaque

    def getVisibility(self) -> int:
        return self._visibility

    def getAssistBlocked(self) -> bool:
        return self._assist_blocked

    def getImportantForAccessibility(self) -> int:
        return self._important_for_accessibility

    def getChildCount(self) -> int:
        return len(self._children)

    def getChildAt(self, index: int) -> Optional["AssistStructureViewNode"]:
        if 0 <= index < len(self._children):
            return self._children[index]
        return None

    def toString(self) -> str:
        return f"ViewNode(class={self._class_name}, text={self._text})"


# ═══════════════════════════════════════════════════════════════
# AssistContent
# ═══════════════════════════════════════════════════════════════

class AssistContent(Stub):
    """AssistContent — 辅助内容 (桌面存根)"""

    def __init__(self):
        super().__init__()
        self._intent: Optional[Any] = None
        self._clip_data: Optional[Any] = None
        self._structured_data: Optional[str] = None
        self._provider_uri: Optional[str] = None
        self._extras: Optional[Any] = None
        self._is_app_provided_intent = False
        self._is_app_provided_web_uri = False
        self._web_uri: Optional[str] = None
        self._uri: Optional[str] = None

    def getIntent(self) -> Optional[Any]:
        """获取 Intent"""
        return self._intent

    def setIntent(self, intent: Any) -> None:
        """设置 Intent"""
        self._intent = intent
        self._is_app_provided_intent = True

    def setClipData(self, clip_data: Any) -> None:
        """设置剪贴数据"""
        self._clip_data = clip_data

    def getClipData(self) -> Optional[Any]:
        """获取剪贴数据"""
        return self._clip_data

    def getStructuredData(self) -> Optional[str]:
        """获取结构化数据"""
        return self._structured_data

    def setStructuredData(self, data: str) -> None:
        """设置结构化数据"""
        self._structured_data = data

    def getProviderUri(self) -> Optional[str]:
        """获取提供商 URI"""
        return self._provider_uri

    def setProviderUri(self, uri: str) -> None:
        """设置提供商 URI"""
        self._provider_uri = uri

    def getExtras(self) -> Optional[Any]:
        """获取附加信息"""
        return self._extras

    def setExtras(self, extras: Any) -> None:
        """设置附加信息"""
        self._extras = extras

    def isAppProvidedIntent(self) -> bool:
        """检查是否为应用提供的 Intent"""
        return self._is_app_provided_intent

    def isAppProvidedWebUri(self) -> bool:
        """检查是否为应用提供的 Web URI"""
        return self._is_app_provided_web_uri

    def getWebUri(self) -> Optional[str]:
        """获取 Web URI"""
        return self._web_uri

    def setWebUri(self, uri: str) -> None:
        """设置 Web URI"""
        self._web_uri = uri
        self._is_app_provided_web_uri = True

    def getUri(self) -> Optional[str]:
        """获取 URI"""
        return self._uri

    def getLaunchUri(self) -> Optional[str]:
        """获取启动 URI"""
        return self._uri

    def clone(self) -> "AssistContent":
        """克隆"""
        new = AssistContent()
        new._intent = self._intent
        new._structured_data = self._structured_data
        new._provider_uri = self._provider_uri
        new._uri = self._uri
        new._web_uri = self._web_uri
        return new

    def toString(self) -> str:
        return f"AssistContent(intent={self._intent})"