# -*- coding: utf-8 -*-
"""
服务器创建模块

包含服务器创建相关的核心逻辑
"""

import re
from pathlib import Path
from typing import Dict, List, Optional, Tuple, Set

from services.commands import (
    get_local_ip,
    get_server_manager_config_dir,
    read_config_file,
    read_merged_config,
    write_config_file,
    generate_start_config,
)


# 服务器类型映射
SERVER_TYPE_MAP = {
    'game': 'game_server',
    'login': 'login_server',
    'client': 'client_server',
    'center': 'center_server',
    'cross': 'cross_server'
}

# 服务器类型到显示名称映射
SERVER_TYPE_NAMES = {
    'game': '游戏服',
    'login': '登录服',
    'client': '客户端测试服',
    'center': '中心服',
    'cross': '跨服'
}

# 基础必须配置项（所有服务器类型都需要）
BASE_REQUIRED_KEYS = {
    'prefix', 'server_id', 'server_type', 'ip', 'db_host',
    'db_user', 'db_pass', 'db_port', 'log_dir', 'db_game_name', 'auto_reload'
}

# 各服务器类型额外必须的配置项（不可删除）
SERVER_TYPE_REQUIRED_KEYS = {
    'game': {
        'server_name', 'game_host', 'tcp_port', 'http_port',
        'open_time', 'login_node', 'center_node', 'db_log_name'
    },
    'login': {
        'tcp_port'
    },
    'center': {
        'open_time', 'login_node', 'db_log_name'
    },
    'cross': {
        'open_time', 'center_node', 'db_log_name'
    },
    'client': {
        'tcp_port', 'game_host', 'login_host', 'login_http_port', 'login_node'
    },
}

# 各服务器类型可编辑的配置项（key: 中文说明）
# 基础配置项（所有类型都有）
BASE_CONFIG_KEYS = {
    'prefix': '项目前缀',
    'server_id': '服务器ID',
    'server_type': '服务器类型',
    'ip': '本机IP',
    'db_host': '数据库地址',
    'db_port': '数据库端口',
    'db_user': '数据库用户',
    'db_pass': '数据库密码',
    'db_save_time': '缓存同步间隔(ms)',
    'db_save_count': '缓存同步数量上限',
    'log_save_time': '日志同步间隔(ms)',
    'log_save_count': '日志同步数量上限',
    'log_dir': '日志目录',
    'logger_level': '日志等级',
    'is_develop': '开发模式',
    'is_inner': '是否内网',
    'auto_reload': '自动热更',
    'gm_auth': '开启GM',
}

# 各服务器类型特有的配置项
SERVER_TYPE_SPECIFIC_KEYS = {
    'game': {
        'server_name': '服务器名称',
        'game_host': '游戏服地址',
        'tcp_port': 'TCP端口',
        'http_port': 'HTTP端口',
        'login_node': '登录节点',
        'center_node': '中心节点',
        'open_time': '开服时间',
        'merge_server_ids': '合服ID列表',
        'merge_server_time': '合服时间',
        'last_merge_server_ids': '上次合服ID',
        'risk_control_server_ip': '风控服务器IP',
        'risk_control_server_post': '风控服务器端口',
    },
    'login': {
        'tcp_port': 'TCP端口',
        'http_port': 'HTTP端口',
    },
    'center': {
        'login_node': '登录节点',
        'open_time': '开服时间',
    },
    'cross': {
        'center_node': '中心节点',
        'open_time': '开服时间',
    },
    'client': {
        'tcp_port': 'TCP端口',
        'game_host': '游戏服地址',
        'game_tcp_port': '游戏服TCP端口',
        'login_host': '登录服地址',
        'login_http_port': '登录服HTTP端口',
        'login_node': '登录节点',
    },
}


