from __future__ import annotations

import asyncio
import base64
import json
import logging
import math
import time
from dataclasses import dataclass
from typing import Optional, Dict

import numpy as np
from dotenv import load_dotenv
from livekit import agents, rtc
from livekit.agents import AutoSubscribe
from websockets import connect as ws_connect
from websockets.exceptions import ConnectionClosed, WebSocketException

# ---------------------------------------------------------------------
# 0. 環境/ロギング
# ---------------------------------------------------------------------
load_dotenv()

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("agent-mixer")

# 折り畳み: websocketsの冗長ログを抑制
logging.getLogger("websockets.client").setLevel(logging.WARNING)
logging.getLogger("websockets.server").setLevel(logging.WARNING)
logging.getLogger("websockets").setLevel(logging.WARNING)

# ---------------------------------------------------------------------
# 1. 定数
# ---------------------------------------------------------------------
FRAME_MS = 10
SR = 48000
SAMPLES = int(SR * FRAME_MS / 1000)  # 480

WS_INITIAL_RETRY_DELAY = 1.0  # seconds
WS_MAX_RETRY_DELAY = 10.0     # seconds
WS_BACKOFF_MULTIPLIER = 2.0

# ---------------------------------------------------------------------
# 2. WebSocket マネージャ（リトライ付き）
# ---------------------------------------------------------------------
class WebSocketManager:
    def __init__(self, url: str):
        self.url = url
        self.ws: Optional = None
        self.is_connected = False
        self.retry_delay = WS_INITIAL_RETRY_DELAY
        self._send_lock = asyncio.Lock()

    async def connect_with_retry(self):
        while True:
            try:
                logger.info(f"Attempting to connect to WebSocket: {self.url}")
                self.ws = await ws_connect(self.url, ping_interval=None)
                self.is_connected = True
                self.retry_delay = WS_INITIAL_RETRY_DELAY
                logger.info("WebSocket connection established successfully")
                return self.ws
            except Exception as e:
                logger.error(f"WebSocket connection failed: {e}")
                logger.info(f"Retrying in {self.retry_delay} seconds...")
                await asyncio.sleep(self.retry_delay)
                self.retry_delay = min(self.retry_delay * WS_BACKOFF_MULTIPLIER, WS_MAX_RETRY_DELAY)

    async def send_with_retry(self, data: str):
        while True:
            try:
                if not self.is_connected or self.ws is None:
                    logger.warning("WebSocket not connected, attempting to reconnect...")
                    await self.connect_with_retry()
                async with self._send_lock:
                    await self.ws.send(data)
                return
            except (ConnectionClosed, WebSocketException) as e:
                logger.error(f"WebSocket send error: {e}")
                self.is_connected = False
                self.ws = None
                logger.info("Attempting to reconnect...")
                await self.connect_with_retry()
            except Exception as e:
                logger.error(f"Unexpected error during WebSocket send: {e}")
                await asyncio.sleep(1)

# ---------------------------------------------------------------------
# 3. ミキサー実装
# ---------------------------------------------------------------------
class SourceBuffer:
    """各参加者の10msフレームを時刻キーで保持する簡易バッファ"""
    def __init__(self, max_lag_frames: int = 6):  # ~60ms
        self.q: Dict[int, np.ndarray] = {}
        self.max_lag = max_lag_frames

    def push(self, t: int, arr: np.ndarray):
        self.q[t] = arr

    def pop_for_time(self, t: int) -> np.ndarray:
        frm = self.q.pop(t, None)
        if frm is None:
            return np.zeros(SAMPLES, dtype=np.float32)
        return frm

    def gc(self, current_t: int):
        cutoff = current_t - self.max_lag
        removed_count = 0
        for k in list(self.q.keys()):
            if k < cutoff:
                self.q.pop(k, None)
                removed_count += 1

        # 緊急時：バッファが異常に大きい場合は強制クリア
        if len(self.q) > 100:  # 1秒以上のバッファ
            # 最新の10フレームのみ保持
            latest_keys = sorted(self.q.keys())[-10:]
            new_q = {k: self.q[k] for k in latest_keys}
            removed_count += len(self.q) - len(new_q)
            self.q = new_q


