from __future__ import annotations

import logging

from yuxi.channel.extensions.feishu.client import get_client, get_chat_info, get_chat_members, get_user_info

logger = logging.getLogger(__name__)

FEISHU_CHAT_TOOLS = [
    {
        "name": "feishu_chat_info",
        "description": "获取飞书群聊信息",
        "parameters": {"chat_id": "群聊 ID"},
    },
    {
        "name": "feishu_chat_members",
        "description": "获取飞书群聊成员列表",
        "parameters": {"chat_id": "群聊 ID"},
    },
    {
        "name": "feishu_chat_member_info",
        "description": "获取飞书用户详细信息",
        "parameters": {"user_id": "用户 open_id"},
    },
    {
        "name": "feishu_create_group",
        "description": "创建飞书群组",
        "parameters": {"name": "群名称", "user_ids": "初始成员 ID 列表（可选）", "description": "群描述（可选）"},
    },
    {
        "name": "feishu_update_group",
        "description": "更新群组信息（名称/描述）",
        "parameters": {"chat_id": "群聊 ID", "name": "新名称（可选）", "description": "新描述（可选）"},
    },
    {
        "name": "feishu_delete_group",
        "description": "解散群组",
        "parameters": {"chat_id": "群聊 ID"},
    },
    {
        "name": "feishu_add_group_members",
        "description": "添加群成员",
        "parameters": {"chat_id": "群聊 ID", "member_ids": "成员 open_id 列表"},
    },
    {
        "name": "feishu_remove_group_members",
        "description": "移除群成员",
        "parameters": {"chat_id": "群聊 ID", "member_ids": "成员 open_id 列表"},
    },
]


async def get_chat_tool_info(
    app_id: str,
    app_secret: str,
    domain: str,
    chat_id: str,
    http_timeout_ms: int = 30000,
) -> dict:
    try:
        client = get_client(app_id, app_secret, domain, http_timeout_ms)
        result = await get_chat_info(client, chat_id)
        if result:
            return {"success": True, **result}
        return {"success": False, "error": "Chat not found"}
    except Exception:
        logger.exception("Feishu get_chat_tool_info error")
        return {"success": False, "error": "Internal error"}


async def get_chat_tool_members(
    app_id: str,
    app_secret: str,
    domain: str,
    chat_id: str,
    http_timeout_ms: int = 30000,
) -> dict:
    try:
        client = get_client(app_id, app_secret, domain, http_timeout_ms)
        return await get_chat_members(client, chat_id)
    except Exception:
        logger.exception("Feishu get_chat_tool_members error")
        return {"success": False, "error": "Internal error", "members": []}


async def get_chat_tool_member_info(
    app_id: str,
    app_secret: str,
    domain: str,
    chat_id: str,
    member_id: str,
    http_timeout_ms: int = 30000,
) -> dict:
    try:
        client = get_client(app_id, app_secret, domain, http_timeout_ms)

        from yuxi.channel.extensions.feishu.client import get_chat_members as _get_members
        members_result = await _get_members(client, chat_id)
        if not members_result.get("success"):
            return {"success": False, "error": "Unable to fetch chat members"}

        members = members_result.get("members", [])
        target = next((m for m in members if m.get("open_id") == member_id), None)
        if target:
            return {"success": True, "member": target}
        return {"success": False, "error": "Member not found"}
    except Exception:
        logger.exception("Feishu get_chat_tool_member_info error")
        return {"success": False, "error": "Internal error"}


async def create_group_chat(
    app_id: str,
    app_secret: str,
    domain: str,
    name: str,
    user_ids: list[str] | None = None,
    description: str = "",
    http_timeout_ms: int = 30000,
) -> dict:
    try:
        client = get_client(app_id, app_secret, domain, http_timeout_ms)

        from yuxi.channel.extensions.feishu.client import create_chat as _create_chat
        return await _create_chat(client, name, description, user_ids, "group")
    except ImportError:
        return {"success": False, "error": "lark-oapi SDK not installed"}
    except Exception:
        logger.exception("Feishu create_group_chat error")
        return {"success": False, "error": "Internal error"}


async def update_group_chat(
    app_id: str,
    app_secret: str,
    domain: str,
    chat_id: str,
    name: str = "",
    description: str = "",
    http_timeout_ms: int = 30000,
) -> dict:
    try:
        client = get_client(app_id, app_secret, domain, http_timeout_ms)

        from yuxi.channel.extensions.feishu.client import update_chat as _update_chat
        return await _update_chat(client, chat_id, name, description)
    except ImportError:
        return {"success": False, "error": "lark-oapi SDK not installed"}
    except Exception:
        logger.exception("Feishu update_group_chat error")
        return {"success": False, "error": "Internal error"}


async def delete_group_chat(
    app_id: str,
    app_secret: str,
    domain: str,
    chat_id: str,
    http_timeout_ms: int = 30000,
) -> dict:
    try:
        client = get_client(app_id, app_secret, domain, http_timeout_ms)

        from yuxi.channel.extensions.feishu.client import delete_chat as _delete_chat
        return await _delete_chat(client, chat_id)
    except ImportError:
        return {"success": False, "error": "lark-oapi SDK not installed"}
    except Exception:
        logger.exception("Feishu delete_group_chat error")
        return {"success": False, "error": "Internal error"}


async def add_group_members(
    app_id: str,
    app_secret: str,
    domain: str,
    chat_id: str,
    member_ids: list[str],
    http_timeout_ms: int = 30000,
) -> dict:
    try:
        client = get_client(app_id, app_secret, domain, http_timeout_ms)

        from yuxi.channel.extensions.feishu.client import add_chat_members as _add
        return await _add(client, chat_id, member_ids)
    except ImportError:
        return {"success": False, "error": "lark-oapi SDK not installed"}
    except Exception:
        logger.exception("Feishu add_group_members error")
        return {"success": False, "error": "Internal error"}


async def remove_group_members(
    app_id: str,
    app_secret: str,
    domain: str,
    chat_id: str,
    member_ids: list[str],
    http_timeout_ms: int = 30000,
) -> dict:
    try:
        client = get_client(app_id, app_secret, domain, http_timeout_ms)

        from yuxi.channel.extensions.feishu.client import remove_chat_members as _remove
        return await _remove(client, chat_id, member_ids)
    except ImportError:
        return {"success": False, "error": "lark-oapi SDK not installed"}
    except Exception:
        logger.exception("Feishu remove_group_members error")
        return {"success": False, "error": "Internal error"}