# -*- coding: utf-8 -*-
"""Remote server database/RPC queries and role RPC helpers."""

from .shared import *
from .erlang import _ensure_epmd_daemon, get_erl_cmd, get_local_ip

def query_remote_servers(db_host: str, db_port: int, db_user: str, db_pass: str, 
                         db_name: str) -> List[Dict[str, str]]:
    """从登录服数据库查询远程服务器列表
    
    Args:
        db_host: 数据库地址
        db_port: 数据库端口
        db_user: 数据库用户名
        db_pass: 数据库密码
        db_name: 数据库名（登录服数据库，如 ai002_login_s900）
    
    Returns:
        服务器列表，每项包含 server_id, server_node, center_node 等信息
    """
    try:
        import pymysql
    except ImportError:
        # 尝试使用 mysql-connector
        try:
            import mysql.connector as pymysql
        except ImportError:
            raise ImportError("需要安装 pymysql 或 mysql-connector-python: pip install pymysql")
    
    servers = []
    
    try:
        # 连接数据库
        conn = pymysql.connect(
            host=db_host,
            port=db_port,
            user=db_user,
            password=db_pass,
            database=db_name,
            charset='utf8mb4'
        )
        
        cursor = conn.cursor()
        
        # 查询 server_info 表
        # 注意: running 字段是运行时字段(sync=false)，不存储在数据库中
        sql = """
            SELECT server_id, server_node, center_node, game_db 
            FROM server_info 
            WHERE server_node IS NOT NULL AND server_node != ''
            ORDER BY server_id
        """
        cursor.execute(sql)
        
        for row in cursor.fetchall():
            server_id, server_node, center_node, game_db = row
            servers.append({
                'server_id': str(server_id),
                'server_node': str(server_node) if server_node else '',
                'center_node': str(center_node) if center_node else '',
                'game_db': str(game_db) if game_db else '',
                'running': False  # 运行状态需要实时检测，这里默认为 False
            })
        
        cursor.close()
        conn.close()
        
    except Exception as e:
        raise Exception(f"数据库查询失败: {str(e)}")
    
    return servers


def _erl_quoted_atom(node: str) -> str:
    """将节点名转为 Erlang 源码中的单引号原子字面量。"""
    n = (node or "").strip()
    if not n:
        raise ValueError("登录服节点为空")
    return "'" + n.replace("\\", "\\\\").replace("'", "\\'") + "'"


# 由 file:script/1 加载。输出 SM_COUNT 行 + 每行「服务器ID\t名称base64\t节点明文」。
# 注意：file:script 生成的匿名 fun 属于 erl_eval，若本地与远程 OTP 版本不一致会 badfun。
# 需确保本地 erl 路径所指版本与登录服 OTP 版本相同。
_FETCH_REMOTE_RPC_SCRIPT = """begin
    LN = __LOGIN_ATOM__,
    R = rpc:call(LN, erlang, apply, [
        fun() ->
            ms_cache:tab2list_foldl(server_temp_info,
                fun(OneServer, ResultAcc) ->
                    ServerId = element(2, server_temp_info_c:get_server_id(OneServer)),
                    ServerName = unicode:characters_to_binary([
                        element(2, server_temp_info_c:get_server_name(OneServer))
                    ]),
                    case server_info_lib:get_server_node(ServerId) of
                        {_, Node} ->
                            [{ServerId, ServerName, Node} | ResultAcc];
                        _ ->
                            ResultAcc
                    end
                end, [])
        end, []]),
    case R of
        {badrpc, Err} ->
            io:format(standard_io, "RPC_ERROR: ~p~n", [Err]),
            erlang:halt(2, [{flush, true}]);
        _ when is_list(R) ->
            RowLine = fun({Id, NameBin, Node}) ->
                Nb = case NameBin of B when is_binary(B) -> B; _ -> <<>> end,
                NameB64 = binary_to_list(base64:encode(Nb)),
                NodeStr = case Node of
                    N when is_atom(N) -> unicode:characters_to_list(atom_to_binary(N, utf8));
                    N when is_list(N) -> N;
                    N when is_binary(N) -> unicode:characters_to_list(N);
                    _ -> lists:flatten(io_lib:format("~p", [Node]))
                end,
                Sid = lists:flatten(io_lib:format("~w", [Id])),
                lists:flatten([Sid, $\\t, NameB64, $\\t, NodeStr])
            end,
            io:format(standard_io, "SM_COUNT\\t~w~n", [length(R)]),
            lists:foreach(
                fun(Row) ->
                    io:format(standard_io, "~s~n", [RowLine(Row)])
                end, R),
            erlang:halt(0, [{flush, true}]);
        Other ->
            io:format(standard_io, "RPC_ERROR: ~p~n", [Other]),
            erlang:halt(3, [{flush, true}])
    end
end.
"""