class Mixer:
    """
    10msごとに全参加者のフレームを集めて加算ミックスし、int16 bytesをコールバックへ渡す。
    - ヘッドルーム: -6dB
    - 人数スケーリング: 1/sqrt(N_active)
    - ソフトリミッタ: tanh
    """
    def __init__(self, on_mixed_frame):
        self.sources: Dict[str, SourceBuffer] = {}
        self.t: Optional[int] = None
        self.running = False
        self.on_mixed_frame = on_mixed_frame  # async callable(int16_bytes)
        self.headroom = 10 ** (-6 / 20)  # -6dB
        self.use_limiter = True

    def add_source(self, sid: str):
        if sid not in self.sources:
            self.sources[sid] = SourceBuffer()

    def remove_source(self, sid: str):
        self.sources.pop(sid, None)

    def _soft_limiter(self, x: np.ndarray) -> np.ndarray:
        return np.tanh(x)

    def _frame_index(self, ts_ns: int) -> int:
        # 10msグリッドに丸めたフレーム番号
        return int((ts_ns // 1_000_000) // FRAME_MS)

    def push_frame(self, sid: str, frame_ts_ns: int, pcm_bytes: bytes, channels: int = 1):
        """LiveKitのAudioFrameを float32 mono(480) に整形して投入"""
        if sid not in self.sources:
            self.add_source(sid)

        # int16 PCM -> float32 [-1..1]
        x = np.frombuffer(pcm_bytes, dtype=np.int16).astype(np.float32) / 32768.0

        # 10ms(480サンプル)に長さを合わせる
        if x.shape[0] != SAMPLES:
            y = np.zeros(SAMPLES, dtype=np.float32)
            n = min(SAMPLES, x.shape[0])
            y[:n] = x[:n]
            x = y

        t = self._frame_index(frame_ts_ns)
        if self.t is None:
            self.t = t  # 初回のみ基準化
        self.sources[sid].push(t, x)

    async def run(self):
        self.running = True
        tick = FRAME_MS / 1000
        if self.t is None:
            self.t = 0
        while self.running:
            active = 0
            acc = np.zeros(SAMPLES, dtype=np.float32)

            # 全ソースから最新の利用可能時刻を取得
            latest_time = None
            for sb in self.sources.values():
                if sb.q:
                    sb_latest = max(sb.q.keys())
                    if latest_time is None or sb_latest > latest_time:
                        latest_time = sb_latest

            # 最新時刻が見つかった場合、それに同期
            if latest_time is not None:
                if self.t is None:
                    self.t = min(
                        min(sb.q.keys()) for sb in self.sources.values() if sb.q
                    )
                elif latest_time - self.t > 100:
                    self.t = latest_time - 50
                else:
                    # ここでは self.t を進めず、while ループ末尾の self.t += 1 で順次処理
                    pass

            # 現在時刻でフレームを処理
            if self.t is not None:
                for sb in self.sources.values():
                    frm = sb.pop_for_time(self.t)
                    if frm.any():
                        active += 1
                    acc += frm

            if active > 0:
                acc *= self.headroom * (1.0 / math.sqrt(active))
                if self.use_limiter:
                    acc = self._soft_limiter(acc)

            # float32 -> int16 bytes
            out = np.clip(acc, -1.0, 1.0)
            out = (out * 32767.0).astype(np.int16).tobytes()

            await self.on_mixed_frame(out)

            # GCを実行（重要：現在の時刻で古いフレームを削除）
            if self.t is not None:
                for sb in self.sources.values():
                    sb.gc(self.t)

            # 次のフレームへ
            if self.t is not None:
                self.t += 1

            await asyncio.sleep(tick)

# ---------------------------------------------------------------------
# 4. Agent エントリポイント
# ---------------------------------------------------------------------
async def entrypoint(ctx: agents.JobContext):
    """
    metadata(JSON文字列) 例:
    {
      "output_url": "wss://example.com/ws",
      "room_name": "my-room"
    }
    """
    # メタデータ処理
    metadata_str = ctx.job.metadata
    logger.info(f"Job metadata (raw string): {metadata_str}")

    output_url = None
    room_name = None
    private_ip = None
    if metadata_str:
        try:
            data = json.loads(metadata_str)
            output_url = data.get("output_url")
            room_name = data.get("room_name")
            private_ip = data.get("private_ip")
        except json.JSONDecodeError:
            logger.error(f"Failed to parse metadata JSON: {metadata_str}")
            return

    if not output_url:
        logger.error("No output_url provided in metadata")
        return

    logger.info(f"Output URL: {output_url}")
    logger.info(f"Private IP: {private_ip}")

    # WebSocket接続準備
    ws_manager = WebSocketManager(output_url)
    await ws_manager.connect_with_retry()

    # Private IP用のWebSocket接続準備（存在する場合）
    private_ws_manager = None
    if private_ip and room_name:
        private_ws_url = f"ws://{private_ip}:5000/livekit/audio?streamKey={room_name}"
        logger.info(f"Private WebSocket URL: {private_ws_url}")
        private_ws_manager = WebSocketManager(private_ws_url)
        await private_ws_manager.connect_with_retry()

    # ミックス済みフレーム送信のコールバック
    async def send_mixed_frame(int16_bytes: bytes):
        # バイナリ送信が可能なら ws.send(int16_bytes) を推奨。
        # 互換のためここではJSON+Base64を継続。
        b64 = base64.b64encode(int16_bytes).decode("utf-8")
        payload = {
            "room_name": room_name,
            "data": b64,
            "type": "mixed"
        }
        json_payload = json.dumps(payload)
        await ws_manager.send_with_retry(json_payload)
        # Private IP用のWebSocketにも送信
        if private_ws_manager:
            await private_ws_manager.send_with_retry(json_payload)

    # 個別音声フレーム送信の関数
    async def send_individual_frame(participant_id: str, frame_data: bytes):
        """個別参加者の音声フレームを送信"""
        b64 = base64.b64encode(frame_data).decode("utf-8")
        payload = {
            "room_name": room_name,
            "participant_id": participant_id,
            "data": b64,
            "type": "individual"
        }
        await ws_manager.send_with_retry(json.dumps(payload))

    # ミキサー起動
    mixer = Mixer(on_mixed_frame=send_mixed_frame)
    asyncio.create_task(mixer.run())

    # ルーム接続（リモートのオーディオのみ自動購読）
    await ctx.connect(auto_subscribe=AutoSubscribe.AUDIO_ONLY)

    # 新規購読時：フレームをミキサーに投入
    @ctx.room.on("track_subscribed")
    def _on_track_subscribed(
        track: rtc.Track,
        pub: rtc.TrackPublication,
        participant: rtc.RemoteParticipant,
    ):
        if not isinstance(participant, rtc.RemoteParticipant):
            return
        if track.kind != rtc.TrackKind.KIND_AUDIO:
            return
        # 例: Ingressのシステムトラックなどを除外したい場合
        if participant.identity.startswith("ingress"):
            logger.info(f"Ignoring track from Ingress participant: {participant.identity}")
            return

        sid = f"{participant.identity}:{pub.sid}"
        logger.info(f"[SUBSCRIBED] {sid} track_name={pub.name} muted={pub.muted}")

        async def _consume_audio():
            audio_stream = rtc.AudioStream(track)
            try:
                async for ev in audio_stream:
                    frame: rtc.AudioFrame = ev.frame
                    try:
                        # SDKの実装に合わせてフィールド名を確認してください
                        # ts_ns = getattr(frame, "timestamp_ns", int(time.time_ns()))
                        # ch = getattr(frame, "num_channels", 1)
                        ts_ns = int(time.time_ns())
                        ch = 1
                        pcm_bytes = frame.data  # int16 PCM bytes を想定

                        # ミキサーにフレームを投入（ミックス音声用）
                        mixer.push_frame(sid, ts_ns, pcm_bytes, channels=ch)

                        # 個別音声も同時に送信（agent.pyと同様の形式）
                        await send_individual_frame(participant.identity, pcm_bytes)

                    except Exception as e:
                        logger.error(f"Error processing audio frame for {sid}: {e}")
                        continue
            except Exception as e:
                logger.error(f"Error in audio stream processing for {sid}: {e}")
            finally:
                await audio_stream.aclose()

        asyncio.create_task(_consume_audio())

    # 解除時：ソース削除
    @ctx.room.on("track_unsubscribed")
    def _on_track_unsubscribed(
        track: rtc.Track,
        pub: rtc.TrackPublication,
        participant: rtc.RemoteParticipant,
    ):
        if track.kind != rtc.TrackKind.KIND_AUDIO:
            return
        sid = f"{participant.identity}:{pub.sid}"
        mixer.remove_source(sid)
        logger.info(f"[UNSUBSCRIBED] {sid}")

# ---------------------------------------------------------------------
# 5. 実行
# ---------------------------------------------------------------------
if __name__ == "__main__":
    agents.cli.run_app(
        agents.WorkerOptions(
            entrypoint_fnc=entrypoint,
            agent_name="test-agent",
            permissions=agents.WorkerPermissions(
                can_publish=False,
                can_subscribe=True,
                can_publish_data=False,
                hidden=True,
            )
        )
    )