def _read_default_kv(server_root: str) -> Dict[str, str]:
    """读取合并配置（user.config > project.config > default.config）
    
    Args:
        server_root: 服务器根目录
    
    Returns:
        配置字典
    """
    if not server_root:
        return {}
    
    return read_merged_config(server_root)


def get_required_keys_from_kv(server_root: str, server_type: str) -> Optional[Set[str]]:
    """从 default.config 读取必须配置项定义
    
    Args:
        server_root: 服务器根目录
        server_type: 服务器类型 (game/login/client/center/cross)
    
    Returns:
        必须配置项集合，如果配置不存在则返回 None
    """
    kv_config = _read_default_kv(server_root)
    if not kv_config:
        return None
    
    # 读取基础必须配置项
    base_keys_str = kv_config.get('required_keys_base', '')
    if not base_keys_str:
        return None
    
    required = set(k.strip() for k in base_keys_str.split(',') if k.strip())
    
    # 读取类型特有的必须配置项
    type_keys_str = kv_config.get(f'required_keys_{server_type}', '')
    if type_keys_str:
        required.update(k.strip() for k in type_keys_str.split(',') if k.strip())
    
    return required


def get_config_keys_from_kv(server_root: str, server_type: str) -> Optional[Dict[str, str]]:
    """从 default.config 读取可编辑配置项定义
    
    Args:
        server_root: 服务器根目录
        server_type: 服务器类型 (game/login/client/center/cross)
    
    Returns:
        配置项字典 {key: 中文说明}，如果配置不存在则返回 None
    """
    kv_config = _read_default_kv(server_root)
    if not kv_config:
        return None
    
    result = {}
    has_config = False
    
    # 读取基础配置项 (config_keys_base_*)
    for key, value in kv_config.items():
        if key.startswith('config_keys_base_'):
            config_key = key[len('config_keys_base_'):]
            result[config_key] = value
            has_config = True
    
    # 读取类型特有的配置项 (config_keys_<type>_*)
    prefix = f'config_keys_{server_type}_'
    for key, value in kv_config.items():
        if key.startswith(prefix):
            config_key = key[len(prefix):]
            result[config_key] = value
            has_config = True
    
    return result if has_config else None


def get_editable_config_from_default_kv(server_root: str) -> Dict[str, str]:
    """从 default.config 读取编辑对话框可选配置项定义
    
    Args:
        server_root: 服务器根目录
    
    Returns:
        配置项字典 {key: 中文说明}
    """
    kv_config = _read_default_kv(server_root)
    if not kv_config:
        return {}
    
    # 查找 editable_config_ 前缀的配置项
    editable = {}
    for key, value in kv_config.items():
        if key.startswith('editable_config_'):
            config_key = key[len('editable_config_'):]  # 去掉前缀
            editable[config_key] = value
    
    return editable


def get_allowed_config_keys(server_type: str, server_root: str = '') -> Dict[str, str]:
    """获取指定服务器类型允许编辑的配置项
    
    优先从 default.config 读取 config_keys_* 定义，如果没有则使用代码中的默认定义
    
    Args:
        server_type: 服务器类型 (game/login/client/center/cross)
        server_root: 服务器根目录（用于读取 default.config）
    
    Returns:
        配置项字典 {key: 中文说明}
    """
    # 优先从 default.config 读取
    if server_root:
        config_from_kv = get_config_keys_from_kv(server_root, server_type)
        if config_from_kv:
            return config_from_kv
    
    # 回退到代码中的默认定义
    allowed = dict(BASE_CONFIG_KEYS)
    specific = SERVER_TYPE_SPECIFIC_KEYS.get(server_type, {})
    allowed.update(specific)
    return allowed