def query_remote_servers_from_login_rpc(
    login_node: str,
    cookie: str,
    erl_path: Optional[str] = None,
    timeout: int = 120,
) -> List[Dict[str, Any]]:
    """通过向登录服节点 ``rpc:call`` 获取游戏服列表。

    使用 ``erl`` + ``file:script/1`` 执行临时脚本，避免 Windows 超长 ``-eval``。
    注意：脚本中的匿名 fun 属于 erl_eval，需要本地 erl 与登录服 OTP 版本一致，
    否则远程执行会 badfun。

    返回每项含 server_id、server_name（UTF-8 文本）、server_node、running（默认 False）。

    Raises:
        ValueError: 参数无效
        Exception: erl 执行失败、RPC 错误或输出无法解析
    """
    ln = _erl_quoted_atom(login_node)
    ping_node = f"sm_ls_{int(time.time() * 1000) % 100000}"
    cookie_arg = (cookie or "").strip() or "ddxq2-node"
    if any(c in cookie_arg for c in " \t\r\n'\""):
        raise ValueError("Cookie 不能包含空格或引号（请使用项目设置中的纯文本 cookie）")

    erl = get_erl_cmd(erl_path)
    _ensure_epmd_daemon(erl_path)

    # 与 check_nodes_status 一致：本机节点优先用 get_local_ip()，再试 127.0.0.1
    host_parts: List[str] = []
    lip = get_local_ip()
    if lip:
        host_parts.append(lip)
    if "127.0.0.1" not in host_parts:
        host_parts.append("127.0.0.1")
    if not host_parts:
        host_parts = ["127.0.0.1"]

    def _looks_like_vm_nodistribution(stderr: str, stdout: str) -> bool:
        c = (stderr or "") + (stdout or "")
        return any(
            x in c
            for x in (
                "nodistribution",
                "application_start_failure",
                "failed_to_start_child,net_kernel",
                "Kernel pid terminated",
            )
        )

    script_body = _FETCH_REMOTE_RPC_SCRIPT.replace("__LOGIN_ATOM__", ln)

    result: Optional[Any] = None
    for idx, host_part in enumerate(host_parts):
        tmp_path: Optional[str] = None
        try:
            with tempfile.NamedTemporaryFile(
                mode="w",
                suffix=".erl",
                delete=False,
                encoding="utf-8",
                newline="\n",
            ) as tf:
                tf.write(script_body)
                tmp_path = tf.name

            path_for_erl = str(Path(tmp_path).resolve()).replace("\\", "/")
            if '"' in path_for_erl:
                raise ValueError("临时脚本路径含引号，无法传给 Erlang")
            # 脚本内已 halt；若脚本本身无法解析，file:script 返回 {error,_}
            eval_launch = (
                f'case file:script("{path_for_erl}") of '
                "{{error, E}} -> io:format(\"SCRIPT_ERROR: ~p~n\", [E]), halt(1); "
                "_ -> halt(0) end."
            )

            result = subprocess.run(
                [
                    erl,
                    "-noshell",
                    "-name", f"{ping_node}@{host_part}",
                    "-setcookie", cookie_arg,
                    "-eval", eval_launch,
                ],
                capture_output=True,
                text=True,
                encoding="utf-8",
                errors="replace",
                timeout=timeout,
                creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0) if IS_WINDOWS else 0,
            )
        except subprocess.TimeoutExpired as e:
            raise Exception(f"从登录服加载超时（{timeout}s）: {e}") from e
        except FileNotFoundError:
            raise Exception(
                f"找不到 erl 可执行文件: {erl}。"
                "请确认已安装 Erlang/OTP，或在项目设置中填写正确的 Erlang 安装路径。"
            )
        except Exception as e:
            raise Exception(f"执行 erl 失败: {e}") from e
        finally:
            if tmp_path:
                try:
                    os.unlink(tmp_path)
                except OSError:
                    pass

        if result is None:
            raise Exception("内部错误：未获得 erl 执行结果")

        if (
            result.returncode != 0
            and _looks_like_vm_nodistribution(result.stderr, result.stdout)
            and idx < len(host_parts) - 1
        ):
            continue
        break

    if result is None:
        raise Exception("内部错误：未获得 erl 执行结果")

    out = (result.stdout or "").strip()
    err = (result.stderr or "").strip()
    # Windows 下 -noshell 时 io:format 有时落在 stderr；与 stdout 合并后再解析
    combined_text = ((result.stdout or "") + "\n" + (result.stderr or "")).strip()

    rpc_err_lines = [line for line in combined_text.splitlines() if "RPC_ERROR:" in line]
    if rpc_err_lines:
        raise Exception(f"登录服 RPC 失败: {rpc_err_lines[0]}")

    if result.returncode != 0:
        raise Exception(f"erl 退出码 {result.returncode}: {(err or out)[:2000]}")

    servers: List[Dict[str, Any]] = []
    for line in combined_text.splitlines():
        line = line.strip()
        if not line:
            continue
        if line.startswith("RPC_ERROR") or line.startswith("SCRIPT_ERROR"):
            continue
        if line.startswith("SM_COUNT\t"):
            continue
        # 跳过 Eshell/版本等无关行
        if "Eshell" in line or "Erlang/OTP" in line:
            continue
        parts = line.split("\t", 2)
        if len(parts) < 3:
            continue
        sid_s, name_b64, node_s = parts[0], parts[1], parts[2]
        try:
            raw = base64.b64decode(name_b64.encode("ascii"))
            name_dec = raw.decode("utf-8")
        except Exception:
            try:
                name_dec = base64.b64decode(name_b64.encode("ascii")).decode("utf-8", errors="replace")
            except Exception:
                name_dec = ""
        servers.append(
            {
                "server_id": str(sid_s).strip(),
                "server_name": name_dec,
                "server_node": str(node_s).strip(),
                "running": False,
            }
        )

    sm_count: Optional[int] = None
    for line in combined_text.splitlines():
        if line.strip().startswith("SM_COUNT\t"):
            try:
                sm_count = int(line.strip().split("\t", 1)[1])
            except (ValueError, IndexError):
                pass
            break
    if sm_count is not None and sm_count > 0 and len(servers) == 0:
        raise Exception(
            f"登录服报告 SM_COUNT={sm_count} 条，但未解析出数据行（可能编码或输出分流异常）。"
            f" 原始 stdout 前 500 字: {(result.stdout or '')[:500]!r}"
        )

    return servers


