"""
工作站基类
Workstation Base Class - 单接口模式

基于单一硬件接口的简化工作站架构
支持直接模式和代理模式的自动工作流执行器选择
"""
import time
import traceback
from typing import Dict, Any, List, Optional, Union, TYPE_CHECKING
from abc import ABC, abstractmethod
from dataclasses import dataclass
from enum import Enum

if TYPE_CHECKING:
    from unilabos.ros.nodes.presets.protocol_node import ROS2WorkstationNode

from unilabos.devices.work_station.workstation_material_management import MaterialManagementBase
from unilabos.devices.work_station.workstation_http_service import (
    WorkstationHTTPService, WorkstationReportRequest, MaterialUsage
)
from unilabos.utils.log import logger


class WorkflowStatus(Enum):
    """工作流状态"""
    IDLE = "idle"
    INITIALIZING = "initializing"  
    RUNNING = "running"
    PAUSED = "paused"
    STOPPING = "stopping"
    STOPPED = "stopped"
    ERROR = "error"
    COMPLETED = "completed"


@dataclass
class WorkflowInfo:
    """工作流信息"""
    name: str
    description: str
    estimated_duration: float  # 预估持续时间（秒）
    required_materials: List[str]  # 所需物料类型
    output_product: str  # 输出产品类型
    parameters_schema: Dict[str, Any]  # 参数架构


