import Ecto.Query, warn: false

  alias OpenAgents.Accounts.User

  alias OpenAgents.Forge.Browse

  alias OpenAgents.PullRequests.PullRequest

  alias OpenAgents.Repo

  alias OpenAgents.Repositories

  alias OpenAgents.Repositories.Repository

  alias OpenAgents.Stacks.IdempotencyRequest

  alias OpenAgents.Stacks.Stack

  alias OpenAgents.Stacks.StackEntry

  alias OpenAgents.Stacks.StackEvent

  @doc """

  Creates a stack from pull requests ordered bottom to top.

    end

  end

  @doc "Lists a repository's stacks with active entries, newest first."

  def list(%Repository{id: repository_id}) do

    Stack

    |> where(repository_id: ^repository_id)

    |> order_by(desc: :number)

    |> Repo.all()

    |> Repo.preload(entries: active_entries_query())

  end

  @doc """

  Creates a stack from an API request.

  The request names the trunk ref, the pull request numbers bottom to top,

  and optionally the head OIDs the caller observed. The whole validation

  chain runs inside one metadata transaction with row locks. A retried

  idempotency key replays the original result; the same key with a different

  request fails with `:idempotency_conflict`.

  """

  def create_from_api(%Repository{} = repository, params, %User{} = actor, idempotency_key)

      when is_binary(idempotency_key) do

    with :ok <- authorize(repository, actor),

         {:ok, request} <- parse_create_request(params) do

      request_digest = digest({:create, request})

      run_idempotent(repository, actor, "stack_create", idempotency_key, request_digest, fn ->

        create_stack_rows(repository, request, actor, idempotency_key, request_digest)

      end)

    end

  end

  @doc """

  Appends one pull request to the top of an open stack.

  The new pull request must target the current top head. A caller-supplied

  `expected_stack_version` that mismatches the current version fails with

  `:stale_stack_version`. A successful append bumps the stack version.

  """

  def append_from_api(

        %Repository{} = repository,

        number,

        params,

        %User{} = actor,

        idempotency_key

      )

      when is_integer(number) and is_binary(idempotency_key) do

    with :ok <- authorize(repository, actor),

         {:ok, request} <- parse_append_request(params) do

      request_digest = digest({:append, number, request})

      run_idempotent(repository, actor, "stack_append", idempotency_key, request_digest, fn ->

        append_stack_rows(repository, number, request, actor, idempotency_key, request_digest)

      end)

    end

  end

  def get_by_number!(%Repository{id: repository_id}, number) when is_integer(number) do

    Stack

    |> Repo.get_by!(repository_id: repository_id, number: number)

  end

  defp number_conflict?(_other), do: false

  defp authorize(repository, actor) do

    if Repositories.writable?(repository, actor), do: :ok, else: {:error, :forbidden}

  end

  defp run_idempotent(repository, actor, operation, idempotency_key, request_digest, fun) do

    Repo.transaction(fn ->

      lock_repository_stacks(repository.id)

      case get_idempotency_request(actor.id, operation, idempotency_key) do

        %IdempotencyRequest{request_digest: ^request_digest} = request ->

          {reload_stack(request.stack_id), :replayed}

        %IdempotencyRequest{} ->

          Repo.rollback(:idempotency_conflict)

        nil ->

          fun.()

      end

    end)

  end

  defp lock_repository_stacks(repository_id) do

    key = "pull_request_stacks:#{repository_id}"

    Repo.query!("SELECT pg_advisory_xact_lock(hashtextextended($1, 0))", [key])

    :ok

  end

  defp get_idempotency_request(user_id, operation, idempotency_key) do

    Repo.one(

      from request in IdempotencyRequest,

        where:

          request.user_id == ^user_id and request.operation == ^operation and

            request.idempotency_key == ^idempotency_key,

        lock: "FOR UPDATE"

    )

  end

  defp reload_stack(stack_id) do

    Stack

    |> Repo.get!(stack_id)

    |> Repo.preload(entries: active_entries_query())

  end

  defp create_stack_rows(repository, request, actor, idempotency_key, request_digest) do

    with {:ok, pull_requests} <- load_pull_requests(repository, request.pull_requests),

         :ok <- validate_structure(repository, pull_requests),

         :ok <- validate_trunk(request.trunk_ref, pull_requests),

         {:ok, trunk_oid} <- resolve_oid(repository, request.trunk_ref),

         {:ok, heads} <- snapshot_heads(repository, pull_requests),

         :ok <- validate_expected_heads(request.expected_heads, pull_requests, heads) do

      stack = insert_stack!(repository, actor, request.trunk_ref)

      entries = insert_entry_rows!(stack, entry_specs(pull_requests, heads, trunk_oid))

      record_event!(stack, "pull_request_stack.created", actor, %{

        "number" => stack.number,

        "trunk_ref" => stack.trunk_ref,

        "trunk_oid" => trunk_oid,

        "entries" => Enum.map(entries, &event_entry/1)

      })

      record_idempotency!(actor, "stack_create", idempotency_key, request_digest, stack.id)

      {%{stack | entries: entries}, :created}

    else

      {:error, reason} -> Repo.rollback(reason)

    end

  end

  defp append_stack_rows(repository, number, request, actor, idempotency_key, request_digest) do

    with {:ok, stack} <- get_stack_for_update(repository, number),

         :ok <- validate_open(stack),

         :ok <- validate_expected_version(request.expected_stack_version, stack),

         {:ok, top, entries} <- top_entry(stack),

         {:ok, [pull_request]} <- load_pull_requests(repository, [request.pull_request]),

         :ok <- validate_append(repository, stack, entries, top, pull_request),

         {:ok, head_oid} <- resolve_oid(repository, pull_request.head_ref),

         :ok <- validate_expected_head(request.expected_head, head_oid),

         {:ok, stack} <- bump_version(stack) do

      entry =

        insert_entry_row!(stack, pull_request, top.position + 1, top.observed_head_oid, head_oid)

      record_event!(stack, "pull_request_stack.appended", actor, %{

        "number" => stack.number,

        "trunk_ref" => stack.trunk_ref,

        "entries" => [event_entry(entry)]

      })

      record_idempotency!(actor, "stack_append", idempotency_key, request_digest, stack.id)

      {%{stack | entries: entries ++ [entry]}, :created}

    else

      {:error, reason} -> Repo.rollback(reason)

    end

  end

  defp parse_create_request(params) do

    with {:ok, trunk_ref} <- ref_param(params, "trunk_ref"),

         {:ok, numbers} <- pull_request_numbers(Map.get(params, "pull_requests")),

         {:ok, expected_heads} <- expected_heads(Map.get(params, "expected_heads"), numbers) do

      {:ok, %{trunk_ref: trunk_ref, pull_requests: numbers, expected_heads: expected_heads}}

    end

  end

  defp parse_append_request(params) do

    with {:ok, number} <- pull_request_number(Map.get(params, "pull_request")),

         {:ok, version} <- expected_version(Map.get(params, "expected_stack_version")),

         {:ok, expected_head} <- optional_oid(Map.get(params, "expected_head")) do

      {:ok,

       %{pull_request: number, expected_stack_version: version, expected_head: expected_head}}

    end

  end

  defp ref_param(params, key) do

    case Map.get(params, key) do

      value when is_binary(value) and value != "" -> {:ok, value}

      _other -> {:error, :invalid_request}

    end

  end

  defp pull_request_numbers(numbers) when is_list(numbers) and numbers != [] do

    if Enum.all?(numbers, &(is_integer(&1) and &1 > 0)),

      do: {:ok, numbers},

      else: {:error, :invalid_request}

  end

  defp pull_request_numbers(_other), do: {:error, :invalid_request}

  defp pull_request_number(number) when is_integer(number) and number > 0, do: {:ok, number}

  defp pull_request_number(_other), do: {:error, :invalid_request}

  defp expected_version(nil), do: {:ok, nil}

  defp expected_version(version) when is_integer(version) and version >= 1, do: {:ok, version}

  defp expected_version(_other), do: {:error, :invalid_request}

  defp expected_heads(nil, _numbers), do: {:ok, %{}}

  defp expected_heads(heads, numbers) when is_map(heads) do

    Enum.reduce_while(heads, {:ok, %{}}, fn {key, value}, {:ok, acc} ->

      with {number, ""} <- Integer.parse(to_string(key)),

           true <- number in numbers,

           {:ok, oid} when is_binary(oid) <- optional_oid(value) do

        {:cont, {:ok, Map.put(acc, number, oid)}}

      else

        _invalid -> {:halt, {:error, :invalid_request}}

      end

    end)

  end

  defp expected_heads(_other, _numbers), do: {:error, :invalid_request}

  defp optional_oid(nil), do: {:ok, nil}

  defp optional_oid(value) when is_binary(value) and byte_size(value) in [40, 64] do

    case Base.decode16(value, case: :lower) do

      {:ok, _raw} -> {:ok, value}

      :error -> {:error, :invalid_request}

    end

  end

  defp optional_oid(_other), do: {:error, :invalid_request}

  defp load_pull_requests(%Repository{id: repository_id}, numbers) do

    rows =

      Repo.all(

        from pr in PullRequest,

          join: issue in assoc(pr, :issue),

          where: pr.repository_id == ^repository_id and issue.number in ^numbers,

          preload: [issue: issue],

          lock: "FOR UPDATE"

      )

    by_number = Map.new(rows, &{&1.issue.number, &1})

    numbers

    |> Enum.reduce_while({:ok, []}, fn number, {:ok, acc} ->

      case Map.get(by_number, number) do

        nil -> {:halt, {:error, :pull_request_not_found}}

        pull_request -> {:cont, {:ok, [pull_request | acc]}}

      end

    end)

    |> case do

      {:ok, pull_requests} -> {:ok, Enum.reverse(pull_requests)}

      {:error, reason} -> {:error, reason}

    end

  end

  defp validate_trunk(trunk_ref, [bottom | _rest]) do

    if bottom.base_ref == trunk_ref, do: :ok, else: {:error, :trunk_mismatch}

  end

  defp snapshot_heads(repository, pull_requests) do

    Enum.reduce_while(pull_requests, {:ok, %{}}, fn pull_request, {:ok, acc} ->

      case resolve_oid(repository, pull_request.head_ref) do

        {:ok, oid} -> {:cont, {:ok, Map.put(acc, pull_request.id, oid)}}

        {:error, reason} -> {:halt, {:error, reason}}

      end

    end)

  end

  defp resolve_oid(repository, ref) do

    case Browse.resolve_commit(repository, ref) do

      {:ok, oid} -> {:ok, oid}

      _other -> {:error, :invalid_ref}

    end

  end

  defp validate_expected_heads(expected_heads, pull_requests, heads) do

    by_number = Map.new(pull_requests, &{&1.issue.number, &1})

    Enum.reduce_while(expected_heads, :ok, fn {number, expected}, :ok ->

      pull_request = Map.fetch!(by_number, number)

      if Map.fetch!(heads, pull_request.id) == expected,

        do: {:cont, :ok},

        else: {:halt, {:error, :expected_head_mismatch}}

    end)

  end

  defp validate_expected_head(nil, _head_oid), do: :ok

  defp validate_expected_head(expected, expected), do: :ok

  defp validate_expected_head(_expected, _head_oid), do: {:error, :expected_head_mismatch}

  defp insert_stack!(repository, actor, trunk_ref) do

    %Stack{}

    |> Stack.changeset(%{

      repository_id: repository.id,

      created_by_user_id: actor.id,

      number: next_number(repository.id),

      trunk_ref: trunk_ref

    })

    |> Repo.insert!()

  end

  defp entry_specs(pull_requests, heads, trunk_oid) do

    {specs, _previous_head} =

      pull_requests

      |> Enum.with_index(1)

      |> Enum.map_reduce(trunk_oid, fn {pull_request, position}, boundary ->

        head = Map.fetch!(heads, pull_request.id)

        {{pull_request, position, boundary, head}, head}

      end)

    specs

  end

  defp insert_entry_rows!(stack, specs) do

    Enum.map(specs, fn {pull_request, position, boundary, head} ->

      insert_entry_row!(stack, pull_request, position, boundary, head)

    end)

  end

  defp insert_entry_row!(stack, pull_request, position, boundary, head) do

    entry =

      %StackEntry{}

      |> StackEntry.changeset(%{

        stack_id: stack.id,

        pull_request_id: pull_request.id,

        position: position,

        boundary_oid: boundary,

        observed_head_oid: head

      })

      |> Repo.insert!()

    %{entry | pull_request: pull_request}

  end

  defp event_entry(entry) do

    %{

      "position" => entry.position,

      "pull_request" => entry.pull_request.issue.number,

      "boundary_oid" => entry.boundary_oid,

      "observed_head_oid" => entry.observed_head_oid

    }

  end

  defp record_event!(stack, event_type, actor, payload) do

    %StackEvent{}

    |> StackEvent.changeset(%{

      stack_id: stack.id,

      actor_user_id: actor.id,

      event_type: event_type,

      stack_version: stack.version,

      payload: payload

    })

    |> Repo.insert!()

  end

  defp record_idempotency!(actor, operation, idempotency_key, request_digest, stack_id) do

    %IdempotencyRequest{}

    |> IdempotencyRequest.changeset(

      actor.id,

      operation,

      idempotency_key,

      request_digest,

      stack_id

    )

    |> Repo.insert!()

  end

  defp get_stack_for_update(%Repository{id: repository_id}, number) do

    case Repo.one(

           from stack in Stack,

             where: stack.repository_id == ^repository_id and stack.number == ^number,

             lock: "FOR UPDATE"

         ) do

      nil -> {:error, :stack_not_found}

      stack -> {:ok, stack}

    end

  end

  defp validate_open(%Stack{state: "open"}), do: :ok

  defp validate_open(%Stack{}), do: {:error, :stack_not_open}

  defp validate_expected_version(nil, _stack), do: :ok

  defp validate_expected_version(version, %Stack{version: version}), do: :ok

  defp validate_expected_version(_version, %Stack{}), do: {:error, :stale_stack_version}

  defp top_entry(stack) do

    case active_entries(stack) do

      [] -> {:error, :empty_stack}

      entries -> {:ok, List.last(entries), entries}

    end

  end

  defp validate_append(repository, stack, entries, top, pull_request) do

    branches = [stack.trunk_ref | Enum.map(entries, & &1.pull_request.head_ref)]

    cond do

      pull_request.head_repository_id != repository.id ->

        {:error, :cross_repository_head}

      pull_request.state != "open" ->

        {:error, :pull_request_not_open}

      pull_request.head_ref in branches ->

        {:error, :duplicate_branch}

      pull_request.base_ref != top.pull_request.head_ref ->

        {:error, :not_stack_top}

      not is_nil(active_entry_for_pull_request(pull_request)) ->

        {:error, :already_stacked}

      true ->

        :ok

    end

  end

  defp bump_version(%Stack{id: id, version: version}) do

    {count, updated} =

      Repo.update_all(

        from(stack in Stack,

          where: stack.id == ^id and stack.version == ^version and stack.state == "open",

          select: stack

        ),

        set: [version: version + 1, updated_at: DateTime.utc_now()]

      )

    case {count, updated} do

      {1, [stack]} -> {:ok, stack}

      {0, _} -> {:error, :stale_stack_version}

    end

  end

  defp digest(value) do

    value

    |> :erlang.term_to_binary([:deterministic])

    |> then(&:crypto.hash(:sha256, &1))

    |> Base.encode16(case: :lower)

  end

end

defmodule OpenAgents.Stacks.IdempotencyRequest do

  @moduledoc false

  use Ecto.Schema

  import Ecto.Changeset

  @primary_key {:id, :binary_id, autogenerate: true}

  @foreign_key_type :binary_id

  @timestamps_opts [type: :utc_datetime_usec]

  schema "pull_request_stack_idempotency_requests" do

    field :operation, :string

    field :idempotency_key, :string

    field :request_digest, :string

    belongs_to :user, OpenAgents.Accounts.User

    belongs_to :stack, OpenAgents.Stacks.Stack

    timestamps()

  end

  def changeset(request, user_id, operation, idempotency_key, request_digest, stack_id) do

    request

    |> change()

    |> put_change(:user_id, user_id)

    |> put_change(:operation, operation)

    |> put_change(:idempotency_key, idempotency_key)

    |> put_change(:request_digest, request_digest)

    |> put_change(:stack_id, stack_id)

    |> validate_required([:user_id, :operation, :idempotency_key, :request_digest, :stack_id])

    |> validate_length(:operation, min: 1, max: 40)

    |> validate_length(:idempotency_key, min: 1, max: 255)

    |> validate_format(:request_digest, ~r/\A[0-9a-f]{64}\z/)

    |> unique_constraint([:user_id, :operation, :idempotency_key])

    |> check_constraint(:request_digest, name: :pull_request_stack_idempotency_digest_check)

    |> foreign_key_constraint(:user_id)

    |> foreign_key_constraint(:stack_id)

  end

end

defmodule OpenAgents.Stacks.StackEvent do

  @moduledoc """

  A transactional outbox row for one stack mutation.

  Every explicit stack mutation writes an event inside the same metadata

  transaction, so consumers replay the mutation history without racing the

  request handler. Consumers deduplicate by event ID.

  """

  use Ecto.Schema

  import Ecto.Changeset

  @primary_key {:id, :binary_id, autogenerate: true}

  @foreign_key_type :binary_id

  @timestamps_opts [type: :utc_datetime_usec]

  @event_types ~w(pull_request_stack.created pull_request_stack.appended)

  schema "pull_request_stack_events" do

    belongs_to :stack, OpenAgents.Stacks.Stack

    field :event_type, :string

    field :stack_version, :integer

    belongs_to :actor_user, OpenAgents.Accounts.User

    field :payload, :map, default: %{}

    timestamps()

  end

  def changeset(event, attrs) do

    event

    |> cast(attrs, [:event_type, :stack_version, :payload])

    |> put_change(:stack_id, Map.fetch!(attrs, :stack_id))

    |> put_change(:actor_user_id, Map.get(attrs, :actor_user_id))

    |> validate_required([:stack_id, :event_type, :stack_version, :payload])

    |> validate_inclusion(:event_type, @event_types)

    |> validate_number(:stack_version, greater_than_or_equal_to: 1)

    |> check_constraint(:stack_version, name: :pull_request_stack_events_version_check)

    |> foreign_key_constraint(:stack_id)

    |> foreign_key_constraint(:actor_user_id)

  end

end

      "get /api/v3/repos/:owner/:repo/issues/:issue_number/dependencies" => :optional_bearer,

      "get /api/v3/repos/:owner/:repo/pulls" => :optional_bearer,

      "get /api/v3/repos/:owner/:repo/pulls/:pull_number" => :optional_bearer,

      "get /api/v3/repos/:owner/:repo/stacks" => :optional_bearer,

      "get /api/v3/repos/:owner/:repo/stacks/:stack_number" => :optional_bearer,

      "get /api/v3/repos/:owner/:repo/projectsV2" => :optional_bearer,

      "get /api/v3/repos/:owner/:repo/projectsV2/:project_number" => :optional_bearer,

      "get /api/v3/repos/:owner/:repo/projectsV2/:project_number/items" => :optional_bearer,

      "post /api/v3/orgs/:org/repos/imports" => :required_bearer,

      "post /api/v3/repos/:owner/:repo/issues" => :required_bearer,

      "post /api/v3/repos/:owner/:repo/pulls" => :required_bearer,

      "post /api/v3/repos/:owner/:repo/stacks" => :required_bearer,

      "post /api/v3/repos/:owner/:repo/stacks/:stack_number/append" => :required_bearer,

      # pipe_through :forge_write_api — forum writes and identity claims.

      "post /api/v3/forum/topics" => :required_bearer,

      "post /api/v3/forum/topics/:topic_id/posts" => :required_bearer,

defmodule OpenAgentsWeb.StackController do

  use OpenAgentsWeb, :controller

  alias OpenAgents.Repositories

  alias OpenAgents.Stacks

  alias OpenAgentsWeb.ControllerHelpers

  def index(conn, %{"owner" => owner, "repo" => repo}) do

    repository = Repositories.get_visible_by_path!(owner, repo, conn.assigns[:current_user])

    render(conn, :index, stacks: Stacks.list(repository), owner: owner, repo: repo)

  rescue

    Ecto.NoResultsError -> not_found(conn)

  end

  def show(conn, %{"owner" => owner, "repo" => repo, "stack_number" => number}) do

    repository = Repositories.get_visible_by_path!(owner, repo, conn.assigns[:current_user])

    stack = Stacks.get_by_number!(repository, ControllerHelpers.integer_param!(number))

    render(conn, :show, stack: stack, owner: owner, repo: repo)

  rescue

    Ecto.NoResultsError -> not_found(conn)

  end

  def create(conn, %{"owner" => owner, "repo" => repo} = params) do

    repository = Repositories.get_visible_by_path!(owner, repo, conn.assigns.current_user)

    with {:ok, idempotency_key} <- idempotency_key(conn),

         {:ok, {stack, replay_state}} <-

           Stacks.create_from_api(repository, params, conn.assigns.current_user, idempotency_key) do

      conn

      |> put_status(:created)

      |> render(:show, stack: stack, owner: owner, repo: repo, replay_state: replay_state)

    else

      {:error, reason} -> render_error(conn, reason)

    end

  rescue

    Ecto.NoResultsError -> not_found(conn)

  end

  def append(conn, %{"owner" => owner, "repo" => repo, "stack_number" => number} = params) do

    repository = Repositories.get_visible_by_path!(owner, repo, conn.assigns.current_user)

    with {:ok, idempotency_key} <- idempotency_key(conn),

         {:ok, {stack, replay_state}} <-

           Stacks.append_from_api(

             repository,

             ControllerHelpers.integer_param!(number),

             params,

             conn.assigns.current_user,

             idempotency_key

           ) do

      render(conn, :show, stack: stack, owner: owner, repo: repo, replay_state: replay_state)

    else

      {:error, reason} -> render_error(conn, reason)

    end

  rescue

    Ecto.NoResultsError -> not_found(conn)

  end

  defp idempotency_key(conn) do

    case get_req_header(conn, "idempotency-key") do

      [key] when byte_size(key) in 1..200 ->

        if String.contains?(key, ["\r", "\n", "\0"]),

          do: {:error, :invalid_idempotency_key},

          else: {:ok, key}

      _invalid ->

        {:error, :invalid_idempotency_key}

    end

  end

  defp render_error(conn, :invalid_idempotency_key),

    do: error(conn, :bad_request, "Provide one Idempotency-Key header")

  defp render_error(conn, :forbidden),

    do: error(conn, :forbidden, "You cannot modify stacks in this repository.")

  defp render_error(conn, reason) when reason in [:stack_not_found, :pull_request_not_found],

    do: not_found(conn)

  defp render_error(conn, reason)

       when reason in [

              :idempotency_conflict,

              :stale_stack_version,

              :expected_head_mismatch,

              :stack_not_open

            ],

       do: conflict(conn, reason)

  defp render_error(conn, reason)

       when reason in [

              :invalid_request,

              :invalid_ref,

              :trunk_mismatch,

              :empty_stack,

              :repository_mismatch,

              :cross_repository_head,

              :pull_request_not_open,

              :duplicate_pull_request,

              :duplicate_branch,

              :broken_base_chain,

              :already_stacked,

              :not_stack_top

            ] do

    conn

    |> put_status(:unprocessable_entity)

    |> json(%{message: message(reason), code: Atom.to_string(reason)})

  end

  defp conflict(conn, reason) do

    conn

    |> put_status(:conflict)

    |> json(%{message: message(reason), code: Atom.to_string(reason)})

  end

  defp message(:idempotency_conflict), do: "The idempotency key is already in use."

  defp message(:stale_stack_version), do: "The stack version does not match."

  defp message(:expected_head_mismatch), do: "An expected head OID does not match."

  defp message(:stack_not_open), do: "The stack is not open."

  defp message(:invalid_request), do: "The request body is invalid."

  defp message(:invalid_ref), do: "A ref did not resolve to a commit."

  defp message(:trunk_mismatch), do: "The bottom pull request does not target the trunk ref."

  defp message(:empty_stack), do: "A stack needs at least one pull request."

  defp message(:repository_mismatch), do: "Every pull request must belong to this repository."

  defp message(:cross_repository_head), do: "Every head branch must live in this repository."

  defp message(:pull_request_not_open), do: "Every pull request must be open."

  defp message(:duplicate_pull_request), do: "A pull request appears more than once."

  defp message(:duplicate_branch), do: "A branch appears more than once."

  defp message(:broken_base_chain), do: "The direct-base chain is broken."

  defp message(:already_stacked), do: "A pull request already belongs to an active stack."

  defp message(:not_stack_top), do: "The pull request does not target the current top head."

  defp not_found(conn), do: error(conn, :not_found, "Not Found")

  defp error(conn, status, message), do: conn |> put_status(status) |> json(%{message: message})

end

defmodule OpenAgentsWeb.StackJSON do

  @moduledoc "Renders pull request stacks with their ordered entries."

  def render("index.json", %{stacks: stacks} = assigns),

    do: Enum.map(stacks, &stack(&1, assigns))

  def render("show.json", %{stack: stack} = assigns) do

    json = stack(stack, assigns)

    case Map.get(assigns, :replay_state) do

      nil -> json

      replay_state -> Map.put(json, :replayed, replay_state == :replayed)

    end

  end

  defp stack(stack, assigns) do

    base_url = String.trim_trailing(OpenAgentsWeb.Endpoint.url(), "/")

    owner = assigns.owner

    repo = assigns.repo

    %{

      id: stack.id,

      number: stack.number,

      trunk_ref: stack.trunk_ref,

      state: stack.state,

      health: stack.health,

      version: stack.version,

      size: length(stack.entries),

      entries: Enum.map(stack.entries, &entry(&1, owner, repo, base_url)),

      created_at: stack.inserted_at,

      updated_at: stack.updated_at,

      url: "#{base_url}/api/v3/repos/#{owner}/#{repo}/stacks/#{stack.number}"

    }

  end

  defp entry(entry, owner, repo, base_url) do

    pull_request = entry.pull_request

    %{

      position: entry.position,

      boundary_oid: entry.boundary_oid,

      observed_head_oid: entry.observed_head_oid,

      pull_request: %{

        number: pull_request.issue.number,

        state: pull_request.issue.state,

        head: %{ref: pull_request.head_ref, sha: pull_request.head_sha},

        base: %{ref: pull_request.base_ref, sha: pull_request.base_sha},

        url: "#{base_url}/api/v3/repos/#{owner}/#{repo}/pulls/#{pull_request.issue.number}"

      }

    }

  end

end

    get "/repos/:owner/:repo/pulls", PullRequestController, :index

    get "/repos/:owner/:repo/pulls/:pull_number", PullRequestController, :show

    get "/repos/:owner/:repo/stacks", StackController, :index

    get "/repos/:owner/:repo/stacks/:stack_number", StackController, :show

    get "/repos/:owner/:repo/projectsV2", ProjectController, :index

    get "/repos/:owner/:repo/projectsV2/:project_number", ProjectController, :show

    get "/repos/:owner/:repo/projectsV2/:project_number/items", ProjectController, :items

    patch "/repos/:owner/:repo/issues/:issue_number", IssueController, :update

    post "/repos/:owner/:repo/pulls", PullRequestController, :create

    patch "/repos/:owner/:repo/pulls/:pull_number", PullRequestController, :update

    post "/repos/:owner/:repo/stacks", StackController, :create

    post "/repos/:owner/:repo/stacks/:stack_number/append", StackController, :append

    post "/repos/:owner/:repo/issues/:issue_number/comments", CommentController, :create

    put "/repos/:owner/:repo/issues/comments/:id", CommentController, :update

    patch "/repos/:owner/:repo/issues/comments/:id", CommentController, :update

    20260823050000,

    20260823051500,

    20260823052000,

    20260823053000

    20260823053000,

    20260823054500

  ],

  "required_tables": [

    "users",

defmodule OpenAgents.Repo.Migrations.CreatePullRequestStackApiTables do

  use Ecto.Migration

  def change do

    create table(:pull_request_stack_events, primary_key: false) do

      add :id, :binary_id, primary_key: true

      add :stack_id,

          references(:pull_request_stacks, type: :binary_id, on_delete: :delete_all),

          null: false

      add :event_type, :string, null: false

      add :stack_version, :bigint, null: false

      add :actor_user_id, references(:users, type: :binary_id, on_delete: :nilify_all)

      add :payload, :map, null: false, default: %{}

      timestamps(type: :utc_datetime_usec)

    end

    create index(:pull_request_stack_events, [:stack_id])

    create constraint(:pull_request_stack_events, :pull_request_stack_events_version_check,

             check: "stack_version >= 1"

           )

    create table(:pull_request_stack_idempotency_requests, primary_key: false) do

      add :id, :binary_id, primary_key: true

      add :user_id, references(:users, type: :binary_id, on_delete: :delete_all), null: false

      add :operation, :string, null: false

      add :idempotency_key, :string, null: false

      add :request_digest, :string, null: false

      add :stack_id,

          references(:pull_request_stacks, type: :binary_id, on_delete: :delete_all),

          null: false

      timestamps(type: :utc_datetime_usec)

    end

    create unique_index(:pull_request_stack_idempotency_requests, [

             :user_id,

             :operation,

             :idempotency_key

           ])

    create constraint(

             :pull_request_stack_idempotency_requests,

             :pull_request_stack_idempotency_digest_check,

             check: "request_digest ~ '^[0-9a-f]{64}$'"

           )

  end

end

defmodule OpenAgentsWeb.StackControllerTest do

  use OpenAgentsWeb.ConnCase

  alias OpenAgents.Forge.Repos

  alias OpenAgents.PullRequests.PullRequest

  alias OpenAgents.Repo

  alias OpenAgents.Stacks.IdempotencyRequest

  alias OpenAgents.Stacks.Stack

  alias OpenAgents.Stacks.StackEvent

  import Ecto.Query

  import OpenAgents.IssuesFixtures

  setup do

    base =

      Path.join(

        System.tmp_dir!(),

        "stack-controller-#{System.unique_integer([:positive])}"

      )

    previous_data = Application.get_env(:openagents, :forge_data_dir)

    previous_wal = Application.get_env(:openagents, :forge_wal_dir)

    Application.put_env(:openagents, :forge_data_dir, Path.join(base, "data"))

    Application.put_env(:openagents, :forge_wal_dir, Path.join(base, "wal"))

    on_exit(fn ->

      restore_env(:forge_data_dir, previous_data)

      restore_env(:forge_wal_dir, previous_wal)

      File.rm_rf(base)

    end)

    :ok

  end

  describe "POST /api/v3/repos/:owner/:repo/stacks" do

    test "creates a stack, reads it back, and replays the idempotency key", %{conn: conn} do

      repository = repository_fixture()

      oids = seed_chain(repository, ["layer-1", "layer-2", "layer-3"])

      [pr_1, pr_2, pr_3] = pull_request_chain(repository, oids, ["layer-1", "layer-2", "layer-3"])

      conn = put_forge_api_token(conn, "stack-create", repository)

      body = %{

        trunk_ref: "main",

        pull_requests: [pr_1, pr_2, pr_3],

        expected_heads: %{

          "#{pr_1}" => oids["layer-1"],

          "#{pr_2}" => oids["layer-2"],

          "#{pr_3}" => oids["layer-3"]

        }

      }

      create_conn =

        conn

        |> put_req_header("idempotency-key", "stack-create-1")

        |> post(path(repository), body)

      assert %{

               "number" => 1,

               "trunk_ref" => "main",

               "state" => "open",

               "health" => "healthy",

               "version" => 1,

               "size" => 3,

               "replayed" => false,

               "entries" => [entry_1, entry_2, entry_3]

             } = json_response(create_conn, 201)

      assert %{"position" => 1, "boundary_oid" => boundary_1} = entry_1

      assert boundary_1 == oids["main"]

      assert %{"position" => 2, "boundary_oid" => boundary_2} = entry_2

      assert boundary_2 == oids["layer-1"]

      assert %{"position" => 3, "observed_head_oid" => head_3} = entry_3

      assert head_3 == oids["layer-3"]

      assert [%StackEvent{event_type: "pull_request_stack.created", stack_version: 1}] =

               Repo.all(StackEvent)

      replay_conn =

        conn

        |> put_req_header("idempotency-key", "stack-create-1")

        |> post(path(repository), body)

      assert %{"number" => 1, "replayed" => true} = json_response(replay_conn, 201)

      assert Repo.aggregate(Stack, :count) == 1

      assert Repo.aggregate(IdempotencyRequest, :count) == 1

      show_conn = get(conn, "#{path(repository)}/1")

      assert %{"number" => 1, "size" => 3} = json_response(show_conn, 200)

      index_conn = get(conn, path(repository))

      assert [%{"number" => 1}] = json_response(index_conn, 200)

    end

    test "rejects a reused idempotency key with a different request", %{conn: conn} do

      repository = repository_fixture()

      oids = seed_chain(repository, ["layer-1"])

      [pr_1] = pull_request_chain(repository, oids, ["layer-1"])

      conn = put_forge_api_token(conn, "stack-idem-conflict", repository)

      first =

        conn

        |> put_req_header("idempotency-key", "stack-idem-1")

        |> post(path(repository), %{trunk_ref: "main", pull_requests: [pr_1]})

      assert %{"number" => 1} = json_response(first, 201)

      second =

        conn

        |> put_req_header("idempotency-key", "stack-idem-1")

        |> post(path(repository), %{trunk_ref: "other", pull_requests: [pr_1]})

      assert %{"code" => "idempotency_conflict"} = json_response(second, 409)

    end

    test "requires one Idempotency-Key header", %{conn: conn} do

      repository = repository_fixture()

      conn = put_forge_api_token(conn, "stack-no-key", repository)

      conn = post(conn, path(repository), %{trunk_ref: "main", pull_requests: [1]})

      assert %{"message" => "Provide one Idempotency-Key header"} = json_response(conn, 400)

    end

    test "refuses a caller without write access", %{conn: conn} do

      repository = repository_fixture()

      oids = seed_chain(repository, ["layer-1"])

      [pr_1] = pull_request_chain(repository, oids, ["layer-1"])

      conn = put_forge_api_token(conn, "stack-nonmember")

      conn =

        conn

        |> put_req_header("idempotency-key", "stack-forbidden-1")

        |> post(path(repository), %{trunk_ref: "main", pull_requests: [pr_1]})

      assert json_response(conn, 403)

    end

    test "rejects each structural violation with an explanation", %{conn: conn} do

      repository = repository_fixture()

      oids = seed_chain(repository, ["layer-1", "layer-2", "layer-3"])

      [pr_1, pr_2, pr_3] = pull_request_chain(repository, oids, ["layer-1", "layer-2", "layer-3"])

      conn = put_forge_api_token(conn, "stack-rejections", repository)

      post_stack = fn body, key ->

        conn

        |> put_req_header("idempotency-key", key)

        |> post(path(repository), body)

      end

      response = post_stack.(%{trunk_ref: "main"}, "reject-1")

      assert %{"code" => "invalid_request"} = json_response(response, 422)

      response = post_stack.(%{trunk_ref: "main", pull_requests: [999]}, "reject-2")

      assert json_response(response, 404)

      response =

        post_stack.(%{trunk_ref: "wrong-trunk", pull_requests: [pr_1, pr_2]}, "reject-3")

      assert %{"code" => "trunk_mismatch"} = json_response(response, 422)

      response = post_stack.(%{trunk_ref: "main", pull_requests: [pr_1, pr_3]}, "reject-4")

      assert %{"code" => "broken_base_chain"} = json_response(response, 422)

      response = post_stack.(%{trunk_ref: "main", pull_requests: [pr_1, pr_1]}, "reject-5")

      assert %{"code" => "duplicate_pull_request"} = json_response(response, 422)

      response =

        post_stack.(

          %{

            trunk_ref: "main",