def get_login_db_name(prefix: str, login_server_id: int) -> str:
    """生成登录服数据库名
    
    Args:
        prefix: 项目前缀
        login_server_id: 登录服ID
    
    Returns:
        数据库名，如 ai002_login_s900
    """
    return f"{prefix}_login_s{login_server_id}"


def _format_target_node(server_name: str, target_ip: Optional[str]) -> str:
    if '@' in server_name:
        return server_name
    ip = target_ip if target_ip else get_local_ip()
    return f"{server_name}@{ip}"


def _argv_to_shell_line(args: List[str]) -> str:
    """将实际传给 subprocess 的参数列表格式化为可复制的命令行字符串。"""
    if IS_WINDOWS:
        return subprocess.list2cmdline(args)
    return shlex.join(args)


def rpc_clear_server_on_center_and_login(
    center_node: str,
    login_node: str,
    server_id: Union[int, str],
    cookie: str,
    erl_path: Optional[str] = None,
    timeout: int = 45,
) -> Tuple[int, str, str, str]:
    """Notify center/login nodes to clear a game server.

    Returns:
        (returncode, stdout, stderr, full_command_line)
    """
    clean_center_node = str(center_node or "").strip().strip("'\"")
    clean_login_node = str(login_node or "").strip().strip("'\"")
    if not clean_center_node:
        raise ValueError("center_node is empty")
    if not clean_login_node:
        raise ValueError("login_node is empty")

    try:
        sid = int(str(server_id).strip())
    except (TypeError, ValueError) as exc:
        raise ValueError(f"invalid server_id: {server_id!r}") from exc

    cookie_arg = (cookie or "").strip() or "ddxq2-node"
    if any(c in cookie_arg for c in " \t\r\n'\""):
        raise ValueError("cookie cannot contain whitespace or quotes")

    erl = get_erl_cmd(erl_path)
    local_ip = get_local_ip()
    ping_node = f"clear_{os.getpid()}_{time.time_ns() % 100000000}"
    center_atom = _erl_quoted_atom(clean_center_node)
    login_atom = _erl_quoted_atom(clean_login_node)
    eval_code = (
        f"CenterNode = {center_atom}, "
        f"LoginNode = {login_atom}, "
        f"ServerId = {sid}, "
        "CenterResult = rpc:call(CenterNode, center_node_gs_lib, clear_server, [ServerId]), "
        "LoginResult = rpc:call(LoginNode, login_server_app, clear_server, [ServerId]), "
        "io:format(\"CENTER: ~p~nLOGIN: ~p~n\", [CenterResult, LoginResult]), "
        "case {CenterResult, LoginResult} of "
        "{{badrpc, _}, _} -> erlang:halt(2, [{flush, true}]); "
        "{_, {badrpc, _}} -> erlang:halt(3, [{flush, true}]); "
        "_ -> erlang:halt(0, [{flush, true}]) "
        "end."
    )
    args = [
        erl,
        "-noshell",
        "-name", f"{ping_node}@{local_ip}",
        "-setcookie", cookie_arg,
        "-eval", eval_code,
    ]
    cmd_line = _argv_to_shell_line(args)

    try:
        _ensure_epmd_daemon(erl_path)
        result = subprocess.run(
            args,
            capture_output=True,
            text=True,
            encoding="utf-8",
            errors="replace",
            timeout=timeout,
            creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0) if IS_WINDOWS else 0,
        )
        return result.returncode, (result.stdout or ""), (result.stderr or ""), cmd_line
    except subprocess.TimeoutExpired:
        return -1, "", f"RPC timeout after {timeout}s", cmd_line
    except Exception as e:
        return -1, "", str(e), cmd_line