class WorkstationBase(ABC):
    """工作站基类 - 单接口模式
    
    核心设计原则：
    1. 每个工作站只有一个 hardware_interface
    2. 根据接口类型自动选择工作流执行器
    3. 支持直接模式和代理模式
    4. 统一的设备操作接口
    """

    def __init__(
        self,
        device_id: str,
        deck_config: Optional[Dict[str, Any]] = None,
        http_service_config: Optional[Dict[str, Any]] = None,
        *args,
        **kwargs,
    ):
        # 基本配置
        self.device_id = device_id
        self.deck_config = deck_config or {"size_x": 1000.0, "size_y": 1000.0, "size_z": 500.0}
        
        # HTTP服务配置
        self.http_service_config = http_service_config or {
            "enabled": True,
            "host": "127.0.0.1", 
            "port": 8081
        }
        
        # 单一硬件接口 - 可以是具体客户端对象或代理字符串
        self.hardware_interface: Union[Any, str] = None
        
        # 协议节点引用（用于代理模式）
        self._protocol_node: Optional['ROS2WorkstationNode'] = None
        
        # 工作流执行器（基于通信接口类型自动选择）
        self.workflow_executor: Optional['WorkflowExecutor'] = None
        
        # 工作流状态
        self.current_workflow_status = WorkflowStatus.IDLE
        self.current_workflow_info = None
        self.workflow_start_time = None
        self.workflow_parameters = {}
        
        # 错误处理
        self.error_history = []
        self.action_results = {}
        
        # 支持的工作流（静态预定义）
        self.supported_workflows: Dict[str, WorkflowInfo] = {}
        
        # 初始化工作站模块
        self.material_management: MaterialManagementBase = self._create_material_management_module()
        
        # 注册支持的工作流
        self._register_supported_workflows()
        
        # 启动HTTP报送接收服务
        self.http_service = None
        self._start_http_service()
        
        logger.info(f"工作站 {device_id} 初始化完成（单接口模式）")

    def set_hardware_interface(self, hardware_interface: Union[Any, str]):
        """设置硬件接口"""
        self.hardware_interface = hardware_interface
        
        # 根据接口类型自动创建工作流执行器
        self._setup_workflow_executor()
        
        logger.info(f"工作站 {self.device_id} 硬件接口设置: {type(hardware_interface).__name__}")

    def set_protocol_node(self, protocol_node: 'ROS2WorkstationNode'):
        """设置协议节点引用（用于代理模式）"""
        self._protocol_node = protocol_node
        logger.info(f"工作站 {self.device_id} 关联协议节点")

    def _setup_workflow_executor(self):
        """根据硬件接口类型自动设置工作流执行器"""
        if self.hardware_interface is None:
            return
        
        # 动态导入工作流执行器类
        try:
            from unilabos.devices.work_station.workflow_executors import (
                ProxyWorkflowExecutor, ModbusWorkflowExecutor, 
                HttpWorkflowExecutor, PyLabRobotWorkflowExecutor
            )
        except ImportError:
            logger.warning("工作流执行器模块未找到，将使用基础执行器")
            self.workflow_executor = None
            return
        
        # 检查是否为代理字符串
        if isinstance(self.hardware_interface, str) and self.hardware_interface.startswith("proxy:"):
            self.workflow_executor = ProxyWorkflowExecutor(self)
            logger.info(f"工作站 {self.device_id} 使用代理工作流执行器")
            
        # 检查是否为Modbus客户端
        elif hasattr(self.hardware_interface, 'write_register') and hasattr(self.hardware_interface, 'read_register'):
            self.workflow_executor = ModbusWorkflowExecutor(self)
            logger.info(f"工作站 {self.device_id} 使用Modbus工作流执行器")
            
        # 检查是否为HTTP客户端
        elif hasattr(self.hardware_interface, 'post') or hasattr(self.hardware_interface, 'get'):
            self.workflow_executor = HttpWorkflowExecutor(self)
            logger.info(f"工作站 {self.device_id} 使用HTTP工作流执行器")
            
        # 检查是否为PyLabRobot设备
        elif hasattr(self.hardware_interface, 'transfer_liquid') or hasattr(self.hardware_interface, 'pickup_tips'):
            self.workflow_executor = PyLabRobotWorkflowExecutor(self)
            logger.info(f"工作站 {self.device_id} 使用PyLabRobot工作流执行器")
            
        else:
            logger.warning(f"工作站 {self.device_id} 无法识别硬件接口类型: {type(self.hardware_interface)}")
            self.workflow_executor = None

    # ============ 统一的设备操作接口 ============
    
    def call_device_method(self, method: str, *args, **kwargs) -> Any:
        """调用设备方法的统一接口"""
        # 1. 代理模式：通过协议节点转发
        if isinstance(self.hardware_interface, str) and self.hardware_interface.startswith("proxy:"):
            if not self._protocol_node:
                raise RuntimeError("代理模式需要设置protocol_node")
            
            device_id = self.hardware_interface[6:]  # 移除 "proxy:" 前缀
            return self._protocol_node.call_device_method(device_id, method, *args, **kwargs)
        
        # 2. 直接模式：直接调用硬件接口方法
        elif self.hardware_interface and hasattr(self.hardware_interface, method):
            return getattr(self.hardware_interface, method)(*args, **kwargs)
        
        else:
            raise AttributeError(f"硬件接口不支持方法: {method}")

    def get_device_status(self) -> Dict[str, Any]:
        """获取设备状态"""
        try:
            return self.call_device_method('get_status')
        except AttributeError:
            # 如果设备不支持get_status方法，返回基础状态
            return {
                "status": "unknown",
                "interface_type": type(self.hardware_interface).__name__,
                "timestamp": time.time()
            }

    def is_device_available(self) -> bool:
        """检查设备是否可用"""
        try:
            self.get_device_status()
            return True
        except:
            return False

    # ============ 工作流控制接口 ============

    def execute_workflow(self, workflow_name: str, parameters: Dict[str, Any]) -> bool:
        """执行工作流 - 委托给工作流执行器"""
        if not self.workflow_executor:
            logger.error(f"工作站 {self.device_id} 工作流执行器未初始化")
            return False
        
        try:
            # 设置工作流状态
            self.current_workflow_status = WorkflowStatus.INITIALIZING
            self.workflow_parameters = parameters
            self.workflow_start_time = time.time()
            
            # 委托给工作流执行器
            success = self.workflow_executor.execute_workflow(workflow_name, parameters)
            
            if success:
                self.current_workflow_status = WorkflowStatus.RUNNING
                logger.info(f"工作站 {self.device_id} 工作流 {workflow_name} 启动成功")
            else:
                self.current_workflow_status = WorkflowStatus.ERROR
                logger.error(f"工作站 {self.device_id} 工作流 {workflow_name} 启动失败")
            
            return success
            
        except Exception as e:
            self.current_workflow_status = WorkflowStatus.ERROR
            logger.error(f"工作站 {self.device_id} 执行工作流失败: {e}")
            return False

    def start_workflow(self, workflow_type: str, parameters: Dict[str, Any] = None) -> bool:
        """启动工作流 - 兼容旧接口"""
        return self.execute_workflow(workflow_type, parameters or {})

    def stop_workflow(self, emergency: bool = False) -> bool:
        """停止工作流"""
        if not self.workflow_executor:
            logger.warning(f"工作站 {self.device_id} 工作流执行器未初始化")
            return True
        
        try:
            if self.current_workflow_status in [WorkflowStatus.IDLE, WorkflowStatus.STOPPED]:
                logger.warning(f"工作站 {self.device_id} 没有正在运行的工作流")
                return True
            
            self.current_workflow_status = WorkflowStatus.STOPPING
            
            # 委托给工作流执行器
            success = self.workflow_executor.stop_workflow(emergency)
            
            if success:
                self.current_workflow_status = WorkflowStatus.STOPPED
                logger.info(f"工作站 {self.device_id} 工作流停止成功 (紧急: {emergency})")
            else:
                self.current_workflow_status = WorkflowStatus.ERROR
                logger.error(f"工作站 {self.device_id} 工作流停止失败")
            
            return success
            
        except Exception as e:
            self.current_workflow_status = WorkflowStatus.ERROR
            logger.error(f"工作站 {self.device_id} 停止工作流失败: {e}")
            return False

    # ============ 状态属性 ============
    
    @property
    def workflow_status(self) -> WorkflowStatus:
        """获取当前工作流状态"""
        return self.current_workflow_status

    @property
    def is_busy(self) -> bool:
        """检查工作站是否忙碌"""
        return self.current_workflow_status in [
            WorkflowStatus.INITIALIZING,
            WorkflowStatus.RUNNING,
            WorkflowStatus.STOPPING
        ]

    @property
    def workflow_runtime(self) -> float:
        """获取工作流运行时间（秒）"""
        if self.workflow_start_time is None:
            return 0.0
        return time.time() - self.workflow_start_time

    @property
    def error_count(self) -> int:
        """获取错误计数"""
        return len(self.error_history)

    @property
    def last_error(self) -> Optional[Dict[str, Any]]:
        """获取最后一个错误"""
        return self.error_history[-1] if self.error_history else None

    # ============ 抽象方法 - 子类必须实现 ============
    
    @abstractmethod
    def _create_material_management_module(self) -> MaterialManagementBase:
        """创建物料管理模块 - 子类必须实现"""
        pass

    @abstractmethod
    def _register_supported_workflows(self):
        """注册支持的工作流 - 子类必须实现"""
        pass

    # ============ HTTP服务管理 ============

    def _start_http_service(self):
        """启动HTTP报送接收服务"""
        try:
            if not self.http_service_config.get("enabled", True):
                logger.info(f"工作站 {self.device_id} HTTP报送接收服务已禁用")
                return
            
            host = self.http_service_config.get("host", "127.0.0.1")
            port = self.http_service_config.get("port", 8081)
            
            self.http_service = WorkstationHTTPService(
                workstation_handler=self,
                host=host,
                port=port
            )
            
            logger.info(f"工作站 {self.device_id} HTTP报送接收服务启动成功: {host}:{port}")
            
        except Exception as e:
            logger.error(f"工作站 {self.device_id} 启动HTTP报送接收服务失败: {e}")
            self.http_service = None

    def _stop_http_service(self):
        """停止HTTP报送接收服务"""
        try:
            if self.http_service:
                self.http_service.stop()
                self.http_service = None
                logger.info(f"工作站 {self.device_id} HTTP报送接收服务已停止")
        except Exception as e:
            logger.error(f"工作站 {self.device_id} 停止HTTP报送接收服务失败: {e}")

    # ============ 报送处理方法 ============

    def process_material_change_report(self, report) -> Dict[str, Any]:
        """处理物料变更报送"""
        try:
            logger.info(f"处理物料变更报送: {report.workstation_id} -> {report.resource_id} ({report.change_type})")
            
            result = {
                'processed': True,
                'resource_id': report.resource_id,
                'change_type': report.change_type,
                'timestamp': time.time()
            }
            
            # 更新本地物料管理系统
            if hasattr(self, 'material_management'):
                try:
                    self.material_management.sync_external_material_change(report)
                except Exception as e:
                    logger.warning(f"同步物料变更到本地管理系统失败: {e}")
            
            return result
            
        except Exception as e:
            logger.error(f"处理物料变更报送失败: {e}")
            return {'processed': False, 'error': str(e)}

    def process_step_finish_report(self, request: WorkstationReportRequest) -> Dict[str, Any]:
        """处理步骤完成报送（统一LIMS协议规范）"""
        try:
            data = request.data
            logger.info(f"处理步骤完成报送: {data['orderCode']} - {data['stepName']}")
            
            result = {
                'processed': True,
                'order_code': data['orderCode'],
                'step_id': data['stepId'],
                'timestamp': time.time()
            }
            
            return result
            
        except Exception as e:
            logger.error(f"处理步骤完成报送失败: {e}")
            return {'processed': False, 'error': str(e)}

    def process_sample_finish_report(self, request: WorkstationReportRequest) -> Dict[str, Any]:
        """处理样品完成报送"""
        try:
            data = request.data
            logger.info(f"处理样品完成报送: {data['sampleId']}")
            
            result = {
                'processed': True,
                'sample_id': data['sampleId'],
                'timestamp': time.time()
            }
            
            return result
            
        except Exception as e:
            logger.error(f"处理样品完成报送失败: {e}")
            return {'processed': False, 'error': str(e)}

    def process_order_finish_report(self, request: WorkstationReportRequest, used_materials: List[MaterialUsage]) -> Dict[str, Any]:
        """处理订单完成报送"""
        try:
            data = request.data
            logger.info(f"处理订单完成报送: {data['orderCode']}")
            
            result = {
                'processed': True,
                'order_code': data['orderCode'],
                'used_materials': len(used_materials),
                'timestamp': time.time()
            }
            
            return result
            
        except Exception as e:
            logger.error(f"处理订单完成报送失败: {e}")
            return {'processed': False, 'error': str(e)}

    def handle_external_error(self, error_request):
        """处理外部错误报告"""
        try:
            logger.error(f"收到外部错误报告: {error_request}")
            
            # 记录错误
            error_record = {
                'timestamp': time.time(),
                'error_type': error_request.get('error_type', 'unknown'),
                'error_message': error_request.get('message', ''),
                'source': error_request.get('source', 'external'),
                'context': error_request.get('context', {})
            }
            
            self.error_history.append(error_record)
            
            # 处理紧急停止情况
            if error_request.get('emergency_stop', False):
                self._trigger_emergency_stop(error_record['error_message'])
            
            return {'processed': True, 'error_id': len(self.error_history)}
            
        except Exception as e:
            logger.error(f"处理外部错误失败: {e}")
            return {'processed': False, 'error': str(e)}

    def _trigger_emergency_stop(self, reason: str):
        """触发紧急停止"""
        logger.critical(f"触发紧急停止: {reason}")
        self.stop_workflow(emergency=True)

    def __del__(self):
        """清理资源"""
        try:
            self._stop_http_service()
        except:
            pass