import asyncio
import logging
import json
import websockets
from typing import Dict, Any, Optional
from config.logger import setup_logging
from core.services.connection_service import ConnectionService
from core.transport.websocket_transport import WebSocketTransport
from config.config_loader import get_config_from_api_async
from core.utils.util import check_vad_update, check_asr_update
from core.auth import AuthMiddleware, AuthenticationError
from core.utils.config_validation import validate_config_components
from core.providers.asr.shared_asr_manager import SharedASRManager


class SuppressInvalidHandshakeFilter(logging.Filter):
    """过滤掉无效握手错误日志（如HTTPS访问WS端口）"""

    def filter(self, record):
        msg = record.getMessage()
        suppress_keywords = [
            "opening handshake failed",
            "did not receive a valid HTTP request",
            "connection closed while reading HTTP request",
            "line without CRLF",
        ]
        return not any(keyword in msg for keyword in suppress_keywords)


def _setup_websockets_logger():
    """配置 websockets 相关的所有 logger，过滤无效握手错误"""
    filter_instance = SuppressInvalidHandshakeFilter()
    for logger_name in ["websockets", "websockets.server", "websockets.client"]:
        ws_logger = logging.getLogger(logger_name)
        ws_logger.addFilter(filter_instance)


_setup_websockets_logger()


logger = setup_logging()
TAG = __name__


