#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
VWED统一对象模块系统
提供脚本中可使用的VWED.api、VWED.function等统一接口
"""

import asyncio
from typing import Dict, Any, Optional, Callable, List
from services.script_registry_service import get_global_registry
from services.script_websocket_service import get_websocket_manager
from services.task_service import get_task_service
from utils.logger import get_logger

logger = get_logger("services.script_vwed_objects")


class VWEDApiModule:
    """VWED.api 模块 - API接口注册"""
    
    def __init__(self, script_id: str):
        self.script_id = script_id
        self.registry = get_global_registry()
    
    # def register(self, path: str, method: str = "GET",
    #             description: str = "", parameters: Dict = None,
    #             response_schema: Dict = None):
    #     """装饰器：注册API接口
    #
    #     使用方式：
    #     @VWED.api.register("/test", "POST", description="测试接口")
    #     def handle_test(request_data):
    #         return {"result": "success"}
    #     """
    #     def decorator(handler: Callable):
    #         self.registry.register_api_route(
    #             path=path,
    #             method=method,
    #             handler=handler,
    #             script_id=self.script_id,
    #             description=description,
    #             parameters=parameters,
    #             response_schema=response_schema
    #         )
    #         return handler
    #     return decorator
    
    # def get(self, path: str, **kwargs):
    #     """注册GET接口"""
    #     return self.register(path, "GET", **kwargs)
    #
    # def post(self, path: str, **kwargs):
    #     """注册POST接口"""
    #     return self.register(path, "POST", **kwargs)
    #
    # def put(self, path: str, **kwargs):
    #     """注册PUT接口"""
    #     return self.register(path, "PUT", **kwargs)
    #
    # def delete(self, path: str, **kwargs):
    #     """注册DELETE接口"""
    #     return self.register(path, "DELETE", **kwargs)
    
    def register_route(self, path: str, method: str = "GET", handler: Callable = None,
                      description: str = "", params: Dict = None, 
                      parameters: Dict = None, response_schema: Dict = None):
        """分离式API接口注册（用户要求的新格式）
        
        使用方式：
        VWED.api.register_route(
            path="/calculate",
            method="POST", 
            handler=calculate_handler,
            description="数学计算接口",
            params={"a": 0, "b": 0, "operation": "add"}  # 简化的参数定义
        )
        """
        # 验证HTTP方法
        valid_methods = ["GET", "POST", "PUT", "DELETE"]
        if method.upper() not in valid_methods:
            raise ValueError(f"method参数错误：'{method}' 不是有效的HTTP请求方式。支持的方式有：{', '.join(valid_methods)}")
        
        if handler is None:
            raise ValueError("handler参数不能为空")
            
        self.registry.register_api_route(
            path=path,
            method=method.upper(),
            handler=handler,
            script_id=self.script_id,
            description=description,
            params=params,  # 传递简化的参数格式
            parameters=parameters,
            response_schema=response_schema
        )
        return handler


class VWEDFunctionModule:
    """VWED.function 模块 - 自定义函数注册"""
    
    def __init__(self, script_id: str):
        self.script_id = script_id
        self.registry = get_global_registry()
    
    def register(self, name: str, handler: Callable = None, description: str = "", 
                params: Dict = None, parameters: List[Dict] = None, 
                return_schema: Dict = None, tags: List[str] = None):
        """分离式自定义函数注册
        
        使用方式：
        VWED.function.register(
            name="simple_add",
            handler=simple_add,
            description="简单加法函数",
            params={"a": 0, "b": 0}  # 简化的参数定义
        )
        """
        if handler is None:
            raise ValueError("handler参数不能为空")
            
        self.registry.register_function(
            name=name,
            handler=handler,
            script_id=self.script_id,
            description=description,
            params=params,  # 传递简化的参数格式
            parameters=parameters,
            return_schema=return_schema,
            tags=tags
        )
        return handler


class VWEDEventModule:
    """VWED.event 模块 - 事件系统"""
    
    def __init__(self, script_id: str):
        self.script_id = script_id
        self.registry = get_global_registry()
    
    def listen(self, event_name: str, handler: Callable, priority: int = 1):
        """注册事件监听器
            
        分离式模式：
        VWED.event.listen(
            event_name="user_login",
            handler=on_user_login
        )
        """
        def decorator(func: Callable):
            self.registry.register_event_listener(
                event_name=event_name,
                handler=func,
                script_id=self.script_id,
                priority=priority
            )
            return func
            
        # if handler is not None:
        return decorator(handler)
        # else:
        #     # 装饰器模式
        #     return decorator
    
    async def emit(self, event_name: str, data: Dict[str, Any]):
        """触发事件"""
        await self.registry.emit_event(event_name, data)
    
    def on(self, event_name: str, priority: int = 1):
        """listen的别名"""
        return self.listen(event_name, priority=priority)


