alias OpenAgents.Repo

  alias OpenAgents.Repositories

  alias OpenAgents.Repositories.Repository

  alias OpenAgents.Stacks

  alias OpenAgents.Stacks.Operation

  alias OpenAgents.Stacks.Stack

  alias OpenAgents.Stacks.StackEntry

    end

  end

  @doc """

  Requests a merge selected by pull request rather than by stack.

  The `merge-async` surface submits against one pull request. The request

  resolves the pull request's active stack, defaults the merge method to

  `merge`, and merges the contiguous prefix ending at that layer. An

  unstacked pull request cannot merge through this surface.

  """

  def request_for_pull_request(

        %Repository{} = repository,

        pull_number,

        params,

        %User{} = actor,

        key

      )

      when is_integer(pull_number) and is_binary(key) do

    with {:ok, pull_request} <- find_pull_request(repository, pull_number),

         {:ok, stack_number} <- active_stack_number(pull_request) do

      request =

        params

        |> Map.put("pull_request_number", pull_number)

        |> Map.put_new("merge_method", "merge")

      request_from_api(repository, stack_number, request, actor, key)

    end

  end

  @doc """

  Loads one merge operation for the pull request that submitted it.

  The poll surface outlives stack membership: a merged pull request's

  entry is removed, so the lookup goes through the operation's own

  request rather than the active entry.

  """

  def get_operation_for_pull_request(%Repository{} = repository, pull_number, operation_id)

      when is_integer(pull_number) do

    with {:ok, uuid} <- cast_operation_id(operation_id),

         %Operation{} = operation <- find_merge_operation(repository, uuid),

         %{"pull_request_number" => ^pull_number} <- operation.request do

      {:ok, operation}

    else

      _missing -> {:error, :operation_not_found}

    end

  end

  defp cast_operation_id(operation_id) do

    case Ecto.UUID.cast(operation_id) do

      {:ok, uuid} -> {:ok, uuid}

      :error -> {:error, :operation_not_found}

    end

  end

  defp find_merge_operation(repository, uuid) do

    Repo.one(

      from operation in Operation,

        join: stack in Stack,

        on: operation.stack_id == stack.id,

        where:

          operation.id == ^uuid and stack.repository_id == ^repository.id and

            operation.kind == "merge"

    )

  end

  defp find_pull_request(repository, number) do

    pull_request =

      Repo.one(

        from pr in PullRequest,

          join: issue in Issue,

          on: pr.issue_id == issue.id,

          where: pr.repository_id == ^repository.id and issue.number == ^number

      )

    case pull_request do

      nil -> {:error, :pull_request_not_found}

      %PullRequest{} -> {:ok, pull_request}

    end

  end

  defp active_stack_number(pull_request) do

    case Stacks.active_entry_for_pull_request(pull_request) do

      nil ->

        {:error, :not_stacked}

      %StackEntry{stack_id: stack_id} ->

        {:ok, Repo.one!(from stack in Stack, where: stack.id == ^stack_id, select: stack.number)}

    end

  end

  @doc """

  Executes one claimed merge operation to a terminal state.

  defp ensure_no_active_operation(stack, nil) do

    active =

      Repo.exists?(

      Repo.one(

        from operation in Operation,

          where:

            operation.stack_id == ^stack.id and

              operation.state in ^Operation.active_states()

              operation.state in ^Operation.active_states(),

          limit: 1

      )

    if active, do: {:error, :operation_in_progress}, else: :ok

    case active do

      nil -> :ok

      %Operation{id: id} -> {:error, {:operation_in_progress, id}}

    end

  end

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

  defp ensure_no_active_operation(stack, nil) do

    active =

      Repo.exists?(

      Repo.one(

        from operation in Operation,

          where:

            operation.stack_id == ^stack.id and

              operation.state in ^Operation.active_states()

              operation.state in ^Operation.active_states(),

          limit: 1

      )

    if active, do: {:error, :operation_in_progress}, else: :ok

    case active do

      nil -> :ok

      %Operation{id: id} -> {:error, {:operation_in_progress, id}}

    end

  end

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

      "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/pulls/:pull_number/merge-async/:operation_id" =>

        :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/stacks/:stack_number/operations/:operation_id" =>

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

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

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

      "put /api/v3/repos/:owner/:repo/pulls/:pull_number/merge-async" => :required_bearer,

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

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

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

    Ecto.NoResultsError -> not_found(conn)

  end

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

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

    pull_number = ControllerHelpers.integer_param!(number)

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

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

           Merge.request_for_pull_request(

             repository,

             pull_number,

             params,

             conn.assigns.current_user,

             idempotency_key

           ) do

      conn

      |> put_status(:accepted)

      |> render(:merge_async,

        operation: operation,

        replay_state: replay_state,

        owner: owner,

        repo: repo,

        pull_number: pull_number

      )

    else

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

    end

  rescue

    Ecto.NoResultsError -> not_found(conn)

  end

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

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

    pull_number = ControllerHelpers.integer_param!(params["pull_number"])

    case Merge.get_operation_for_pull_request(repository, pull_number, params["operation_id"]) do

      {:ok, operation} ->

        render(conn, :merge_async,

          operation: operation,

          replay_state: nil,

          owner: owner,

          repo: repo,

          pull_number: pull_number

        )

      {:error, reason} ->

        render_error(conn, reason)

    end

  rescue

    Ecto.NoResultsError -> not_found(conn)

  end

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

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

       when reason in [:stack_not_found, :pull_request_not_found, :operation_not_found],

       do: not_found(conn)

  defp render_error(conn, {:operation_in_progress, operation_id}) do

    conn

    |> put_status(:conflict)

    |> json(%{

      message: message(:operation_in_progress),

      code: "operation_in_progress",

      operation_id: operation_id

    })

  end

  defp render_error(conn, reason)

       when reason in [

              :idempotency_conflict,

              :stale_stack_version,

              :expected_head_mismatch,

              :stack_not_open,

              :operation_in_progress,

              :operation_not_waiting,

              :operation_not_abortable,

              :merge_queue_unavailable

              :broken_base_chain,

              :already_stacked,

              :not_stack_top,

              :not_stacked,

              :resolution_not_found,

              :resolution_parent_mismatch,

              :pull_request_not_in_stack

  defp message(:pull_request_not_in_stack),

    do: "The pull request is not an active entry of this stack."

  defp message(:not_stacked),

    do: "The pull request does not belong to an active stack."

  defp message(:resolution_parent_mismatch),

    do: "The resolution commit does not build on the persisted parent."

    end

  end

  def render("merge_async.json", %{operation: operation} = assigns) do

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

    json = %{

      operation_id: operation.id,

      merge_status: merge_status(operation),

      state: operation.state,

      merge_method: Map.get(operation.request, "merge_method"),

      pull_request: Map.get(operation.request, "pull_request_number"),

      error: operation.error,

      created_at: operation.inserted_at,

      completed_at: operation.completed_at,

      url:

        "#{base_url}/api/v3/repos/#{assigns.owner}/#{assigns.repo}/pulls/#{assigns.pull_number}/merge-async/#{operation.id}"

    }

    case Map.get(assigns, :replay_state) do

      nil -> json

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

    end

  end

  # The external contract collapses internal operation states into the

  # three the poll surface promises: a submitted merge is pending until

  # it either lands or terminates without landing.

  defp merge_status(%{state: state})

       when state in ~w(pending running waiting_for_conflict_resolution waiting_for_checks),

       do: "pending"

  defp merge_status(%{state: "succeeded"}), do: "merged"

  defp merge_status(_operation), do: "failed"

  defp stack(stack, assigns) do

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

    owner = assigns.owner

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

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

    get "/repos/:owner/:repo/pulls/:pull_number/merge-async/:operation_id",

        StackController,

        :merge_async_status

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

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

    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

    put "/repos/:owner/:repo/pulls/:pull_number/merge-async", StackController, :merge_async

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

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

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

                 "restack-active-3"

               )

      {:ok, {_operation, :created}} =

      {:ok, {operation, :created}} =

        Restack.request_from_api(repository, stack.number, %{}, actor, "restack-active-1")

      assert {:error, :operation_in_progress} =

      operation_id = operation.id

      assert {:error, {:operation_in_progress, ^operation_id}} =

               Restack.request_from_api(repository, stack.number, %{}, actor, "restack-active-2")

    end

    end

  end

  describe "PUT /api/v3/repos/:owner/:repo/pulls/:pull_number/merge-async" do

    test "accepts a submission, polls it, replays retries, and reports the active conflict",

         %{conn: conn} do

      repository = repository_fixture()

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

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

      conn = put_forge_api_token(conn, "merge-async", repository)

      assert %{"number" => 1} =

               conn

               |> put_req_header("idempotency-key", "merge-async-create")

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

               |> json_response(201)

      submit_conn =

        conn

        |> put_req_header("idempotency-key", "merge-async-1")

        |> put("#{pulls_path(repository)}/#{pr_1}/merge-async", %{})

      assert %{

               "operation_id" => operation_id,

               "merge_status" => "pending",

               "state" => "pending",

               "merge_method" => "merge",

               "pull_request" => ^pr_1,

               "replayed" => false,

               "url" => poll_url

             } = json_response(submit_conn, 202)

      assert String.ends_with?(

               poll_url,

               "#{pulls_path(repository)}/#{pr_1}/merge-async/#{operation_id}"

             )

      poll_conn = get(conn, "#{pulls_path(repository)}/#{pr_1}/merge-async/#{operation_id}")

      assert %{"operation_id" => ^operation_id, "merge_status" => "pending"} =

               json_response(poll_conn, 200)

      replay_conn =

        conn

        |> put_req_header("idempotency-key", "merge-async-1")

        |> put("#{pulls_path(repository)}/#{pr_1}/merge-async", %{})

      assert %{"operation_id" => ^operation_id, "replayed" => true} =

               json_response(replay_conn, 202)

      second_conn =

        conn

        |> put_req_header("idempotency-key", "merge-async-2")

        |> put("#{pulls_path(repository)}/#{pr_2}/merge-async", %{})

      assert %{"code" => "operation_in_progress", "operation_id" => ^operation_id} =

               json_response(second_conn, 409)

    end

    test "scopes the poll to the submitting pull request", %{conn: conn} do

      repository = repository_fixture()

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

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

      conn = put_forge_api_token(conn, "merge-async-scope", repository)

      assert %{"number" => 1} =

               conn

               |> put_req_header("idempotency-key", "merge-async-scope-create")

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

               |> json_response(201)

      assert %{"operation_id" => operation_id} =

               conn

               |> put_req_header("idempotency-key", "merge-async-scope-1")

               |> put("#{pulls_path(repository)}/#{pr_1}/merge-async", %{})

               |> json_response(202)

      other_conn = get(conn, "#{pulls_path(repository)}/#{pr_2}/merge-async/#{operation_id}")

      assert json_response(other_conn, 404)

      bogus_conn = get(conn, "#{pulls_path(repository)}/#{pr_1}/merge-async/not-a-uuid")

      assert json_response(bogus_conn, 404)

    end

    test "rejects an unstacked pull request and an unknown pull request", %{conn: conn} do

      repository = repository_fixture()

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

      solo = pull_request(repository, "layer-1", "main", oids["main"], oids["layer-1"])

      conn = put_forge_api_token(conn, "merge-async-unstacked", repository)

      solo_conn =

        conn

        |> put_req_header("idempotency-key", "merge-async-solo-1")

        |> put("#{pulls_path(repository)}/#{solo}/merge-async", %{})

      assert %{"code" => "not_stacked"} = json_response(solo_conn, 422)

      missing_conn =

        conn

        |> put_req_header("idempotency-key", "merge-async-missing-1")

        |> put("#{pulls_path(repository)}/999999/merge-async", %{})

      assert json_response(missing_conn, 404)

    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, "merge-async-outsider")

      writer_conn =

        Phoenix.ConnTest.build_conn()

        |> put_forge_api_token("merge-async-owner", repository)

      assert %{"number" => 1} =

               writer_conn

               |> put_req_header("idempotency-key", "merge-async-outsider-create")

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

               |> json_response(201)

      conn =

        conn

        |> put_req_header("idempotency-key", "merge-async-outsider-1")

        |> put("#{pulls_path(repository)}/#{pr_1}/merge-async", %{})

      assert json_response(conn, 403)

    end

  end

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

    test "reads are public for a public repository", %{conn: conn} do

      repository = repository_fixture()

  defp path(repository), do: "/api/v3/repos/#{repository.owner}/#{repository.name}/stacks"

  defp pulls_path(repository),

    do: "/api/v3/repos/#{repository.owner}/#{repository.name}/pulls"

  defp seed_chain(repository, branches) do

    path = Repos.ensure_repo!(repository.storage_key, repository.default_branch)