#!/usr/bin/env python3
"""
AudioPlayQueue - 音频播放队列管理
支持流式播放、打断、队列管理
"""

import asyncio
import logging
import io
import wave
from typing import Optional, Deque
from collections import deque

from components.base import BaseComponent, ComponentConfig, ComponentState

logger = logging.getLogger(__name__)


class AudioPlayQueue(BaseComponent):
    """音频播放队列管理器"""

    def __init__(self, config, event_bus):
        super().__init__(
            config=ComponentConfig(
                name="audio_play_queue",
                enabled=config.get("audio", {}).get("enabled", True),
                priority=2,
                dependencies=[]
            ),
            event_bus=event_bus
        )

        self.audio_config = config.get("audio", {})
        self._queue: Deque[bytes] = deque()
        self._playing = False
        self._interrupted = False
        self._current_task: Optional[asyncio.Task] = None

    async def _do_initialize(self):
        """初始化音频队列"""
        logger.info("🎵 初始化音频播放队列")
        self._is_ready = True

    async def _run_loop(self):
        """主循环"""
        logger.info("🔄 音频队列主循环启动")

        while self.state == ComponentState.RUNNING:
            try:
                if self._queue and not self._playing and not self._interrupted:
                    # 开始播放下一个音频
                    await self._play_next()
                elif self._interrupted:
                    logger.info("⏹️ 音频播放被打断")
                    self._interrupted = False
                    self._playing = False
                    self._queue.clear()
                else:
                    await asyncio.sleep(0.05)
            except asyncio.CancelledError:
                break
            except Exception as e:
                logger.error(f"❌ 音频队列错误: {e}")
                await asyncio.sleep(0.1)

    async def play(self, audio_data: bytes) -> bool:
        """
        添加音频到队列

        Args:
            audio_data: 音频数据 (WAV bytes)

        Returns:
            bool: 是否成功添加
        """
        if not audio_data or len(audio_data) < 100:
            return False

        self._queue.append(audio_data)
        logger.info(f"🎵 添加到队列，队列大小: {len(self._queue)}")
        return True

    async def stop(self) -> bool:
        """停止当前播放"""
        logger.info("⏹️ 停止音频播放")
        self._playing = False
        if self._current_task and not self._current_task.done():
            self._current_task.cancel()
            try:
                await self._current_task
            except asyncio.CancelledError:
                pass
        return True

    async def interrupt(self) -> bool:
        """
        打断当前播放（Barge-in）

        Returns:
            bool: 是否成功打断
        """
        logger.info("⚡ 打断音频播放")
        self._interrupted = True
        self._playing = False  # 立即停止播放标志
        
        if self._current_task and not self._current_task.done():
            self._current_task.cancel()
            try:
                await self._current_task
            except asyncio.CancelledError:
                pass
        
        # 清空队列
        self._queue.clear()
        
        logger.info("✅ 打断完成，队列已清空")
        return True

    async def clear(self) -> bool:
        """清空队列"""
        self._queue.clear()
        logger.info("🧹 清空音频队列")
        return True

    async def _play_next(self):
        """播放队列中的下一个音频"""
        if not self._queue:
            return

        self._playing = True
        audio_data = self._queue.popleft()

        try:
            # TODO: 实际播放音频
            # 这里使用 asyncio.sleep 模拟播放时间
            duration = len(audio_data) / (16000 * 2)  # 16kHz, int16
            logger.info(f"🔊 播放音频: {duration:.1f}s")
            await asyncio.sleep(min(duration, 5.0))  # 最多播放5秒
            self._playing = False
        except Exception as e:
            logger.error(f"❌ 播放失败: {e}")
            self._playing = False

    def get_queue_size(self) -> int:
        """获取队列大小"""
        return len(self._queue)

    def is_playing(self) -> bool:
        """是否正在播放"""
        return self._playing

    def health_check(self):
        return {
            "status": "healthy" if self._is_ready else "unhealthy",
            "queue_size": len(self._queue),
            "is_playing": self._playing,
            "interrupted": self._interrupted
        }


def create_audio_play_queue(config, event_bus) -> BaseComponent:
    """创建音频播放队列"""
    return AudioPlayQueue(config, event_bus)