# -*- coding: utf-8 -*-
"""
Schema 生成工具模块
"""

from typing import Any, Dict, List


def generate_input_schema(parameters: Dict[str, Any]) -> Dict[str, Any]:
    """
    从查询配置的参数定义生成 MCP 工具的 inputSchema
    
    此函数会保留完整的 JSON Schema 信息，包括：
    - type: Schema 类型（通常是 "object"）
    - required: 必填字段列表
    - properties: 属性定义（包括每个属性的 type, description, format, examples 等）
    - description: Schema 的整体描述（如果有）
    - 以及其他任何 JSON Schema 标准字段
    
    此函数还会自动添加以下字段（如果原始 parameters 中未定义）：
    - targetDatabaseName: 目标数据库名称（非必填，默认为空字符串）
    
    Args:
        parameters: 查询配置中的参数定义字典，应该是一个完整的 JSON Schema 对象
        
    Returns:
        Dict[str, Any]: 符合 JSON Schema 规范的 inputSchema 对象
        
    Example:
        >>> params = {
        ...     "type": "object",
        ...     "required": ["userId", "startTime"],
        ...     "properties": {
        ...         "userId": {
        ...             "type": "integer",
        ...             "description": "用户的唯一标识符",
        ...             "examples": [10086]
        ...         },
        ...         "startTime": {
        ...             "type": "string",
        ...             "format": "date-time",
        ...             "description": "查询的起始时间",
        ...             "examples": ["2023-01-01 00:00:00"]
        ...         }
        ...     }
        ... }
        >>> schema = generate_input_schema(params)
        >>> # schema 将包含所有原始信息，包括 format 和 examples
        >>> # 同时会自动添加 targetDatabaseName 字段
    """
    # 如果 parameters 本身就是一个完整的 JSON Schema 对象，直接使用
    # 但确保至少包含 type 和 properties
    if not parameters:
        # 如果 parameters 为空，返回一个空的 object schema
        return {
            "type": "object",
            "properties": {},
            "required": []
        }
    
    # 检查 parameters 是否已经是完整的 JSON Schema 格式
    # 完整格式应该有 "type": "object" 和 "properties" 字段
    if "type" in parameters and parameters.get("type") == "object" and "properties" in parameters:
        # 已经是完整的 JSON Schema 格式，直接使用
        input_schema = dict(parameters)
    else:
        # parameters 是简化格式（直接是参数定义），需要转换为 JSON Schema 格式
        # 例如: {"workOrderNumber": {"type": "string", "description": "...", "required": true}}
        properties = {}
        required = []
        
        for param_name, param_def in parameters.items():
            if isinstance(param_def, dict):
                # 提取 required 标记
                if param_def.get("required", False):
                    required.append(param_name)
                
                # 复制参数定义，但移除 required 字段（它应该在顶层的 required 数组中）
                prop_def = {k: v for k, v in param_def.items() if k != "required"}
                properties[param_name] = prop_def
        
        input_schema = {
            "type": "object",
            "properties": properties,
            "required": required
        }
    
    # 确保必需的字段存在
    if "type" not in input_schema:
        input_schema["type"] = "object"
    
    if "properties" not in input_schema:
        input_schema["properties"] = {}
    
    if "required" not in input_schema:
        input_schema["required"] = []
    
    # 添加 targetDatabaseName 字段（如果不存在）
    if "targetDatabaseName" not in input_schema["properties"]:
        input_schema["properties"]["targetDatabaseName"] = {
            "type": "string",
            "description": "目标数据库名称",
            "default": ""
        }
    
    # 保留所有其他字段，如 description, examples, format 等
    # JSON Schema 标准支持的字段都会被保留：
    # - additionalProperties
    # - patternProperties
    # - minProperties / maxProperties
    # - dependencies
    # - 等等
    
    return input_schema


def validate_input_schema(schema: Dict[str, Any]) -> tuple[bool, str]:
    """
    验证 inputSchema 是否符合基本的 JSON Schema 规范
    
    Args:
        schema: 要验证的 schema 对象
        
    Returns:
        tuple[bool, str]: (是否有效, 错误消息或成功消息)
        
    Example:
        >>> schema = {"type": "object", "properties": {"id": {"type": "string"}}}
        >>> is_valid, msg = validate_input_schema(schema)
        >>> print(is_valid, msg)
        True, "Schema 验证通过"
    """
    if not isinstance(schema, dict):
        return False, "Schema 必须是一个字典对象"
    
    if schema.get("type") != "object":
        return False, "Schema 的 type 字段必须是 'object'"
    
    if "properties" not in schema:
        return False, "Schema 必须包含 properties 字段"
    
    if not isinstance(schema.get("properties"), dict):
        return False, "Schema 的 properties 字段必须是一个字典对象"
    
    # 验证 required 字段（如果存在）
    if "required" in schema:
        required = schema["required"]
        if not isinstance(required, list):
            return False, "Schema 的 required 字段必须是一个列表"
        
        # 验证所有 required 的字段都在 properties 中定义
        properties = schema["properties"]
        for field in required:
            if field not in properties:
                return False, f"必填字段 '{field}' 未在 properties 中定义"
    
    # 验证 properties 中每个字段的定义
    for prop_name, prop_def in schema["properties"].items():
        if not isinstance(prop_def, dict):
            return False, f"属性 '{prop_name}' 的定义必须是一个字典对象"
        
        if "type" not in prop_def:
            return False, f"属性 '{prop_name}' 必须包含 type 字段"
    
    return True, "Schema 验证通过"

