defmodule VoiceChat.MixProject do
  use Mix.Project

  def project do
    [
      app: :voice_chat,
      version: "0.1.0",
      elixir: "~> 1.15",
      start_permanent: Mix.env() == :prod,
      deps: deps()
    ]
  end

  def application do
    [
      extra_applications: [:logger],
      mod: {VoiceChat.Application, []}
    ]
  end

  defp deps do
    [
      {:bandit, "~> 1.6"},
      {:websock_adapter, "~> 0.5"},
      {:plug, "~> 1.16"},
      {:jason, "~> 1.4"}
    ]
  end
end

defmodule VoiceChat.Application do
  @moduledoc false
  use Application

  @impl true
  def start(_type, _args) do
    # 确保录音目录存在
    VoiceChat.recordings_dir() |> File.mkdir_p!()

    # 确保提示音（“好的”）存在，不存在则生成
    VoiceChat.PromptAudio.ensure!()

    children = [
      # 会话注册表：session_id -> ws 进程，进程退出自动清理
      {Registry, keys: :unique, name: VoiceChat.SessionRegistry},
      # HTTP + WebSocket 服务器
      {Bandit, plug: VoiceChat.Endpoint, port: VoiceChat.port()}
    ]

    opts = [strategy: :one_for_one, name: VoiceChat.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

defmodule VoiceChat.Endpoint do
  @moduledoc """
  HTTP 路由：静态调试页面 + WebSocket 升级接口 + 调试辅助接口。
  """

  use Plug.Router

  plug(Plug.Logger)

  plug(Plug.Static,
    at: "/",
    from: :voice_chat,
    only: ~w(index.html app.js app.css)
  )

  plug(:match)
  plug(:dispatch)

  get "/" do
    send_file(conn, 200, Application.app_dir(:voice_chat, "priv/static/index.html"))
  end

  get "/health" do
    send_resp(conn, 200, "ok")
  end

  get "/sessions" do
    sessions =
      VoiceChat.SessionRegistry
      |> Registry.select([{{:"$1", :"$2", :"$3"}, [], [{{:"$1", :"$2", :"$3"}}]}])
      |> Enum.map(fn {id, pid, meta} ->
        %{
          "session" => id,
          "ws_pid" => inspect(pid),
          # PID 不是 JSON 类型，编码前统一转成字符串，否则会话进行中该接口会 500
          "meta" =>
            Map.new(meta, fn
              {k, v} when is_pid(v) -> {k, inspect(v)}
              {k, v} -> {k, v}
            end)
        }
      end)

    conn
    |> put_resp_content_type("application/json")
    |> send_resp(200, Jason.encode!(sessions))
  end

  get "/ws" do
    conn = Plug.Conn.fetch_query_params(conn)

    try do
      conn
      |> WebSockAdapter.upgrade(
        VoiceChat.WSHandler,
        %{query_params: conn.query_params},
        timeout: 60_000,
        max_frame_size: 10_000_000
      )
      |> halt()
    rescue
      e in WebSockAdapter.UpgradeError ->
        send_resp(conn, 400, "websocket upgrade failed: #{Exception.message(e)}")
    end
  end

  match _ do
    send_resp(conn, 404, "not found")
  end
end

defmodule VoiceChat.WSHandler do
  @moduledoc """
  WebSocket 会话处理器（WebSock 回调模块，运行在 Bandit 的 ws 进程中）。

  每个连接即一个新 session：
  - `init/1` 启动录音进程与提示音进程，并把 session 注册到 Registry；
  - 二进制帧（麦克风音频块）转发给录音进程落盘；
  - 文本帧为 JSON 控制消息（config / text 等）；
  - `handle_info` 响应提示音进程发来的下发请求（文本 + 音频）。
  """

  @behaviour WebSock

  require Logger

  @impl true
  def init(%{query_params: query_params}) do
    session_id = VoiceChat.SessionId.sanitize(query_params["session"])
    ws_pid = self()

    # 先占用最终 session id，再用它启动录音进程，避免重名连接写入旧 id 的文件。
    session_id = register_session(session_id, ws_pid)
    recorder = VoiceChat.Recorder.start(session_id, ws_pid)

    {_, _} =
      Registry.update_value(
        VoiceChat.SessionRegistry,
        session_id,
        &Map.put(&1, :recorder, recorder)
      )

    prompter = VoiceChat.Prompter.start(ws_pid)

    Logger.info("session opened id=#{session_id} ws_pid=#{inspect(ws_pid)}")

    session_message = Jason.encode!(%{type: "session", session: session_id})
    state = %{session_id: session_id, ws_pid: ws_pid, recorder: recorder, prompter: prompter}

    {:push, {:text, session_message}, state}
  end

  defp register_session(session_id, ws_pid) when is_pid(ws_pid) do
    meta = %{ws_pid: ws_pid, started_at: DateTime.utc_now() |> DateTime.to_iso8601()}
    register_session(session_id, meta)
  end

  defp register_session(session_id, meta) do
    case Registry.register(VoiceChat.SessionRegistry, session_id, meta) do
      {:ok, _} ->
        session_id

      {:error, {:already_registered, _pid}} ->
        register_session(VoiceChat.SessionId.generate(), meta)
    end
  end

  @impl true
  def handle_in({data, opcode: :binary}, state) do
    VoiceChat.Recorder.chunk(state.recorder, data)
    {:ok, state}
  end

  def handle_in({text, opcode: :text}, state) do
    case Jason.decode(text) do
      {:ok, %{"type" => "config"} = config} ->
        VoiceChat.Recorder.config(state.recorder, config)
        {:ok, state}

      {:ok, %{"type" => "text", "text" => t}} when is_binary(t) ->
        # 模拟聊天：回一句 echo
        reply = Jason.encode!(%{type: "text", message: "收到: #{t}", session: state.session_id})
        {:push, {:text, reply}, state}

      {:ok, _other} ->
        {:ok, state}

      {:error, _} ->
        Logger.warning("bad json frame session=#{state.session_id}")
        {:ok, state}
    end
  end

  @impl true
  def handle_info({:send_binary, data}, state), do: {:push, {:binary, data}, state}
  def handle_info({:send_text, text}, state), do: {:push, {:text, text}, state}
  def handle_info(_msg, state), do: {:ok, state}

  @impl true
  def terminate(_reason, state) do
    VoiceChat.Prompter.stop(state.prompter)

    if VoiceChat.Recorder.stop(state.recorder) == {:error, :timeout} do
      Logger.warning("recorder stop timed out session=#{state.session_id}")
    end

    Logger.info("session closed id=#{state.session_id}")
    :ok
  end
end

defmodule VoiceChat.Recorder do
  @moduledoc """
  每个 session 的音频落盘进程（轻量进程）。

  接收 `{:chunk, binary}` 持续写入文件；收到 `:stop` 或所属 ws 进程退出时，
  补齐 WAV 头并关闭文件。PCM16 数据在 finalize 时包装成标准 .wav 文件，
  Opus 的 WebM / Ogg 容器数据则原样拼接保存。
  """

  require Logger

  @stop_timeout 5_000
  @wav_header_size 44

  @doc "启动录音进程，与调用进程（ws 进程）link。"
  def start(session_id, ws_pid) do
    spawn_link(fn -> init_loop(session_id, ws_pid) end)
  end

  @doc "设置音频格式 / 采样率等元信息。"
  def config(pid, config) when is_pid(pid), do: send(pid, {:config, config})

  @doc "写入一块音频数据。"
  def chunk(pid, data) when is_pid(pid) and is_binary(data), do: send(pid, {:chunk, data})

  @doc "请求停止并等待进程退出；常规 `:stop` 分支先 finalize，超时返回 `{:error, :timeout}`。"
  def stop(pid) when is_pid(pid) do
    monitor = Process.monitor(pid)
    send(pid, :stop)

    receive do
      {:DOWN, ^monitor, :process, ^pid, _reason} ->
        :ok
    after
      @stop_timeout ->
        Process.demonitor(monitor, [:flush])
        {:error, :timeout}
    end
  end

  defp init_loop(session_id, ws_pid) do
    # trap 退出信号：ws 进程异常退出时也能 finalize 文件
    Process.flag(:trap_exit, true)

    loop(%{
      session_id: session_id,
      ws_pid: ws_pid,
      format: :pcm16,
      sample_rate: 16_000,
      channels: 1,
      io: nil,
      path: nil,
      bytes: 0,
      finalized: false
    })
  end

  defp loop(state) do
    receive do
      {:config, config} ->
        loop(apply_config(state, config))

      {:chunk, data} ->
        loop(write_chunk(state, data))

      :stop ->
        finalize_and_exit(state)

      {:EXIT, from, _reason} ->
        if from == state.ws_pid, do: finalize_and_exit(state), else: loop(state)
    end
  end

  # --- config ---------------------------------------------------------------

  defp apply_config(state, config) when is_map(config) do
    format = container_format(config)

    sample_rate = config["sample_rate"] || state.sample_rate
    channels = config["channels"] || state.channels

    {sample_rate, channels} =
      if valid_wav_params?(sample_rate, channels) do
        {sample_rate, channels}
      else
        Logger.warning(
          "invalid audio config ignored session=#{state.session_id} " <>
            "sample_rate=#{inspect(sample_rate)} channels=#{inspect(channels)}"
        )

        {state.sample_rate, state.channels}
      end

    if state.io do
      Logger.warning(
        "config ignored (file already open) session=#{state.session_id} format=#{inspect(format)}"
      )

      state
    else
      %{state | format: format, sample_rate: sample_rate, channels: channels}
    end
  end

  defp valid_wav_params?(sample_rate, channels)
       when is_integer(sample_rate) and sample_rate > 0 and sample_rate <= 0xFFFF_FFFF and
              is_integer(channels) and channels > 0 and channels * 2 <= 0xFFFF and
              sample_rate * channels * 2 <= 0xFFFF_FFFF,
       do: true

  defp valid_wav_params?(_sample_rate, _channels), do: false

  defp container_format(%{"format" => "opus", "container" => "ogg"}), do: :ogg
  defp container_format(%{"format" => format}) when format in ["opus", "webm"], do: :webm
  defp container_format(%{"format" => "ogg"}), do: :ogg
  defp container_format(_config), do: :pcm16

  # --- writing --------------------------------------------------------------

  defp write_chunk(%{io: nil} = state, data) do
    case ensure_open(state) do
      %{io: nil} = unopened -> unopened
      opened -> write_chunk(opened, data)
    end
  end

  defp write_chunk(state, data) do
    :ok = :file.write(state.io, data)
    %{state | bytes: state.bytes + byte_size(data)}
  end

  defp ensure_open(state) do
    path = build_path(state)

    case :file.open(path, [:write, :binary, :raw]) do
      {:ok, io} ->
        case state.format do
          :pcm16 ->
            # 先写占位头，finalize 时回填真实大小
            :ok = :file.write(io, VoiceChat.Wav.header(state.sample_rate, state.channels, 0))

          format when format in [:webm, :ogg] ->
            :ok
        end

        %{state | io: io, path: path}

      {:error, reason} ->
        Logger.error("cannot open recording file #{path}: #{inspect(reason)}")
        state
    end
  end

  defp build_path(state) do
    timestamp = System.system_time(:microsecond)
    sequence = System.unique_integer([:positive, :monotonic])
    ext = if state.format == :pcm16, do: "wav", else: Atom.to_string(state.format)
    dir = VoiceChat.recordings_dir()
    Path.join(dir, "#{state.session_id}_#{timestamp}_#{sequence}.#{ext}")
  end

  # --- finalize -------------------------------------------------------------

  defp finalize_and_exit(state) do
    finalize(state)
    :ok
  end

  defp finalize(%{finalized: true} = state), do: state

  defp finalize(%{io: nil} = state), do: %{state | finalized: true}

  defp finalize(state) do
    state =
      case state.format do
        :pcm16 -> finalize_pcm(state)
        format when format in [:webm, :ogg] -> finalize_container(state)
      end

    %{state | finalized: true, io: nil}
  end

  defp finalize_pcm(state) do
    frame_size = state.channels * 2
    complete_bytes = state.bytes - rem(state.bytes, frame_size)
    dropped_bytes = state.bytes - complete_bytes

    if dropped_bytes > 0 do
      end_position = @wav_header_size + complete_bytes
      {:ok, ^end_position} = :file.position(state.io, end_position)

      :ok = :file.truncate(state.io)

      Logger.warning(
        "dropped incomplete PCM frame session=#{state.session_id} bytes=#{dropped_bytes}"
      )
    end

    {:ok, 0} = :file.position(state.io, 0)

    :ok =
      :file.write(
        state.io,
        VoiceChat.Wav.header(state.sample_rate, state.channels, complete_bytes)
      )

    :ok = :file.close(state.io)

    Logger.info(
      "recorded wav session=#{state.session_id} path=#{state.path} audio_bytes=#{complete_bytes}"
    )

    %{state | bytes: complete_bytes}
  end

  defp finalize_container(state) do
    :ok = :file.close(state.io)

    Logger.info(
      "recorded container session=#{state.session_id} path=#{state.path} bytes=#{state.bytes}"
    )

    state
  end
end

defmodule VoiceChat.Prompter do
  @moduledoc """
  每个 session 的提示音定时进程（轻量进程）。

  每隔 3 秒向所属 ws 进程发送一次提示音（“好的”）音频字节，
  由 ws 进程通过 WebSocket 推送给客户端播放。
  """

  @interval 3_000

  @doc "启动提示音进程，与调用进程（ws 进程）link。"
  def start(ws_pid) do
    spawn_link(fn -> loop(ws_pid, VoiceChat.PromptAudio.bytes()) end)
  end

  @doc "停止提示音进程。"
  def stop(pid) when is_pid(pid), do: send(pid, :stop)

  defp loop(ws_pid, audio) do
    receive do
      :stop -> :ok
    after
      @interval ->
        if Process.alive?(ws_pid) do
          send(
            ws_pid,
            {:send_text,
             Jason.encode!(%{
               type: "prompt",
               message: "好的",
               at: System.system_time(:second)
             })}
          )

          send(ws_pid, {:send_binary, audio})
          loop(ws_pid, audio)
        else
          :ok
        end
    end
  end
end

defmodule VoiceChat.Wav do
  @moduledoc """
  16-bit PCM WAV 文件的头部构造与简单的提示音合成工具。
  """

  @max_u32 0xFFFF_FFFF
  @max_data_size @max_u32 - 36

  @doc """
  生成 44 字节的 WAV(RIFF) 头部，PCM 16-bit 小端。

  - `sample_rate`: 采样率，如 16000
  - `channels`: 声道数，如 1
  - `data_size`: PCM 数据字节数
  """
  @spec header(pos_integer(), pos_integer(), non_neg_integer()) :: binary()
  def header(sample_rate, channels, data_size)
      when is_integer(sample_rate) and sample_rate > 0 and sample_rate <= @max_u32 and
             is_integer(channels) and channels > 0 and channels * 2 <= 0xFFFF and
             sample_rate * channels * 2 <= @max_u32 and is_integer(data_size) and
             data_size >= 0 and data_size <= @max_data_size do
    byte_rate = sample_rate * channels * 2
    block_align = channels * 2

    <<"RIFF", 36 + data_size::little-32, "WAVE", "fmt ", 16::little-32, 1::little-16,
      channels::little-16, sample_rate::little-32, byte_rate::little-32, block_align::little-16,
      16::little-16, "data", data_size::little-32>>
  end

  @doc """
  合成一段双音提示音（660Hz 短音 + 停顿 + 880Hz 短音），返回完整 WAV 文件字节。
  在没有真人语音素材时的兜底方案。
  """
  @spec synthesize_chime(pos_integer()) :: binary()
  def synthesize_chime(sample_rate \\ 16_000) do
    tone = fn freq, duration ->
      n = round(sample_rate * duration)

      for i <- 0..(n - 1) do
        attack = min(1.0, i / (sample_rate * 0.01))
        release = min(1.0, (n - i) / (sample_rate * 0.03))
        :math.sin(2 * :math.pi() * freq * i / sample_rate) * 0.55 * attack * release
      end
    end

    samples =
      tone.(660, 0.12) ++
        List.duplicate(0.0, round(sample_rate * 0.06)) ++
        tone.(880, 0.18)

    pcm =
      samples
      |> Enum.map(fn s -> round(max(-1.0, min(1.0, s)) * 32_767) end)
      |> Enum.map(&<<&1::little-signed-16>>)
      |> IO.iodata_to_binary()

    header(sample_rate, 1, byte_size(pcm)) <> pcm
  end
end

defmodule VoiceChat.PromptAudio do
  @moduledoc """
  管理每 3 秒推送给客户端的提示音（“好的”）音频字节。

  优先使用 `priv/static/audio/haode.wav`（可自行替换为自己的录音），
  不存在时在启动时自动合成一段双音提示音作为兜底。
  """

  @doc "确保提示音文件存在；不存在则生成兜底音频。"
  def ensure! do
    path = path()
    File.mkdir_p!(Path.dirname(path))

    unless File.exists?(path) do
      File.write!(path, VoiceChat.Wav.synthesize_chime(16_000))
      require Logger
      Logger.info("generated fallback prompt audio at #{path}")
    end

    :ok
  end

  @doc "提示音文件完整字节（每次调用时读取）。"
  def bytes, do: File.read!(path())

  @doc "提示音文件路径。"
  def path, do: Application.app_dir(:voice_chat, "priv/static/audio/haode.wav")
end

els.connect.onclick = () => {
  if (ws && (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING)) return;

  bytesUp = 0;
  bytesDown = 0;
  frames = 0;
  sessionStart = 0;
  sessionId = "sess_" + Date.now() + "_" + Math.floor(Math.random() * 1e6);
  const proto = location.protocol === "https:" ? "wss" : "ws";
  const url = `${proto}://${location.host}/ws?session=${sessionId}`;

  setStatus("连接中…", null);
  els.connect.disabled = true;
  addMessage("system", `正在连接 ${url}`);

  const socket = new WebSocket(url);
  ws = socket;
  socket.binaryType = "arraybuffer";

  socket.onopen = () => {
    if (ws !== socket) return;
    setStatus("已连接", true);
    els.session.textContent = "会话: " + sessionId;
    els.disconnect.disabled = false;
    addMessage("system", "✅ 已连接，正在打开麦克风…");
    void startRecording(socket);
  };

  socket.onmessage = (ev) => {
    if (ws !== socket) return;
    if (typeof ev.data === "string") {
      handleText(ev.data);
    } else {
      bytesDown += ev.data.byteLength;
      playAudio(ev.data);
    }
  };

  socket.onclose = () => {
    if (ws !== socket) return;
    ws = null;
    void stopRecording();
    setStatus("已断开", false);
    els.session.textContent = "";
    els.connect.disabled = false;
    els.disconnect.disabled = true;
    addMessage("system", "🔌 连接已断开");
    addMessage("system", "💾 服务端将尝试收尾本次录音；结果与保存路径以服务端日志为准");
  };

  socket.onerror = () => {
    if (ws === socket) addMessage("error", "⚠️ WebSocket 错误");
  };
};

els.disconnect.onclick = async () => {
  const socket = ws;
  if (!socket) return;
  els.disconnect.disabled = true;
  await stopRecording();
  if (ws === socket && socket.readyState < WebSocket.CLOSING) socket.close();
};

window.addEventListener("beforeunload", () => {
  void stopRecording();
  if (ws) ws.close();
});

async function startRecording(socket) {
  const fmt = els.format.value;
  if (fmt === "opus") await startMediaRecorder(socket);
  else await startPcmCapture(socket);
}

function sendConfig(socket, fmt, container) {
  if (ws !== socket || socket.readyState !== WebSocket.OPEN) throw new Error("WebSocket 已关闭");
  const config =
    fmt === "opus"
      ? { type: "config", format: "opus", container }
      : { type: "config", format: "pcm16", sample_rate: 16000, channels: 1, bit_depth: 16 };
  socket.send(JSON.stringify(config));
}

async function startPcmCapture(socket) {
  try {
    ensureAudioCtx();
    await audioCtx.resume();
    if (ws !== socket) return;

    const stream = await navigator.mediaDevices.getUserMedia({
      audio: { echoCancellation: true, noiseSuppression: true, sampleRate: 16000 },
    });
    if (ws !== socket || socket.readyState !== WebSocket.OPEN) {
      stream.getTracks().forEach((track) => track.stop());
      return;
    }

    micStream = stream;
    sendConfig(socket, "pcm16");
    sourceNode = audioCtx.createMediaStreamSource(stream);
    processor = audioCtx.createScriptProcessor(4096, 1, 1);

    const targetRate = 16000;
    processor.onaudioprocess = (e) => {
      const input = e.inputBuffer.getChannelData(0);
      const pcm = downsample(input, audioCtx.sampleRate, targetRate);
      const buf = floatTo16BitPCM(pcm);
      if (ws === socket && socket.readyState === WebSocket.OPEN) {
        socket.send(buf);
        bytesUp += buf.byteLength;
        frames++;
      }
    };

    // 静音增益保持音频图活跃，避免回声反馈
    silenceNode = audioCtx.createGain();
    silenceNode.gain.value = 0;
    sourceNode.connect(processor);
    processor.connect(silenceNode);
    silenceNode.connect(audioCtx.destination);

    sessionStart = Date.now();
    addMessage("system", "🎤 麦克风已开启（PCM16 @16kHz）—— 开始说话吧");
  } catch (err) {
    if (ws === socket) {
      await stopRecording();
      addMessage("error", "⚠️ 无法获取麦克风: " + err.message);
    }
  }
}

async function startMediaRecorder(socket) {
  try {
    const mime = ["audio/webm;codecs=opus", "audio/ogg;codecs=opus"].find((m) =>
      MediaRecorder.isTypeSupported(m)
    );
    if (!mime) throw new Error("当前浏览器不支持 WebM/Ogg Opus 录音");

    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
    if (ws !== socket || socket.readyState !== WebSocket.OPEN) {
      stream.getTracks().forEach((track) => track.stop());
      return;
    }

    micStream = stream;
    mediaRecorder = new MediaRecorder(stream, { mimeType: mime });
    sendConfig(socket, "opus", mime.startsWith("audio/ogg") ? "ogg" : "webm");

    mediaRecorder.ondataavailable = (e) => {
      if (e.data && e.data.size > 0 && socket.readyState === WebSocket.OPEN) {
        socket.send(e.data);
        bytesUp += e.data.size;
        frames++;
      }
    };

    mediaRecorder.start(250); // 每 250ms 一个分块
    sessionStart = Date.now();
    addMessage("system", "🎤 麦克风已开启（Opus / " + mime + " 分块）");
  } catch (err) {
    if (ws === socket) {
      await stopRecording();
      addMessage("error", "⚠️ 无法获取麦克风: " + err.message);
    }
  }
}

async function stopRecording() {
  const recorder = mediaRecorder;
  const captureProcessor = processor;
  const captureSource = sourceNode;
  const captureSilence = silenceNode;
  const captureStream = micStream;
  mediaRecorder = null;
  processor = null;
  sourceNode = null;
  silenceNode = null;
  micStream = null;
  sessionStart = 0;

  if (captureProcessor) captureProcessor.onaudioprocess = null;

  if (recorder && recorder.state !== "inactive") {
    await new Promise((resolve) => {
      const timeout = setTimeout(resolve, 1_000);
      recorder.addEventListener("stop", () => { clearTimeout(timeout); resolve(); }, { once: true });
      try { recorder.stop(); } catch (_) { clearTimeout(timeout); resolve(); }
    });
  }

  if (captureProcessor) {
    try { captureProcessor.disconnect(); } catch (_) {}
  }
  if (captureSource) {
    try { captureSource.disconnect(); } catch (_) {}
  }
  if (captureSilence) {
    try { captureSilence.disconnect(); } catch (_) {}
  }
  if (captureStream) {
    captureStream.getTracks().forEach((track) => track.stop());
  }
  // audioCtx 保留给播放用，不关闭
}

/* ---------- 音频处理 ---------- */

function downsample(input, fromRate, toRate) {
  if (fromRate === toRate) return input;
  const ratio = fromRate / toRate;
  const newLen = Math.round(input.length / ratio);
  const out = new Float32Array(newLen);
  let offset = 0;
  for (let i = 0; i < newLen; i++) {
    const end = Math.round((i + 1) * ratio);
    let sum = 0, count = 0;
    for (; offset < end && offset < input.length; offset++) {
      sum += input[offset];
      count++;
    }
    out[i] = count > 0 ? sum / count : 0;
  }
  return out;
}

function floatTo16BitPCM(float32) {
  const buffer = new ArrayBuffer(float32.length * 2);
  const view = new DataView(buffer);
  for (let i = 0; i < float32.length; i++) {
    const s = Math.max(-1, Math.min(1, float32[i]));
    view.setInt16(i * 2, s < 0 ? s * 0x8000 : s * 0x7fff, true);
  }
  return buffer;
}

function ensureAudioCtx() {
  if (!audioCtx) audioCtx = new (window.AudioContext || window.webkitAudioContext)();
  return audioCtx;
}

function playAudio(arrayBuffer) {
  const ctx = ensureAudioCtx();
  ctx.resume()
    .then(() => ctx.decodeAudioData(arrayBuffer.slice(0)))
    .then((buffer) => {
      const src = ctx.createBufferSource();
      src.buffer = buffer;
      src.connect(ctx.destination);
      src.start();
      addMessage("out", "🔊 播放服务端音频");
    })
    .catch((err) => addMessage("error", "⚠️ 音频解码失败: " + err.message));
}

function handleText(raw) {
  let msg;
  try { msg = JSON.parse(raw); } catch (_) { return; }

  switch (msg.type) {
    case "session": {
      const actual = String(msg.session || "");
      if (actual) {
        const renamed = sessionId && sessionId !== actual;
        sessionId = actual;
        els.session.textContent = "会话: " + actual;
        if (renamed) addMessage("system", `ℹ️ 会话名冲突，服务端已改用 ${actual}`);
      }
      break;
    }
    case "prompt":
      addMessage("in", `🔊 服务端提示音: “${msg.message || "好的"}”`);
      break;
    case "text":
      addMessage("in", msg.message || msg.text || "");
      break;
    case "error":
      addMessage("error", "⚠️ " + (msg.message || "服务器错误"));
      break;
    default:
      addMessage("in", "← " + raw);
  }
}