from __future__ import annotations

from typing import Any

from ._validate import validate_params

try:
    import lark_oapi

    HAS_LARK_SDK = True
except ImportError:
    HAS_LARK_SDK = False
    lark_oapi = None  # type: ignore


@validate_params
async def get_chat_members(client: Any, chat_id: str) -> list[dict[str, Any]]:
    if not HAS_LARK_SDK or not client:
        return []

    members: list[dict[str, Any]] = []
    page_token = ""
    try:
        while True:
            request = (
                lark_oapi.api.im.v1.ListChatMembersRequest.builder()
                .chat_id(chat_id)
                .page_size(100)
                .page_token(page_token)
                .build()
            )
            resp = await client.im.v1.chat.member.list(request)
            if not resp.success():
                break

            data = resp.data if hasattr(resp, "data") else {}
            items = data.get("items", [])
            for item in items:
                members.append(
                    {
                        "open_id": item.get("open_id", ""),
                        "user_id": item.get("user_id", ""),
                        "name": item.get("name", ""),
                        "member_type": item.get("member_type", ""),
                    }
                )

            page_token = data.get("page_token", "")
            if not page_token or not items:
                break
    except Exception as e:
        raise RuntimeError(f"获取群成员失败: {e}") from e

    return members


@validate_params
async def search_chat_by_name(client: Any, name: str) -> list[dict[str, Any]]:
    if not HAS_LARK_SDK or not client:
        return []

    chats: list[dict[str, Any]] = []
    page_token = ""
    try:
        while True:
            request = (
                lark_oapi.api.im.v1.SearchChatRequest.builder()
                .search_key(name)
                .page_size(50)
                .page_token(page_token)
                .build()
            )
            resp = await client.im.v1.chat.search(request)
            if not resp.success():
                break

            data = resp.data if hasattr(resp, "data") else {}
            items = data.get("items", [])
            for item in items:
                chats.append(
                    {
                        "chat_id": item.get("chat_id", ""),
                        "name": item.get("name", ""),
                        "description": item.get("description", ""),
                        "chat_type": item.get("chat_type", ""),
                        "member_count": item.get("member_count", 0),
                    }
                )

            page_token = data.get("page_token", "")
            if not page_token or not items:
                break
    except Exception as e:
        raise RuntimeError(f"搜索群组失败: {e}") from e

    return chats


@validate_params
async def create_chat(
    client: Any,
    name: str,
    description: str = "",
    user_ids: list[str] | None = None,
    chat_type: str = "private",
) -> dict[str, Any]:
    if not HAS_LARK_SDK or not client:
        raise RuntimeError("SDK 不可用")

    try:
        builder = lark_oapi.api.im.v1.CreateChatRequestBody.builder().name(name)
        if description:
            builder.description(description)
        if chat_type:
            builder.chat_type(chat_type)
        if user_ids:
            builder.user_ids(user_ids)

        request_body = builder.build()
        request = lark_oapi.api.im.v1.CreateChatRequest.builder().request_body(request_body).build()
        resp = await client.im.v1.chat.create(request)
        if not resp.success():
            raise RuntimeError(f"创建群组失败: {resp.msg}")

        data = resp.data if hasattr(resp, "data") else {}
        return {
            "chat_id": data.get("chat_id", ""),
            "name": data.get("name", name),
            "description": data.get("description", description),
        }
    except Exception as e:
        raise RuntimeError(f"创建群组失败: {e}") from e


@validate_params
async def add_chat_members(
    client: Any,
    chat_id: str,
    user_ids: list[str],
) -> dict[str, Any]:
    if not HAS_LARK_SDK or not client:
        raise RuntimeError("SDK 不可用")

    try:
        request_body = lark_oapi.api.im.v1.CreateChatMembersRequestBody.builder().id_list(user_ids).build()
        request = (
            lark_oapi.api.im.v1.CreateChatMembersRequest.builder().chat_id(chat_id).request_body(request_body).build()
        )
        resp = await client.im.v1.chat_members.create(request)
        if not resp.success():
            raise RuntimeError(f"添加群成员失败: {resp.msg}")

        data = resp.data if hasattr(resp, "data") else {}
        invalid_ids = data.get("invalid_id_list", []) or []
        return {
            "chat_id": chat_id,
            "added_count": len(user_ids) - len(invalid_ids),
            "invalid_ids": invalid_ids,
        }
    except Exception as e:
        raise RuntimeError(f"添加群成员失败: {e}") from e


@validate_params
async def update_chat(
    client: Any,
    chat_id: str,
    name: str = "",
    description: str = "",
) -> dict[str, Any]:
    if not HAS_LARK_SDK or not client:
        raise RuntimeError("SDK 不可用")

    try:
        builder = lark_oapi.api.im.v1.UpdateChatRequestBody.builder()
        if name:
            builder.name(name)
        if description:
            builder.description(description)

        request_body = builder.build()
        request = lark_oapi.api.im.v1.UpdateChatRequest.builder().chat_id(chat_id).request_body(request_body).build()
        resp = await client.im.v1.chat.update(request)
        if not resp.success():
            raise RuntimeError(f"更新群组失败: {resp.msg}")

        return {
            "chat_id": chat_id,
            "updated": True,
        }
    except Exception as e:
        raise RuntimeError(f"更新群组失败: {e}") from e


@validate_params
async def create_chat_announcement(
    client: Any,
    chat_id: str,
    content: str,
) -> dict[str, Any]:
    if not HAS_LARK_SDK or not client:
        raise RuntimeError("SDK 不可用")

    try:
        request_body = lark_oapi.api.im.v1.CreateChatAnnouncementRequestBody.builder().content(content).build()
        request = (
            lark_oapi.api.im.v1.CreateChatAnnouncementRequest.builder()
            .chat_id(chat_id)
            .request_body(request_body)
            .build()
        )
        resp = await client.im.v1.chat.announcement.create(request)
        if not resp.success():
            raise RuntimeError(f"创建群公告失败: {resp.msg}")

        return {
            "chat_id": chat_id,
            "created": True,
        }
    except Exception as e:
        raise RuntimeError(f"创建群公告失败: {e}") from e