class NewWebSocketServer:
    """
    新的WebSocket服务器：使用新架构替代旧的ConnectionHandler
    集成ConnectionService、MessageRouter和新的Processor架构
    """

    def __init__(self, config: Dict[str, Any]):
        self.config = config
        self.logger = setup_logging()
        self.config_lock = asyncio.Lock()
        self.last_update_error = None

        # 创建连接服务
        self.connection_service = ConnectionService(config)
        self.connection_service.server = self

        # 活跃连接管理
        self.active_connections = set()

        # 认证中间件
        self.auth_middleware = AuthMiddleware(config)

        # 服务器实例和控制
        self._server = None
        self._stop_event = asyncio.Event()
        self._started_event = asyncio.Event()
        self._is_running = False

    async def start(self):
        """启动WebSocket服务器"""
        server_config = self.config["server"]
        host = server_config.get("ip", "0.0.0.0")
        port = int(server_config.get("port", 8000))

        logger.bind(tag=TAG).info(f"启动新架构WebSocket服务器: {host}:{port}")

        self._stop_event.clear()
        self._started_event.clear()

        try:
            self._server = await websockets.serve(
                self._handle_connection,
                host,
                port,
                process_request=self._http_response
            )
            self._is_running = True
            self._started_event.set()
            logger.bind(tag=TAG).info("WebSocket服务器启动成功")

            # 等待停止信号
            await self._stop_event.wait()

        except Exception as e:
            logger.bind(tag=TAG).error(f"WebSocket服务器启动失败: {e}")
            raise
        finally:
            self._is_running = False
            self._started_event.clear()

    async def stop(self):
        """停止WebSocket服务器"""
        if not self._is_running:
            logger.bind(tag=TAG).debug("WebSocket服务器未运行，无需停止")
            return

        logger.bind(tag=TAG).info("正在停止WebSocket服务器...")

        # 关闭所有活跃连接
        for transport in list(self.active_connections):
            try:
                await transport.close()
            except Exception as e:
                logger.bind(tag=TAG).error(f"关闭连接失败: {e}")
        self.active_connections.clear()

        # 关闭服务器
        if self._server:
            self._server.close()
            try:
                await asyncio.wait_for(self._server.wait_closed(), timeout=5.0)
            except asyncio.TimeoutError:
                logger.bind(tag=TAG).warning("等待服务器关闭超时")
            self._server = None

        # 发送停止信号
        self._stop_event.set()
        self._is_running = False
        self._started_event.clear()

        logger.bind(tag=TAG).info("WebSocket服务器已停止")

    async def _handle_connection(self, websocket):
        """处理新连接 - 使用新架构"""
        # 提取连接头信息
        headers = self._extract_headers(websocket)
        device_id = headers.get('device-id')

        # 如果没有 device-id，提示并关闭连接
        if not device_id:
            await websocket.send("端口正常，如需测试连接，请使用test_page.html")
            await websocket.close()
            return

        # 连接时认证
        try:
            await self._handle_auth(headers)
        except AuthenticationError as e:
            logger.bind(tag=TAG).warning(f"认证失败: {e}")
            await websocket.send("认证失败")
            await websocket.close()
            return

        # 创建WebSocket传输层
        try:
            protocol_version = int(headers.get('protocol-version', 1) or 1)
        except (TypeError, ValueError):
            protocol_version = 1
        transport = WebSocketTransport(
            websocket,
            from_mqtt_gateway=headers.get('from_mqtt_gateway') == 'true',
            protocol_version=protocol_version,
        )

        # 记录活跃连接
        self.active_connections.add(transport)

        try:
            logger.bind(tag=TAG).info(
                f"新连接建立: {device_id} from {headers.get('x-real-ip', 'unknown')}"
            )

            # 使用ConnectionService处理连接
            await self.connection_service.handle_connection(transport, headers)

        except websockets.exceptions.ConnectionClosed:
            logger.bind(tag=TAG).info("WebSocket连接正常关闭")
        except Exception as e:
            logger.bind(tag=TAG).error(f"处理WebSocket连接时出错: {e}", exc_info=True)
            # 将错误反馈给管理端，避免长时间等待
            try:
                if hasattr(websocket, "closed") and not websocket.closed:
                    await websocket.send(
                        json.dumps(
                            {
                                "type": "server",
                                "status": "error",
                                "message": f"Server error: {e}",
                                "content": {"action": "unknown"},
                            }
                        )
                    )
            except Exception:
                pass
        finally:
            # 确保从活动连接集合中移除
            self.active_connections.discard(transport)

            # 强制关闭连接（如果还没有关闭的话）
            try:
                if hasattr(websocket, "closed") and not websocket.closed:
                    await websocket.close()
                elif hasattr(websocket, "state") and websocket.state.name != "CLOSED":
                    await websocket.close()
            except Exception as close_error:
                logger.bind(tag=TAG).error(f"强制关闭WebSocket连接时出错: {close_error}")

    async def _handle_auth(self, headers: Dict[str, str]):
        """
        连接时认证

        Args:
            headers: HTTP 请求头

        Raises:
            AuthenticationError: 认证失败时抛出
        """
        await self.auth_middleware.authenticate_async(headers)

    def _extract_headers(self, websocket) -> Dict[str, str]:
        """
        从WebSocket请求中提取头信息

        支持从以下来源提取信息：
        1. HTTP 请求头
        2. URL 查询参数（device-id, client-id, authorization）
        3. 路径参数（如 ?from=mqtt_gateway）
        """
        headers = {}

        # 1. 提取 HTTP 请求头
        if hasattr(websocket, 'request') and hasattr(websocket.request, 'headers'):
            for name, value in websocket.request.headers.items():
                headers[name.lower()] = value
        elif hasattr(websocket, 'request_headers'):
            for name, value in websocket.request_headers.items():
                headers[name.lower()] = value

        # 2. 提取路径参数（如果有的话）
        request_path = None
        if hasattr(websocket, 'request') and hasattr(websocket.request, 'path'):
            request_path = websocket.request.path
        elif hasattr(websocket, 'path'):
            request_path = websocket.path

        if request_path:
            from urllib.parse import urlparse, parse_qs
            parsed = urlparse(request_path)
            query_params = parse_qs(parsed.query)

            # 处理关键参数：device-id, client-id, authorization
            key_params = ['device-id', 'client-id', 'authorization']
            for key in key_params:
                if key in query_params and query_params[key]:
                    # URL 参数优先级低于 header
                    if key not in headers or not headers[key]:
                        headers[key] = query_params[key][0]

            # 处理其他参数
            for key, values in query_params.items():
                if values and key not in headers:
                    headers[key] = values[0]

            # 检查是否来自 MQTT 网关
            if request_path.endswith("?from=mqtt_gateway") or "from=mqtt_gateway" in request_path:
                headers['from_mqtt_gateway'] = 'true'

        # 3. 提取远程地址
        if hasattr(websocket, 'remote_address'):
            # 如果 headers 中没有 x-real-ip，使用 remote_address
            if 'x-real-ip' not in headers:
                headers['x-real-ip'] = websocket.remote_address[0]

        return headers

    async def _http_response(self, websocket, request_headers):
        """处理HTTP请求"""
        # 检查是否为 WebSocket 升级请求
        if request_headers.headers.get("connection", "").lower() == "upgrade":
            # 如果是 WebSocket 请求，返回 None 允许握手继续
            return None
        else:
            # 如果是普通 HTTP 请求，返回服务器状态
            return websocket.respond(200, "New Architecture WebSocket Server is running\n")

    async def apply_config(self, new_config: Dict[str, Any]) -> bool:
        """Apply a facade-validated config to future WebSocket connections."""
        self.config = new_config
        self.connection_service = ConnectionService(new_config)
        self.connection_service.server = getattr(self, "management_owner", self)
        self.auth_middleware = AuthMiddleware(new_config)
        return True

    async def update_config(
        self, new_config: Optional[Dict[str, Any]] = None
    ) -> bool:
        """
        更新服务器配置并重新初始化组件

        Returns:
            bool: 更新是否成功
        """
        try:
            async with self.config_lock:
                logger.bind(tag=TAG).info("开始更新服务器配置")
                self.last_update_error = None
                old_config = self.config
                old_connection_service = self.connection_service
                old_auth_middleware = self.auth_middleware

                # 管理命令可自行拉取配置；多协议管理器则直接传入已合并配置。
                if new_config is None:
                    new_config = await get_config_from_api_async(self.config)
                    if new_config is None:
                        logger.bind(tag=TAG).error("获取新配置失败")
                        self.last_update_error = "获取新配置失败"
                        return False

                logger.bind(tag=TAG).info("获取新配置成功")

                new_shared_manager = None
                reuse_manager = False

                # 校验新配置（预初始化组件以发现配置错误）
                ok, error_msg = await validate_config_components(new_config, logger)
                if not ok:
                    logger.bind(tag=TAG).error(f"配置校验失败: {error_msg}")
                    self.last_update_error = f"配置校验失败: {error_msg}"
                    return False

                # 准备共享 ASR 管理器（本地模型走共享预加载）
                old_shared_manager = old_config.get("_shared_asr_manager")
                selected_asr = new_config.get("selected_module", {}).get("ASR")
                if selected_asr:
                    asr_config = new_config.get("ASR", {}).get(selected_asr, {})
                    asr_type = asr_config.get("type", selected_asr)
                    if SharedASRManager.is_local_model_type(asr_type):
                        if (
                            old_shared_manager
                            and getattr(old_shared_manager, "asr_type", None) == asr_type
                            and old_shared_manager.is_ready()
                        ):
                            new_shared_manager = old_shared_manager
                            reuse_manager = True
                        else:
                            new_shared_manager = SharedASRManager(new_config, asr_type)
                            await new_shared_manager.initialize()
                # 非本地模型时不立即关闭旧共享管理器，待更新成功后统一处理

                # 检查 VAD 和 ASR 类型是否需要更新
                update_vad = check_vad_update(self.config, new_config)
                update_asr = check_asr_update(self.config, new_config)
                logger.bind(tag=TAG).info(
                    f"检查VAD和ASR类型是否需要更新: VAD={update_vad}, ASR={update_asr}"
                )

                # 检查配置是否有重大变化
                changed_configs = self._get_changed_configs(self.config, new_config)

                # 更新配置
                self.config = new_config
                if new_shared_manager:
                    self.config["_shared_asr_manager"] = new_shared_manager
                elif "_shared_asr_manager" in self.config:
                    del self.config["_shared_asr_manager"]

                # 根据变化类型进行更新
                if changed_configs:
                    logger.bind(tag=TAG).info(f"配置项变化: {', '.join(changed_configs)}")

                # 重新创建连接服务，使用新配置
                # 注意：已建立的连接会继续使用旧配置，只有新连接使用新配置
                self.connection_service = ConnectionService(new_config)
                self.connection_service.server = self

                # 如果 ASR 配置变化且复用旧共享管理器，提示重启
                if update_asr and reuse_manager:
                    logger.bind(tag=TAG).warning(
                        "ASR 配置已变化，但仍复用已有共享 ASR 管理器，建议重启服务"
                    )
                else:
                    # 即使没有重大变化，也更新 ConnectionService 的配置引用
                    self.connection_service.config = new_config
                    self.connection_service.server = self

                # 更新认证中间件
                self.auth_middleware = AuthMiddleware(new_config)

                # 更新成功后再关闭旧共享管理器（避免失败回滚时不可用）
                if old_shared_manager and old_shared_manager is not new_shared_manager:
                    await old_shared_manager.shutdown()

                logger.bind(tag=TAG).info("配置更新任务执行完毕")
                return True

        except Exception as e:
            logger.bind(tag=TAG).error(f"更新服务器配置失败: {str(e)}", exc_info=True)
            self.last_update_error = f"更新服务器配置失败: {str(e)}"
            try:
                if new_shared_manager and not reuse_manager:
                    await new_shared_manager.shutdown()
                self.config = old_config
                self.connection_service = old_connection_service
                self.auth_middleware = old_auth_middleware
            except Exception:
                pass
            return False

    def get_last_update_error(self) -> str:
        return self.last_update_error or ""

    def _get_changed_configs(self, old_config: Dict[str, Any], new_config: Dict[str, Any]) -> list:
        """
        获取变化的配置项列表

        Returns:
            list: 变化的配置项名称列表
        """
        changed = []
        key_configs = [
            "selected_module",
            "VAD",
            "ASR",
            "LLM",
            "TTS",
            "Memory",
            "Intent"
        ]

        for key in key_configs:
            old_value = old_config.get(key)
            new_value = new_config.get(key)
            if old_value != new_value:
                changed.append(key)

        return changed

    def get_active_connections_count(self) -> int:
        """获取活跃连接数"""
        return len(self.active_connections)

    def get_server_status(self) -> Dict[str, Any]:
        """获取服务器状态"""
        return {
            "active_connections": self.get_active_connections_count(),
            "server_type": "new_architecture",
            "processors": self.connection_service.message_router.list_processors()
        }