def get_all_valid_keys(server_root: str = '') -> Set[str]:
    """获取所有有效的配置键
    
    Args:
        server_root: 服务器根目录（用于读取 default.config）
    
    Returns:
        所有有效配置键的集合
    """
    # 优先从 default.config 读取
    if server_root:
        kv_config = _read_default_kv(server_root)
        if kv_config:
            all_keys = set()
            for key in kv_config.keys():
                if key.startswith('config_keys_base_'):
                    all_keys.add(key[len('config_keys_base_'):])
                elif key.startswith('config_keys_') and '_' in key[len('config_keys_'):]:
                    # config_keys_<type>_<key>
                    parts = key[len('config_keys_'):].split('_', 1)
                    if len(parts) == 2:
                        all_keys.add(parts[1])
            if all_keys:
                return all_keys
    
    # 回退到代码中的默认定义
    all_keys = set(BASE_CONFIG_KEYS.keys())
    for specific in SERVER_TYPE_SPECIFIC_KEYS.values():
        all_keys.update(specific.keys())
    return all_keys


def get_required_keys(server_type: str, server_root: str = '') -> Set[str]:
    """获取指定服务器类型必须的配置项（不可删除）
    
    优先从 default.config 读取 required_keys_* 定义，如果没有则使用代码中的默认定义
    
    Args:
        server_type: 服务器类型 (game/login/client/center/cross)
        server_root: 服务器根目录（用于读取 default.config）
    
    Returns:
        必须的配置项集合
    """
    # 优先从 default.config 读取
    if server_root:
        required_from_kv = get_required_keys_from_kv(server_root, server_type)
        if required_from_kv:
            return required_from_kv
    
    # 回退到代码中的默认定义
    required = set(BASE_REQUIRED_KEYS)
    type_required = SERVER_TYPE_REQUIRED_KEYS.get(server_type, set())
    required.update(type_required)
    return required


def get_server_type_name(server_type: str) -> str:
    """获取服务器类型的中文名称"""
    return SERVER_TYPE_NAMES.get(server_type, server_type)


# 模板文件到服务器类型的映射
TEMPLATE_FILE_MAP = {
    'game': 'sys_game.config.example',
    'login': 'sys_login.config.example',
    'center': 'sys_center.config.example',
    'cross': 'sys_cross.config.example',
    'client': 'sys_client.config.example',
}


def extract_template_placeholders_with_comments(server_root: str, server_type: str) -> Dict[str, str]:
    """从模板文件中提取所有占位符及其注释说明
    
    Args:
        server_root: 服务器根目录
        server_type: 服务器类型 (game/login/client/center/cross)
    
    Returns:
        占位符字典 {key: 注释说明}，如 {'server_id': '服务器id', 'tcp_port': 'tcp端口'}
    """
    template_file = TEMPLATE_FILE_MAP.get(server_type)
    if not template_file:
        return {}
    
    template_path = get_server_manager_config_dir(server_root) / template_file
    if not template_path.exists():
        return {}
    
    try:
        content = template_path.read_text(encoding='utf-8')
        result = {}
        
        # 逐行解析，提取 ${xxx} 和同行的 %% 注释
        for line in content.split('\n'):
            # 查找所有 ${xxx} 占位符
            matches = re.findall(r'\$\{(\w+)\}', line)
            if matches:
                # 提取同行的 %% 注释作为描述
                comment_match = re.search(r'%%\s*(.+?)(?:\s*$)', line)
                comment = ''
                if comment_match:
                    raw_comment = comment_match.group(1).strip()
                    # 只取第一个逗号或句号之前的内容，限制长度
                    for sep in [',', '，', '。', '（', '(', '，']:
                        if sep in raw_comment:
                            raw_comment = raw_comment.split(sep)[0].strip()
                            break
                    # 限制最大长度为15个字符
                    comment = raw_comment[:15] if len(raw_comment) > 15 else raw_comment
                
                for key in matches:
                    if key not in result:
                        # 使用注释作为描述，如果没有注释则使用 key 本身
                        result[key] = comment if comment else key
        
        return result
    except Exception:
        return {}


