defmodule OpenAgentsWeb.TimelineLive do

  @moduledoc """

  The account's unified timeline as a page.

  Every entry is rooted in the account's visitor. Only the current account's

  own coder, voice, and chat activity is shown, newest first.

  """

  use OpenAgentsWeb, :live_view

  alias OpenAgents.Timeline

  @impl true

  def mount(_params, _session, %{assigns: %{current_user: current_user}} = socket) do

    entries =

      Timeline.for_user(current_user)

      |> Enum.reverse()

    {:ok,

     socket

     |> assign(:page_title, "Timeline")

     |> assign(:entries, entries)}

  end

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

    >

      <main id="timeline" class="mx-auto w-full max-w-5xl space-y-6 px-4 py-10">

        <.header>

          Timeline

          <:subtitle>Your account's activity, newest first.</:subtitle>

        </.header>

        <.empty :if={@entries == []} id="timeline-empty" title="No activity yet">

          Your chat, voice, and coder sessions appear here when they start.

        </.empty>

        <.table

          :if={@entries != []}

          id="timeline-table"

          rows={@entries}

          row_id={&"timeline-entry-#{&1.record_id}"}

        >

          <:col :let={entry} label="When">

            <span :if={is_nil(entry.timestamp)} class="text-muted-foreground">—</span>

            <.time_ago :if={entry.timestamp} at={entry.timestamp} />

          </:col>

          <:col :let={entry} label="Modality">

            {modality_label(entry.modality)}

          </:col>

          <:col :let={entry} label="Kind">

            <.badge variant={kind_variant(entry.kind)}>{kind_label(entry.kind)}</.badge>

          </:col>

          <:col :let={entry} label="Summary">

            {entry.summary}

          </:col>

        </.table>

      </main>

    </Layouts.app>

    """

  end

  defp modality_label(modality) do

    modality

    |> to_string()

    |> String.capitalize()

  end

  defp kind_label(kind) do

    kind

    |> to_string()

    |> String.replace("_", " ")

    |> String.capitalize()

  end

  defp kind_variant(:turn), do: :info

  defp kind_variant(:tool_step), do: :warning

  defp kind_variant(:decision), do: :success

  defp kind_variant(:system), do: :default

  defp kind_variant(_kind), do: :default

end

  @authenticated_browser_prefixes [

    "/sarah",

    "/timeline",

    "/computers",

    "/voice/",

    "/data",

  defp browser_scope("/voice/" <> _path), do: "voice:self"

  defp browser_scope("/data" <> _path), do: "data:self"

  defp browser_scope("/artifact-catalog"), do: "artifact-catalog:read"

  defp browser_scope("/timeline"), do: "timeline:self"

  defp browser_scope("/memory/" <> _path), do: "memory:self"

  defp browser_scope("/github/connection"), do: "github-tools:self"

  defp browser_scope("/notifications"), do: "notification:self"

      on_mount: [{OpenAgentsWeb.UserAuth, :ensure_authenticated}] do

      live "/sarah", ChatLive, :index

      live "/memory", MemoryLive, :index

      live "/timeline", TimelineLive, :index

      live "/computers", ComputersLive, :index

      live "/artifact-catalog", ArtifactCatalogLive, :index

      live "/notifications", NotificationsLive, :index

defmodule OpenAgentsWeb.TimelineLiveTest do

  @moduledoc """

  `/timeline` renders the current account's unified activity, newest first,

  and never shows another account's records.

  """

  use OpenAgentsWeb.ConnCase, async: false

  import Phoenix.LiveViewTest

  alias OpenAgents.{Conversations, Repo, Threads}

  test "renders newest-first entries from more than one modality and excludes other accounts", %{

    conn: conn

  } do

    me = github_user("timeline-live-me")

    other = github_user("timeline-live-other")

    # An older coder entry.

    {:ok, my_thread} = Threads.open(me, "My timeline thread")

    [opened_event] = Threads.list_events(my_thread)

    old_time = DateTime.from_naive!(~N[2026-01-01 10:00:00.000000], "Etc/UTC")

    opened_event

    |> Ecto.Changeset.change(emitted_at: old_time)

    |> Repo.update!()

    # A newer chat entry.

    {:ok, conversation} = Conversations.ensure_conversation(me)

    {:ok, %{turn: turn}} = Conversations.create_turn(conversation, "Chat message for timeline")

    # Another account's entry must not appear.

    {:ok, other_thread} = Threads.open(other, "Other private thread")

    [other_event] = Threads.list_events(other_thread)

    conn = log_in_github_user(conn, "timeline-live-me")

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

    html = render(view)

    assert html =~ "Chat message for timeline"

    assert html =~ "Thread opened"

    refute html =~ ~s(id="timeline-entry-#{other_event.id}")

    assert has_element?(view, "#timeline-entry-#{turn.id}")

    assert has_element?(view, "#timeline-entry-#{opened_event.id}")

    # Newest-first: the chat row appears before the older thread row.

    {chat_pos, _} = :binary.match(html, ~s(id="timeline-entry-#{turn.id}"))

    {coder_pos, _} = :binary.match(html, ~s(id="timeline-entry-#{opened_event.id}"))

    assert chat_pos < coder_pos

  end

  test "anonymous browser is redirected without revealing the timeline", %{conn: conn} do

    assert {:error, {:redirect, %{to: "/"}}} = live(conn, ~p"/timeline")

  end

end