class VWEDTimerModule:
    """VWED.timer 模块 - 定时任务"""
    
    def __init__(self, script_id: str):
        self.script_id = script_id
        self.registry = get_global_registry()
    
    def interval(self, seconds: int, handler: Callable, repeat: bool = True, delay: int = 0):
        """注册定时任务
        分离式模式：
        VWED.timer.interval(
            seconds=60,
            handler=system_monitor
        )
        """
        def decorator(func: Callable):
            timer_id = f"{self.script_id}_{func.__name__}_{id(func)}"
            self.registry.register_timer(
                timer_id=timer_id,
                interval=seconds,
                handler=func,
                script_id=self.script_id,
                repeat=repeat,
                delay=delay
            )
            return func
            
        # if handler is not None:
        #     分离式调用模式
        return decorator(handler)
        # else:
        #     # 装饰器模式
        #     return decorator
    
    def once(self, delay: int = 0, handler: Callable = None):
        """注册一次性定时任务
        分离式模式：
        VWED.timer.once(
            delay=10,
            handler=initialization_task
        )
        """
        return self.interval(0, handler=handler, repeat=False, delay=delay)
    
    # def every(self, seconds: int):
    #     """interval的别名"""
    #     return self.interval(seconds)


class VWEDLogModule:
    """VWED.log 模块 - 日志系统"""
    
    def __init__(self, script_id: str):
        self.script_id = script_id
        self.websocket_manager = get_websocket_manager()
    
    async def info(self, message: str, **kwargs):
        """输出信息日志"""
        await self.websocket_manager.broadcast_script_log(
            self.script_id, "INFO", message, **kwargs
        )
    
    async def warning(self, message: str, **kwargs):
        """输出警告日志"""
        await self.websocket_manager.broadcast_script_log(
            self.script_id, "WARNING", message, **kwargs
        )
    
    async def error(self, message: str, **kwargs):
        """输出错误日志"""
        await self.websocket_manager.broadcast_script_log(
            self.script_id, "ERROR", message, **kwargs
        )
    
    async def debug(self, message: str, **kwargs):
        """输出调试日志"""
        await self.websocket_manager.broadcast_script_log(
            self.script_id, "DEBUG", message, **kwargs
        )
    
    def sync_info(self, message: str, **kwargs):
        """同步方式输出信息日志"""
        asyncio.create_task(self.info(message, **kwargs))
    
    def sync_warning(self, message: str, **kwargs):
        """同步方式输出警告日志"""
        asyncio.create_task(self.warning(message, **kwargs))
    
    def sync_error(self, message: str, **kwargs):
        """同步方式输出错误日志"""
        asyncio.create_task(self.error(message, **kwargs))
    
    def sync_debug(self, message: str, **kwargs):
        """同步方式输出调试日志"""
        asyncio.create_task(self.debug(message, **kwargs))


class VWEDTaskModule:
    """VWED.task 模块 - 任务系统集成"""
    
    def __init__(self, script_id: str):
        self.script_id = script_id
        self.task_service = get_task_service()
    
    async def create_task(self, task_name: str, task_config: Dict[str, Any]) -> Dict[str, Any]:
        """创建VWED任务"""
        # 这里集成现有的任务服务
        # 具体实现需要根据现有的任务系统API进行调整
        return {"success": True, "message": "任务创建功能待实现"}
    
    async def execute_task(self, task_id: int, parameters: Dict[str, Any] = None) -> Dict[str, Any]:
        """执行VWED任务"""
        # 集成现有的任务执行系统
        return {"success": True, "message": "任务执行功能待实现"}
    
    async def get_task_status(self, task_id: int) -> Dict[str, Any]:
        """获取任务状态"""
        return {"success": True, "message": "获取任务状态功能待实现"}


class VWEDDataModule:
    """VWED.data 模块 - 数据存储和缓存"""
    
    def __init__(self, script_id: str):
        self.script_id = script_id
        self._storage: Dict[str, Any] = {}
    
    def get(self, key: str, default=None):
        """获取数据"""
        return self._storage.get(key, default)
    
    def set(self, key: str, value: Any):
        """设置数据"""
        self._storage[key] = value
    
    def delete(self, key: str):
        """删除数据"""
        if key in self._storage:
            del self._storage[key]
    
    def clear(self):
        """清空所有数据"""
        self._storage.clear()
    
    def keys(self):
        """获取所有键"""
        return list(self._storage.keys())
    
    def has(self, key: str) -> bool:
        """检查键是否存在"""
        return key in self._storage


class VWEDUtilModule:
    """VWED.util 模块 - 工具函数"""
    
    def __init__(self, script_id: str):
        self.script_id = script_id
    
    def sleep(self, seconds: float):
        """同步睡眠"""
        import time
        time.sleep(seconds)
    
    async def async_sleep(self, seconds: float):
        """异步睡眠"""
        await asyncio.sleep(seconds)
    
    def now(self) -> str:
        """获取当前时间"""
        from datetime import datetime
        return datetime.now().isoformat()
    
    def timestamp(self) -> float:
        """获取当前时间戳"""
        import time
        return time.time()
    
    def uuid(self) -> str:
        """生成UUID"""
        import uuid
        return str(uuid.uuid4())


class VWEDObject:
    """VWED统一对象 - 脚本中的全局VWED变量"""
    
    def __init__(self, script_id: str):
        self.script_id = script_id
        
        # 初始化各模块
        self.api = VWEDApiModule(script_id)
        self.function = VWEDFunctionModule(script_id)
        self.event = VWEDEventModule(script_id)
        self.timer = VWEDTimerModule(script_id)
        self.log = VWEDLogModule(script_id)
        self.task = VWEDTaskModule(script_id)
        self.data = VWEDDataModule(script_id)
        self.util = VWEDUtilModule(script_id)
    
    def get_script_id(self) -> str:
        """获取当前脚本ID"""
        return self.script_id


def create_vwed_object(script_id: str) -> VWEDObject:
    """创建VWED对象实例"""
    return VWEDObject(script_id)