def get_template_config_keys(server_root: str, server_type: str) -> Dict[str, str]:
    """根据模板文件获取可配置的参数列表
    
    优先级：
    1. default.config 中的 editable_config_* 定义（编辑对话框专用）
    2. default.config 中的 config_keys_* 定义（完整配置项）
    3. 从模板文件提取
    4. 代码中的默认定义
    
    Args:
        server_root: 服务器根目录
        server_type: 服务器类型 (game/login/client/center/cross)
    
    Returns:
        配置项字典 {key: 中文说明}
    """
    # 优先从 default.config 读取 editable_config_* (编辑对话框专用)
    editable_from_kv = get_editable_config_from_default_kv(server_root)
    config_from_kv = get_config_keys_from_kv(server_root, server_type)
    if editable_from_kv:
        merged = dict(editable_from_kv)
        # 与 base 一致：所有服务器类型均可配置是否自动热更（editable 子集未列时也补全）
        if 'auto_reload' not in merged:
            label = (config_from_kv or {}).get('auto_reload')
            merged['auto_reload'] = label or BASE_CONFIG_KEYS.get('auto_reload', '自动热更')
        return merged

    # 其次从 default.config 读取 config_keys_* (完整配置项定义)
    if config_from_kv:
        return config_from_kv
    
    # 回退：从模板文件提取
    result = extract_template_placeholders_with_comments(server_root, server_type)
    
    # 如果从模板中读取不到，使用硬编码的配置项作为回退
    if not result:
        allowed = dict(BASE_CONFIG_KEYS)
        specific = SERVER_TYPE_SPECIFIC_KEYS.get(server_type, {})
        allowed.update(specific)
        return allowed
    
    # 排除用于组合其他值的基础占位符（这些通常在创建时就已设置，不需要单独添加）
    # 例如 db_name = "${prefix}_game_s${server_id}" 中的 prefix 和 server_id
    exclude_keys = {'prefix', 'server_id', 'server_type'}
    for key in exclude_keys:
        result.pop(key, None)
    
    return result


def get_server_type_str(server_type: str) -> str:
    """获取服务器类型字符串（如 game_server）"""
    return SERVER_TYPE_MAP.get(server_type, 'game_server')


def generate_server_dir_name(prefix: str, server_type: str, server_id: int) -> str:
    """生成服务器目录名
    
    Args:
        prefix: 服务器前缀
        server_type: 服务器类型 (game/login/client/center/cross)
        server_id: 服务器ID
    
    Returns:
        服务器目录名，如 ddxq_game_s1
    """
    return f'{prefix}_{server_type}_s{server_id}'


def get_existing_server_ids(run_dir: str, server_type: str, prefix: str) -> Set[int]:
    """获取已存在的同类型服务器ID列表
    
    Args:
        run_dir: 运行目录
        server_type: 服务器类型 (game/login/client/center/cross)
        prefix: 服务器前缀
    
    Returns:
        已存在的服务器ID集合
    """
    existing_ids = set()
    run_path = Path(run_dir)
    
    if not run_path.exists():
        return existing_ids
    
    # 匹配模式: prefix_type_sXXX
    pattern = re.compile(rf'^{re.escape(prefix)}_{server_type}_s(\d+)$', re.IGNORECASE)
    
    for item in run_path.iterdir():
        if item.is_dir():
            match = pattern.match(item.name)
            if match:
                try:
                    existing_ids.add(int(match.group(1)))
                except (ValueError, IndexError):
                    pass
    
    return existing_ids