def rpc_role_gs_trace_network(
    server_name: str,
    cookie: str,
    role_id: int,
    enable: bool,
    target_ip: Optional[str] = None,
    erl_path: Optional[str] = None,
) -> Tuple[int, str, str, str]:
    """远程调用 ``role_gs:trace_network/1`` 或 ``trace_network_close/1``。

    Returns:
        (returncode, stdout, stderr, full_command_line)
    """
    erl = get_erl_cmd(erl_path)
    ip = get_local_ip()
    ping_node = f"sm_rpc_{int(time.time() * 1000) % 100000}"
    target_node = _format_target_node(server_name, target_ip)
    func = "trace_network" if enable else "trace_network_close"
    eval_code = (
        f"R = rpc:call('{target_node}', role_gs, {func}, [{int(role_id)}]), "
        f"io:format(\"~p~n\", [R]), halt(0)."
    )
    args = [
        erl,
        "-noshell",
        "-name", f"{ping_node}@{ip}",
        "-setcookie", cookie,
        "-eval", eval_code,
    ]
    cmd_line = _argv_to_shell_line(args)
    try:
        r = subprocess.run(
            args,
            capture_output=True,
            text=True,
            timeout=45,
            creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0) if IS_WINDOWS else 0,
        )
        return r.returncode, (r.stdout or ""), (r.stderr or ""), cmd_line
    except subprocess.TimeoutExpired:
        return -1, "", "RPC 超时", cmd_line
    except Exception as e:
        return -1, "", str(e), cmd_line