import assert from "node:assert/strict"

import {readFileSync} from "node:fs"

import test from "node:test"

test("destroyed() invokes the same resource cleanup as closeVoiceResources", () => {

  const source = readFileSync(new URL("../js/voice_controller.js", import.meta.url), "utf8")

  assert.match(source, /this\.shutdownLocal\(null,\s*["']idle["']\)/)

  assert.match(

    source,

    /closeVoiceResources\(\{\s*channel:\s*this\.channel,\s*peer:\s*this\.peer,\s*media:\s*this\.media,\s*audio:\s*this\.audio,?\s*\}\)/,

  )

})

                active_turn={@active_turn}

                message_queue={@message_queue}

                voice_enabled?={true}

                recording_config={@recording_config}

              />

              <audio id="voice-output" class="voice-output" autoplay playsinline></audio>

            </section>

              active_turn={@active_turn}

              message_queue={@message_queue}

              voice_enabled?={false}

              recording_config={@recording_config}

            />

          </footer>

        </main>

  attr :active_turn, :map, default: nil

  attr :message_queue, :list, required: true

  attr :voice_enabled?, :boolean, required: true

  attr :recording_config, :map, required: true

  defp composer_stack(assigns) do

    ~H"""

              trailing edge rather than an empty group being drawn opposite

              them. --%>

        <.prompt_input_tools class="ml-auto">

          <.voice_session_buttons :if={@voice_enabled?} active_turn={@active_turn} />

          <.voice_session_buttons

            :if={@voice_enabled?}

            active_turn={@active_turn}

            recording_config={@recording_config}

          />

          <%!-- Stop stays its own control rather than `on_stop` on the submit:

                a message sent while a turn runs queues, so send and stop are

                two live actions, not one control in two states. --%>

  end

  attr :active_turn, :map, default: nil

  attr :recording_config, :map, required: true

  defp voice_session_buttons(assigns) do

    ~H"""

    <p :if={@recording_config.enabled?} id="voice-recording-disclosure">

      Call audio is recorded, stored encrypted, and readable by a Sarah operator.

      It is deleted {@recording_config.retention_days} days after a call ends, and

      deleting your data removes it immediately.

    </p>

    <.prompt_input_button

      id="voice-start"

      variant={:outline}

    end)

    conn = log_in_github_user(conn, "voice-recording-off-user")

    assert {:ok, view, html} = live(conn, ~p"/sarah")

    assert {:ok, _view, html} = live(conn, ~p"/sarah")

    assert html =~ ~s(id="voice-controller")

    refute has_element?(view, "#voice-recording-disclosure")

    assert html =~ ~s(data-recording-enabled="false")

  end

  test "recording on surfaces a disclosure before the voice control", %{conn: conn} do

    previous_voice = Application.fetch_env!(:openagents, :voice)

    previous_recording = Application.fetch_env!(:openagents, :voice_recording)

    Application.put_env(:openagents, :voice, enabled_voice())

    Application.put_env(

      :openagents,

      :voice_recording,

      Keyword.put(previous_recording, :enabled, true)

    )

    on_exit(fn ->

      Application.put_env(:openagents, :voice, previous_voice)

      Application.put_env(:openagents, :voice_recording, previous_recording)

    end)

    conn = log_in_github_user(conn, "voice-recording-on-user")

    assert {:ok, _view, html} = live(conn, ~p"/sarah")

    assert html =~ ~s(id="voice-controller")

    assert html =~ ~s(id="voice-recording-disclosure")

    assert html =~ "readable by a Sarah operator"

    assert html =~

             "#{OpenAgents.Voice.Recordings.config().retention_days} days after a call ends"

    assert html =~ ~s(data-recording-enabled="true")

  end

  test "a connected LiveView refuses events after the account is banned", %{conn: conn} do

    user = github_user("live-ban-user")

    conn = log_in_github_user(conn, "live-ban-user")