def build_kv_config(
    server_type: str,
    server_id: int,
    prefix: str,
    ip: str,
    db_host: str,
    db_user: str,
    db_pass: str,
    db_port: int,
    server_dir: str,
    db_game_name: Optional[str] = None,
    db_log_name: Optional[str] = None,
    login_node: Optional[str] = None,
    center_node: Optional[str] = None,
    server_name: Optional[str] = None,
    tcp_port: Optional[int] = None,
    http_port: Optional[int] = None,
    login_host: Optional[str] = None,
    login_http_port: Optional[int] = None,
    open_time: Optional[str] = None,
    auto_reload: Optional[bool] = None
) -> Dict[str, str]:
    """构建服务器的差异化配置 kv.config
    
    Args:
        server_type: 服务器类型 (game/login/client/center/cross)
        server_id: 服务器ID
        prefix: 服务器前缀
        ip: 本机IP
        db_host: 数据库地址
        db_user: 数据库用户
        db_pass: 数据库密码
        db_port: 数据库端口
        server_dir: 服务器目录名
        db_game_name: 游戏/业务数据库名（可选，默认按前缀、类型、ID生成）
        db_log_name: 日志数据库名（可选，默认按前缀、类型、ID生成）
        login_node: 登录节点（可选）
        center_node: 中心节点（可选）
        server_name: 服务器名称（可选）
        tcp_port: TCP端口（可选）
        http_port: HTTP端口（可选）
        login_host: 客户端服连接的登录服地址（可选）
        login_http_port: 客户端服连接的登录服 HTTP 端口（可选）
        open_time: 开服时间（可选）
    
    Returns:
        配置字典
    """
    server_type_str = get_server_type_str(server_type)
    
    # 根据服务器类型生成数据库名
    db_type_prefix = {
        'game': 'game',
        'login': 'login',
        'center': 'center',
        'cross': 'cross',
        'client': 'client'
    }
    type_prefix = db_type_prefix.get(server_type, server_type)
    default_db_game_name = f'{prefix}_{type_prefix}_s{server_id}'
    default_db_log_name = f'{prefix}_{type_prefix}_log_s{server_id}' if server_type != 'login' else ''
    db_game_name_value = (db_game_name or default_db_game_name).strip()
    db_log_name_value = (db_log_name if db_log_name is not None else default_db_log_name).strip()
    
    # 基础配置
    diff_config = {
        'prefix': prefix,
        'server_id': str(server_id),
        'server_type': server_type_str,
        'ip': ip,
        'db_host': db_host,
        'db_user': db_user,
        'db_pass': db_pass,
        'db_port': str(db_port),
        'log_dir': 'log',  # 相对于服务器运行目录
        'db_game_name': db_game_name_value,
    }
    
    # 如果有日志数据库（登录服没有）
    if db_log_name_value:
        diff_config['db_log_name'] = db_log_name_value
    
    # 根据服务器类型添加特定字段
    # game: server_name, tcp_port, http_port, game_host, open_time
    # login: tcp_port
    # center: open_time
    # cross: open_time
    # client: tcp_port, game_host

    if auto_reload is not None:
        diff_config['auto_reload'] = 'true' if auto_reload else 'false'
    
    if server_type == 'game':
        if server_name:
            diff_config['server_name'] = server_name
        diff_config['game_host'] = ip
        if tcp_port:
            diff_config['tcp_port'] = str(tcp_port)
        if http_port:
            diff_config['http_port'] = str(http_port)
        if open_time:
            diff_config['open_time'] = open_time
        diff_config['role_log'] = f'run/{server_dir}/log'
    elif server_type == 'login':
        if tcp_port:
            diff_config['tcp_port'] = str(tcp_port)
    elif server_type == 'center':
        if open_time:
            diff_config['open_time'] = open_time
    elif server_type == 'cross':
        if open_time:
            diff_config['open_time'] = open_time
    elif server_type == 'client':
        diff_config['game_host'] = ip
        if tcp_port:
            diff_config['tcp_port'] = str(tcp_port)
    
    # 节点配置（模板中已有引号，这里不需要添加）
    # game/client/center 需要登录节点
    if login_node and server_type in ('game', 'client', 'center'):
        diff_config['login_node'] = login_node
    # game/cross 需要中心服节点
    if center_node and server_type in ('game', 'cross'):
        diff_config['center_node'] = center_node
    
    # 客户端测试配置
    if server_type == 'client':
        if tcp_port:
            diff_config['game_tcp_port'] = str(tcp_port)
        diff_config['login_host'] = login_host or ip
        diff_config['login_http_port'] = str(login_http_port or 19900)
    
    return diff_config


