#!/usr/bin/env python3
"""
WeCom CLI工具调用封装
用于调用wecom-cli MCP Server的工具
"""

import json
import subprocess
import sys
import os
from typing import Dict, Any, Optional

class WeComCLI:
    """WeCom CLI工具调用类"""
    
    def __init__(self, server_script: str = None):
        """
        初始化
        
        Args:
            server_script: MCP Server脚本路径
        """
        self.server_script = server_script or "/root/.openclaw/agents/101/workspace/wecom-cli-mcp-server.js"
        self.server_process = None
        
    def start_server(self):
        """启动MCP Server"""
        if self.server_process is None:
            try:
                self.server_process = subprocess.Popen(
                    ["node", self.server_script],
                    stdin=subprocess.PIPE,
                    stdout=subprocess.PIPE,
                    stderr=subprocess.PIPE,
                    text=True
                )
                print(f"[INFO] WeCom CLI MCP Server已启动 (PID: {self.server_process.pid})")
            except Exception as e:
                print(f"[ERROR] 启动MCP Server失败: {e}")
                raise
    
    def stop_server(self):
        """停止MCP Server"""
        if self.server_process:
            self.server_process.terminate()
            self.server_process.wait()
            self.server_process = None
            print("[INFO] WeCom CLI MCP Server已停止")
    
    def call_tool(self, category: str, method: str, args: Dict[str, Any]) -> Dict[str, Any]:
        """
        调用MCP工具
        
        Args:
            category: 工具品类（如smartsheet, meeting等）
            method: 方法名（如get_records, create等）
            args: 参数
            
        Returns:
            工具调用结果
        """
        try:
            # 构建完整的工具名
            if category == "smartsheet":
                tool_name = f"smartsheet_{method}"
            else:
                tool_name = f"{category}_{method}"
            
            # 构建MCP请求
            request = {
                "jsonrpc": "2.0",
                "id": 1,
                "method": "tools/call",
                "params": {
                    "name": tool_name,
                    "arguments": args
                }
            }
            
            # 发送请求到MCP Server
            request_json = json.dumps(request) + "\n"
            
            if self.server_process is None:
                self.start_server()
            
            # 发送请求并获取响应
            stdout, stderr = self.server_process.communicate(input=request_json, timeout=10)
            
            if stderr:
                print(f"[DEBUG] MCP Server stderr: {stderr}")
            
            # 解析响应
            response = json.loads(stdout)
            
            if "error" in response:
                return {
                    "error": True,
                    "message": response["error"].get("message", "Unknown error"),
                    "code": response["error"].get("code", -1)
                }
            
            # 提取结果
            result = response.get("result", {})
            content = result.get("content", [])
            
            if content and content[0].get("type") == "text":
                try:
                    result_data = json.loads(content[0]["text"])
                    return {
                        "error": False,
                        "data": result_data
                    }
                except json.JSONDecodeError:
                    return {
                        "error": False,
                        "raw_text": content[0]["text"]
                    }
            
            return {
                "error": False,
                "data": result
            }
            
        except subprocess.TimeoutExpired:
            return {
                "error": True,
                "message": "MCP Server响应超时"
            }
        except Exception as e:
            return {
                "error": True,
                "message": f"调用工具失败: {str(e)}"
            }
    
    def smartsheet_get_records(self, docid: str, sheet_id: str, limit: int = 100, offset: int = 0) -> Dict[str, Any]:
        """获取智能表格记录"""
        return self.call_tool("smartsheet", "get_records", {
            "docid": docid,
            "sheet_id": sheet_id,
            "limit": limit,
            "offset": offset
        })
    
    def smartsheet_add_records(self, docid: str, sheet_id: str, records: list) -> Dict[str, Any]:
        """添加智能表格记录"""
        return self.call_tool("smartsheet", "add_records", {
            "docid": docid,
            "sheet_id": sheet_id,
            "records": records
        })
    
    def smartsheet_delete_records(self, docid: str, sheet_id: str, record_ids: list) -> Dict[str, Any]:
        """删除智能表格记录"""
        return self.call_tool("smartsheet", "delete_records", {
            "docid": docid,
            "sheet_id": sheet_id,
            "record_ids": record_ids
        })
    
    def smartsheet_update_records(self, docid: str, sheet_id: str, records: list) -> Dict[str, Any]:
        """更新智能表格记录"""
        return self.call_tool("smartsheet", "update_records", {
            "docid": docid,
            "sheet_id": sheet_id,
            "records": records
        })
    
    def meeting_create(self, title: str, start_time: str, end_time: str, 
                      attendees: list = None, description: str = "") -> Dict[str, Any]:
        """创建会议"""
        return self.call_tool("meeting", "create", {
            "title": title,
            "start_time": start_time,
            "end_time": end_time,
            "attendees": attendees or [],
            "description": description
        })
    
    def msg_send_text(self, to_user: str, content: str) -> Dict[str, Any]:
        """发送文本消息"""
        return self.call_tool("msg", "send_text", {
            "to_user": to_user,
            "content": content
        })

def main():
    """命令行入口"""
    import argparse
    
    parser = argparse.ArgumentParser(description="WeCom CLI工具调用")
    parser.add_argument("--category", required=True, help="工具品类")
    parser.add_argument("--method", required=True, help="方法名")
    parser.add_argument("--args", required=True, help="JSON格式的参数")
    
    args = parser.parse_args()
    
    try:
        # 解析参数
        method_args = json.loads(args.args)
        
        # 创建客户端
        client = WeComCLI()
        
        # 调用工具
        result = client.call_tool(args.category, args.method, method_args)
        
        # 输出结果
        print(json.dumps(result, indent=2, ensure_ascii=False))
        
        # 停止服务器
        client.stop_server()
        
    except json.JSONDecodeError as e:
        print(json.dumps({
            "error": True,
            "message": f"参数JSON解析失败: {str(e)}"
        }, indent=2))
        sys.exit(1)
    except Exception as e:
        print(json.dumps({
            "error": True,
            "message": f"执行失败: {str(e)}"
        }, indent=2))
        sys.exit(1)

if __name__ == "__main__":
    main()