def create_server(
    server_root: str,
    run_dir: str,
    server_type: str,
    server_id: int,
    prefix: str,
    db_host: str,
    db_user: str,
    db_pass: str,
    db_port: int,
    db_game_name: Optional[str] = None,
    db_log_name: Optional[str] = None,
    login_node: Optional[str] = None,
    center_node: Optional[str] = None,
    server_name: Optional[str] = None,
    tcp_port: Optional[int] = None,
    http_port: Optional[int] = None,
    login_host: Optional[str] = None,
    login_http_port: Optional[int] = None,
    open_time: Optional[str] = None,
    auto_reload: Optional[bool] = None,
    overwrite: bool = False
) -> Tuple[bool, str, Optional[Dict[str, str]]]:
    """创建服务器
    
    在 run/{server}/config/kv.config 创建差异化配置
    
    Args:
        server_root: 服务器根目录
        run_dir: 运行目录
        server_type: 服务器类型 (game/login/client/center/cross)
        server_id: 服务器ID
        prefix: 服务器前缀
        db_host: 数据库地址
        db_user: 数据库用户
        db_pass: 数据库密码
        db_port: 数据库端口
        db_game_name: 游戏/业务数据库名（可选，默认按前缀、类型、ID生成）
        db_log_name: 日志数据库名（可选，默认按前缀、类型、ID生成）
        login_node: 登录节点（可选）
        center_node: 中心节点（可选）
        server_name: 服务器名称（可选）
        tcp_port: TCP端口（可选）
        http_port: HTTP端口（可选）
        login_host: 客户端服连接的登录服地址（可选）
        login_http_port: 客户端服连接的登录服 HTTP 端口（可选）
        open_time: 开服时间（可选）
        auto_reload: 是否自动热更
        overwrite: 如果服务器已存在是否覆盖
    
    Returns:
        (成功, 消息, 合并后的配置字典)
    """
    # 本机 IP（read_merged_config 已统一为 get_local_ip()）
    merged = read_merged_config(server_root) if server_root else {}
    ip = merged.get('ip') or get_local_ip()
    
    if not run_dir and server_root:
        run_dir = str(Path(server_root) / 'run')
    
    # 生成服务器目录名
    server_dir = generate_server_dir_name(prefix, server_type, server_id)
    
    # 服务器配置目录
    server_config_path = Path(run_dir) / server_dir / 'config'
    kv_config_file = server_config_path / 'kv.config'
    
    # 检查是否已存在
    if kv_config_file.exists() and not overwrite:
        return False, f'服务器 {server_dir} 已存在', None
    
    try:
        # 创建目录
        server_config_path.mkdir(parents=True, exist_ok=True)
        
        # 构建差异化配置
        diff_config = build_kv_config(
            server_type=server_type,
            server_id=server_id,
            prefix=prefix,
            ip=ip,
            db_host=db_host,
            db_user=db_user,
            db_pass=db_pass,
            db_port=db_port,
            server_dir=server_dir,
            db_game_name=db_game_name,
            db_log_name=db_log_name,
            login_node=login_node,
            center_node=center_node,
            server_name=server_name,
            tcp_port=tcp_port,
            http_port=http_port,
            login_host=login_host,
            login_http_port=login_http_port,
            open_time=open_time,
            auto_reload=auto_reload
        )
        
        # 写入差异化配置 kv.config
        write_config_file(str(kv_config_file), diff_config)
        
        # 生成完整配置 sys.config
        merged_config = generate_start_config(server_root, server_dir)
        
        return True, f'服务器 {server_dir} 创建成功', merged_config
        
    except Exception as e:
        return False, f'创建服务器失败: {str(e)}', None


def get_id_range_from_config(default_kv: Dict[str, str], server_type: str) -> Tuple[int, int, int]:
    """从配置中获取服务器ID范围
    
    Args:
        default_kv: 默认配置字典
        server_type: 服务器类型 (game/login/client/center/cross)
    
    Returns:
        (最小值, 最大值, 默认值)
    """
    # 默认范围
    default_ranges = {
        'game': (100, 9999, 100),
        'login': (10, 100, 10),
        'center': (1, 10, 1),
        'cross': (10000, 20000, 10000),
        'client': (1, 10000, 1)
    }
    
    min_key = f'{server_type}_id_min'
    max_key = f'{server_type}_id_max'
    default_key = f'{server_type}_id_default'
    
    try:
        id_min = int(default_kv.get(min_key, default_ranges.get(server_type, (1, 100, 1))[0]))
        id_max = int(default_kv.get(max_key, default_ranges.get(server_type, (1, 100, 1))[1]))
        id_default = int(default_kv.get(default_key, default_ranges.get(server_type, (1, 100, 1))[2]))
    except (ValueError, TypeError):
        id_min, id_max, id_default = default_ranges.get(server_type, (1, 100, 1))
    
    return id_min, id_max, id_default


def get_default_port(server_type: str, server_id: int) -> Tuple[int, int]:
    """获取默认端口号
    
    Args:
        server_type: 服务器类型
        server_id: 服务器ID
    
    Returns:
        (TCP端口, HTTP端口)
    """
    # 基础端口
    base_tcp = 18000
    base_http = 19000
    
    tcp_port = base_tcp + server_id
    http_port = base_http + server_id
    
    return tcp_port, http_port


def get_default_server_name(prefix: str, server_id: int) -> str:
    """获取默认服务器名称
    
    Args:
        prefix: 服务器前缀
        server_id: 服务器ID
    
    Returns:
        服务器名称
    """
    return f'{prefix}_{server_id}'


def build_confirmation_message(
    server_type: str,
    server_dir: str,
    server_id: int,
    ip: str,
    db_host: str,
    db_port: int,
    login_node: Optional[str] = None,
    center_node: Optional[str] = None,
    server_name: Optional[str] = None,
    tcp_port: Optional[int] = None,
    http_port: Optional[int] = None,
    open_time: Optional[str] = None
) -> str:
    """构建创建确认消息
    
    Args:
        各种服务器配置参数
    
    Returns:
        确认消息字符串
    """
    type_name = get_server_type_name(server_type)
    
    lines = [
        f'即将创建 {type_name}:',
        '',
        f'服务器目录: {server_dir}',
        f'服务器ID: {server_id}',
        f'本机IP: {ip}',
        f'数据库: {db_host}:{db_port}',
    ]
    
    # 根据服务器类型添加特定信息
    if server_type == 'game':
        if server_name:
            lines.append(f'服务器名称: {server_name}')
        if tcp_port:
            lines.append(f'TCP端口: {tcp_port}')
        if http_port:
            lines.append(f'HTTP端口: {http_port}')
        if open_time:
            lines.append(f'开服时间: {open_time}')
    elif server_type == 'login':
        if tcp_port:
            lines.append(f'TCP端口: {tcp_port}')
    elif server_type == 'center':
        if open_time:
            lines.append(f'开服时间: {open_time}')
    elif server_type == 'cross':
        if open_time:
            lines.append(f'开服时间: {open_time}')
    elif server_type == 'client':
        if tcp_port:
            lines.append(f'TCP端口: {tcp_port}')
    
    # 节点信息
    if login_node and server_type in ('game', 'client', 'center'):
        lines.append(f'登录节点: {login_node}')
    if center_node and server_type in ('game', 'cross'):
        lines.append(f'中心节点: {center_node}')
    
    lines.extend(['', '是否继续创建？'])
    
    return '\n'.join(lines)
