# frozen_string_literal: true

class Projects::MergeRequestsController < Projects::MergeRequests::ApplicationController
  include ToggleSubscriptionAction
  include IssuableActions
  include RendersCommits
  include RendersAssignees
  include ToggleAwardEmoji
  include IssuableCollections
  include RecordUserLastActivity
  include SourcegraphDecorator
  include DiffHelper
  include Gitlab::Cache::Helpers
  include MergeRequestsHelper
  include ParseCommitDate
  include RapidDiffs::Resource
  include ProductAnalyticsTracking

  prepend_before_action(only: [:index]) { authenticate_sessionless_user!(:rss, permission: :read_merge_request) }
  skip_before_action :merge_request, only: [:index, :bulk_update, :export_csv]
  before_action :apply_diff_view_cookie!, only: [:show, :diffs, :rapid_diffs]
  before_action :disable_query_limiting, only: [:assign_related_issues, :update, :show]
  before_action :authorize_update_issuable!, only: [:close, :edit, :update, :remove_wip, :sort]
  before_action :authorize_read_diff_head_pipeline!, only: [
    :test_reports,
    :exposed_artifacts,
    :coverage_reports,
    :terraform_reports,
    :accessibility_reports,
    :codequality_reports,
    :codequality_mr_diff_reports
  ]
  before_action :set_issuables_index, only: [:index]
  before_action :check_search_rate_limit!, only: [:index], if: -> { params[:search].present? }
  before_action :authenticate_user!, only: [:assign_related_issues]
  before_action :check_user_can_push_to_source_branch!, only: [:rebase]

  before_action only: [:index, :show] do
    push_frontend_feature_flag(:show_merge_request_status_draft, current_user)
  end

  before_action only: [:show, :diffs, :rapid_diffs, :reports] do
    push_frontend_feature_flag(:mr_pipelines_graphql, project)
    push_frontend_feature_flag(:rapid_diffs_on_mr_show, current_user, type: :beta)
    push_frontend_feature_flag(:explicit_mr_work_item_relations, project)
  end

  before_action do
    push_frontend_feature_flag(:merge_widget_stop_polling, current_user)
  end

  around_action :allow_gitaly_ref_name_caching, only: [:index, :show, :diffs, :rapid_diffs, :discussions]

  after_action :log_merge_request_show, only: [:show, :diffs, :rapid_diffs]

  feature_category :code_review_workflow, [
    :assign_related_issues, :bulk_update, :cancel_auto_merge,
    :commit_change_content, :commits, :context_commits, :destroy,
    :discussions, :edit, :index, :merge, :rebase, :remove_wip,
    :show, :diffs, :rapid_diffs, :toggle_award_emoji, :toggle_subscription, :update,
    :versions
  ]

  feature_category :code_testing, [:test_reports, :coverage_reports]
  feature_category :code_quality, [:codequality_reports, :codequality_mr_diff_reports]
  feature_category :code_testing, [:accessibility_reports]
  feature_category :infrastructure_as_code, [:terraform_reports]
  feature_category :continuous_integration, [:pipeline_status, :pipelines, :exposed_artifacts]
  feature_category :continuous_delivery, [:ci_environments_status]

  urgency :high, [:export_csv]
  urgency :low, [
    :index,
    :show,
    :diffs,
    :rapid_diffs,
    :commits,
    :bulk_update,
    :edit,
    :update,
    :cancel_auto_merge,
    :merge,
    :ci_environments_status,
    :destroy,
    :rebase,
    :discussions,
    :pipelines,
    :coverage_reports,
    :test_reports,
    :codequality_mr_diff_reports,
    :codequality_reports,
    :terraform_reports,
    :versions
  ]
  urgency :low, [:pipeline_status, :pipelines, :exposed_artifacts]

  helper_method :rapid_diffs_page_enabled?

  track_internal_event :diffs, name: 'view_merge_request_diffs', additional_properties: { label: 'legacy_diffs' }
  track_internal_event :rapid_diffs, name: 'view_merge_request_diffs', additional_properties: { label: 'rapid_diffs' }

  def index
    @merge_requests = @issuables

    respond_to do |format|
      format.html
      format.atom { render layout: 'xml' }
    end
  end

  def show
    show_merge_request
  end

  def diffs
    show_merge_request
  end

  def rapid_diffs
    unless rapid_diffs_page_enabled?
      cookies.delete(:rapid_diffs_enabled)
      return redirect_to(diffs_project_merge_request_path(project, @merge_request))
    end

    rapid_diffs_presenter.offset = 5
    show_merge_request
  rescue StandardError => exception
    log_exception(exception)

    feedback_link = view_context.link_to(
      _("Leave feedback"),
      "https://gitlab.com/gitlab-org/gitlab/-/work_items/596236",
      class: 'gl-link',
      target: '_blank',
      rel: 'noopener noreferrer'
    )

    redirect_to(
      diffs_project_merge_request_path(project, @merge_request, rapid_diffs_disabled: 'true'),
      alert: safe_format(
        _("Rapid Diffs encountered an error and has been temporarily disabled. " \
          "The page has loaded using the standard diff view. %{feedback_link}"),
        feedback_link: feedback_link
      )
    )
  end

  def commits
    # Get context commits from repository
    @context_commits =
      set_commits_for_rendering(
        @merge_request.recent_context_commits
      )

    per_page = [
      (params[:per_page] || MergeRequestDiff::COMMITS_SAFE_SIZE).to_i,
      MergeRequestDiff::COMMITS_SAFE_SIZE
    ].min
    recent_commits = @merge_request
      .recent_commits(load_from_gitaly: true, limit: per_page, page: params[:page])
      .with_latest_pipeline(@merge_request.source_branch)
      .with_markdown_cache
    @next_page = recent_commits.next_page
    @commits = set_commits_for_rendering(
      recent_commits,
      commits_count: @merge_request.commits_count
    )

    commits_count = if @merge_request.preparing?
                      '-'
                    else
                      @merge_request.commits_count + @merge_request.context_commits_count
                    end

    render json: {
      html: view_to_html_string('projects/merge_requests/_commits'),
      next_page: @next_page,
      count: commits_count
    }
  end

  def pipelines
    set_pipeline_variables
    # Capture total count before pagination to ensure accurate count regardless of current page
    @pipelines_count = @pipelines.count
    @pipelines = @pipelines.page(params[:page])

    Gitlab::PollingInterval.set_header(response, interval: 10_000)

    render json: {
      pipelines: PipelineSerializer
        .new(project: @project, current_user: @current_user)
        .with_pagination(request, response)
        .represent(
          @pipelines,
          disable_coverage: true,
          disable_failed_builds: true,
          disable_manual_and_scheduled_actions: true,
          preload: true,
          preload_statuses: false,
          preload_downstream_statuses: false,
          disable_stage_actions: true
        ),
      count: {
        all: @pipelines_count
      }
    }
  end

  def context_commits
    # Get commits from repository
    # or from cache if already merged
    commits = ContextCommitsFinder.new(project, @merge_request, {
      search: params[:search],
      author: params[:author],
      committed_before: convert_date_to_epoch(params[:committed_before]),
      committed_after: convert_date_to_epoch(params[:committed_after]),
      limit: params[:limit]
    }).execute
    render json: CommitEntity.represent(commits, { type: :full, request: merge_request })
  end

  def test_reports
    reports_response(@merge_request.compare_test_reports(current_user))
  end

  def accessibility_reports
    if @merge_request.has_accessibility_reports?
      reports_response(@merge_request.compare_accessibility_reports)
    else
      head :no_content
    end
  end

  def coverage_reports
    if @merge_request.has_coverage_reports?
      reports_response(@merge_request.find_coverage_reports)
    else
      head :no_content
    end
  end

  # documented in doc/development/rails_endpoints/index.md
  def codequality_mr_diff_reports
    reports_response(@merge_request.find_codequality_mr_diff_reports, head_pipeline)
  end

  # documented in doc/development/rails_endpoints/index.md
  def codequality_reports
    reports_response(@merge_request.compare_codequality_reports)
  end

  def terraform_reports
    reports_response(@merge_request.find_terraform_reports)
  end

  def exposed_artifacts
    if @merge_request.has_exposed_artifacts?
      reports_response(@merge_request.find_exposed_artifacts)
    else
      head :no_content
    end
  end

  def edit
    define_edit_vars
  end

  def update
    @merge_request = ::MergeRequests::UpdateService
      .new(project: project, current_user: current_user, params: merge_request_update_params)
      .execute(@merge_request)

    respond_to do |format|
      format.html do
        if @merge_request.errors.present?
          define_edit_vars

          render :edit
        else
          redirect_to project_merge_request_path(@merge_request.target_project, @merge_request)
        end
      end

      format.json do
        if merge_request.errors.present?
          render json: @merge_request.errors, status: :bad_request
        else
          render json: serializer.represent(@merge_request, serializer: params[:serializer] || 'basic')
        end
      end
    end
  rescue ActiveRecord::StaleObjectError
    define_edit_vars if request.format.html?

    render_conflict_response
  end

  def remove_wip
    @merge_request = ::MergeRequests::UpdateService
      .new(project: project, current_user: current_user, params: { wip_event: 'ready' })
      .execute(@merge_request)

    render json: serialize_widget(@merge_request)
  end

  def commit_change_content
    render partial: 'projects/merge_requests/widget/commit_change_content', layout: false
  end

  def cancel_auto_merge
    return access_denied! unless @merge_request.can_cancel_auto_merge?(current_user)

    AutoMergeService.new(project, current_user).cancel(@merge_request)

    render json: serialize_widget(@merge_request)
  end

  def merge
    access_check_result = merge_access_check

    return access_check_result if access_check_result

    status = merge!

    Gitlab::ApplicationContext.push(merge_action_status: status.to_s)

    if @merge_request.merge_error
      render json: { status: status, merge_error: @merge_request.merge_error }
    else
      render json: { status: status }
    end
  end

  def assign_related_issues
    result = ::MergeRequests::AssignIssuesService
      .new(project: project, current_user: current_user, params: { merge_request: @merge_request })
      .execute

    case result[:count]
    when 0
      flash[:alert] = _("Failed to assign you issues related to the merge request.")
    else
      flash[:notice] = n_("An issue has been assigned to you.", "%d issues have been assigned to you.", result[:count])
    end

    redirect_to(merge_request_path(@merge_request))
  end

  def pipeline_status
    render json: PipelineSerializer
      .new(project: @project, current_user: @current_user)
      .represent_status(head_pipeline)
  end

  def ci_environments_status
    environments =
      if ci_environments_status_on_merge_result?
        EnvironmentStatus.for_deployed_merge_request(@merge_request, current_user)
      else
        EnvironmentStatus.for_merge_request(@merge_request, current_user)
      end

    render json: EnvironmentStatusSerializer.new(current_user: current_user).represent(environments)
  end

  def rebase
    # Measure the web UI rebase journey: from clicking the Rebase button here
    # until RebaseWorker completes it. Started only on this path so the SLI is
    # scoped to the button; rebase_async's other callers (REST API, the /rebase
    # quick action) do not start it.
    experience = Labkit::UserExperienceSli.start(:ui_button_rebase)

    @merge_request
      .rebase_async(current_user.id, skip_ci: Gitlab::Utils.to_boolean(merge_params[:skip_ci], default: false))

    head :ok
  rescue MergeRequest::RebaseLockTimeout => e
    experience.error!(e.message).complete
    render json: { merge_error: e.message }, status: :conflict
  end

  def discussions
    super do |discussion_notes|
      note_ids = discussion_notes.flat_map { |x| x.notes.collect(&:id) }
      merge_request.discussions_diffs.load_highlight(diff_note_ids: note_ids)
    end
  end

  def export_csv
    IssuableExportCsvWorker.perform_async(:merge_request, current_user.id, project.id, finder_options.to_h) # rubocop:disable CodeReuse/Worker

    index_path = project_merge_requests_path(project)
    message = format(_('Your CSV export has started. It will be emailed to %{email} when complete.'),
      email: current_user.notification_email_or_default)
    redirect_to(index_path, notice: message)
  end

  def versions
    return render_404 unless ::Feature.enabled?(:rapid_diffs_on_mr_show, current_user, type: :beta)

    render json: RapidDiffs::DiffCompareVersionsEntity.represent(
      @merge_request,
      diff_id: rapid_diff_options[:diff_id],
      start_sha: rapid_diff_options[:start_sha]
    )
  end

  protected

  alias_method :subscribable_resource, :merge_request
  alias_method :issuable, :merge_request
  alias_method :awardable, :merge_request

  def sorting_field
    MergeRequest::SORTING_PREFERENCE_FIELD
  end

  def merge_params
    params.permit(merge_params_attributes)
  end

  def merge_params_attributes
    MergeRequest::KNOWN_MERGE_PARAMS
  end

  def auto_merge_requested?
    # Support params[:merge_when_pipeline_succeeds] during the transition period
    params[:auto_merge_strategy].present? || params[:merge_when_pipeline_succeeds].present?
  end

  private

  def set_issuables_index
    return if request.format.html?

    super
  end

  def show_merge_request
    close_merge_request_if_no_source_project
    @merge_request.check_mergeability(async: true)

    # We need to handle the exception that the auto merge was missed
    # For example, the approval group was changed and now the approvals are passing
    if @merge_request.auto_merge_enabled? && @merge_request.mergeability_checks_pass?
      Gitlab::EventStore.publish(
        MergeRequests::MergeableEvent.new(
          data: { merge_request_id: @merge_request.id }
        )
      )
    end

    display_limit_warnings

    respond_to do |format|
      format.html do
        render_html_page
      end

      format.json do
        Gitlab::PollingInterval.set_header(response, interval: 10_000)

        if params[:serializer] == 'sidebar_extras'
          cache_context = [
            params[:serializer],
            current_user&.cache_key,
            @merge_request.merge_request_assignees.map(&:cache_key),
            @merge_request.merge_request_reviewers.map(&:cache_key)
          ]

          render_cached(
            @merge_request,
            with: serializer,
            cache_context: ->(_) { [Digest::SHA256.hexdigest(cache_context.to_s)] },
            serializer: params[:serializer]
          )
        else
          render json: serializer.represent(@merge_request, serializer: params[:serializer])
        end
      end

      format.patch do
        next render_404 unless @merge_request.diff_refs

        send_git_patch @project.repository, @merge_request.diff_refs
      end

      format.diff do
        next render_404 unless @merge_request.diff_refs

        send_git_diff @project.repository, @merge_request.diff_refs
      end
    end
  end

  def render_html_page
    preload_assignees_for_render(@merge_request)

    # Build a note object for comment form
    @note = @project.notes.new(noteable: @merge_request)

    @noteable = @merge_request

    @commits_count = if @merge_request.preparing?
                       0
                     else
                       @merge_request.commits_count.to_i + @merge_request.context_commits_count.to_i
                     end

    @diffs_count = get_diffs_count
    @issuable_sidebar = serializer.represent(@merge_request, serializer: 'sidebar')
    @current_user_data = Gitlab::Json
      .dump(UserSerializer.new(project: @project)
      .represent(current_user, {}, MergeRequestCurrentUserEntity))
    @show_whitespace_default = current_user.nil? || current_user.show_whitespace_in_diffs
    @file_by_file_default = current_user&.view_diffs_file_by_file
    if @merge_request.has_coverage_reports?
      @coverage_path = coverage_reports_project_merge_request_path(@project, @merge_request, format: :json)
    end

    @update_current_user_path = expose_path(api_v4_user_preferences_path)
    @endpoint_metadata_url = endpoint_metadata_url(@project, @merge_request)
    @endpoint_diff_batch_url = endpoint_diff_batch_url(@project, @merge_request)
    @linked_file_url = linked_file_url(@project, @merge_request) if params[:file]

    @diffs_batch_cache_key = @merge_request.diffs_batch_cache_key

    set_pipeline_variables

    @number_of_pipelines = @pipelines.size

    render
  end

  def get_diffs_count
    return if commit
    return @merge_request.context_commits_diff.raw_diffs.size if show_only_context_commits?
    return @merge_request.merge_request_diffs.find_by_id(params[:diff_id])&.size if params[:diff_id]
    return @merge_request.merge_head_diff.size if @merge_request.diffable_merge_ref? && params[:start_sha].blank?

    @merge_request.diff_size
  end

  def merge_request_update_params
    merge_request_params.merge!(params.permit(:merge_request_diff_head_sha))
  end

  def head_pipeline
    pipeline = @merge_request.head_pipeline
    pipeline if can?(current_user, :read_pipeline, pipeline)
  end
  strong_memoize_attr :head_pipeline

  def ci_environments_status_on_merge_result?
    params[:environment_target] == 'merge_commit'
  end

  def target_branch_missing?
    @merge_request.has_no_commits? && !@merge_request.target_branch_exists?
  end

  def merge!
    if auto_merge_requested?
      return :failed unless @merge_request.auto_merge_eligible?(strategy: auto_merge_strategy)
    else
      return :failed unless @merge_request.mergeable?
    end

    squashing = params.fetch(:squash, false)
    merge_service = ::MergeRequests::MergeService
      .new(project: @project, current_user: current_user, params: merge_params)

    unless merge_service.hooks_validation_pass?(@merge_request, validate_squash_message: squashing)
      return :hook_validation_error
    end

    return :sha_mismatch if params[:sha] != @merge_request.diff_head_sha

    @merge_request.update(merge_error: nil, squash: squashing)

    if auto_merge_requested?
      if merge_request.auto_merge_enabled?
        # TODO: We should have a dedicated endpoint for updating merge params.
        #       See https://gitlab.com/gitlab-org/gitlab-foss/issues/63130.
        AutoMergeService.new(project, current_user, merge_params).update(merge_request)
      else
        AutoMergeService.new(project, current_user, merge_params)
          .execute(
            merge_request,
            auto_merge_strategy
          )
      end
    else
      # Measure the immediate web merge journey end to end: from accepting the
      # merge here until MergeWorker completes it. This captures Sidekiq enqueue
      # and execution latency that no single request can measure. Started only on
      # this path so the SLI is scoped to immediate web merges; MergeWorker's
      # other callers (GraphQL, auto-merge) do not start it.
      Labkit::UserExperienceSli.start(:immediate_web_merge)

      @merge_request.merge_async(current_user.id, merge_params)

      :success
    end
  end

  def serialize_widget(merge_request)
    cached_data = serializer.represent(merge_request, serializer: 'poll_cached_widget')
    widget_data = serializer.represent(merge_request, serializer: 'poll_widget')
    cached_data.merge!(widget_data)
  end

  def serializer
    @serializer ||= MergeRequestSerializer.new(current_user: current_user, project: merge_request.project)
  end

  def define_edit_vars
    @source_project = @merge_request.source_project
    @target_project = @merge_request.target_project
    @noteable = @merge_request

    # FIXME: We have to assign a presenter to another instance variable
    # due to class_name checks being made with issuable classes
    @mr_presenter = @merge_request.present(current_user: current_user)
  end

  def finder_type
    MergeRequestsFinder
  end

  def check_user_can_push_to_source_branch!
    result = MergeRequests::RebaseService
      .new(project: @merge_request.source_project, current_user: current_user)
      .validate(@merge_request)

    return if result.success?

    render json: { merge_error: result.message }, status: :forbidden
  end

  def merge_access_check
    access_denied! unless @merge_request.can_be_merged_by?(current_user)
  end

  def disable_query_limiting
    # Also see https://gitlab.com/gitlab-org/gitlab/-/issues/20827
    Gitlab::QueryLimiting.disable!('https://gitlab.com/gitlab-org/gitlab/-/issues/20824')
  end

  def reports_response(report_comparison, pipeline = nil)
    if pipeline&.active?
      ::Gitlab::PollingInterval.set_header(response, interval: 3000)

      return render json: '', status: :no_content
    end

    case report_comparison[:status]
    when :parsing
      ::Gitlab::PollingInterval.set_header(response, interval: 3000)

      render json: '', status: :no_content
    when :parsed
      render json: Gitlab::Json.dump(report_comparison[:data]), status: :ok
    when :error
      render json: {
               errors: [report_comparison[:status_reason]],
               status_reason: report_comparison[:status_reason]
             },
        status: :bad_request
    else
      raise "Failed to build comparison response as comparison yielded unknown status '#{report_comparison[:status]}'"
    end
  end

  def log_merge_request_show
    return unless current_user && @merge_request

    ::Gitlab::Search::RecentMergeRequests.new(user: current_user).log_view(@merge_request)
  end

  def authorize_read_diff_head_pipeline!
    render_404 unless can?(current_user, :read_build, merge_request.diff_head_pipeline)
  end

  def show_whitespace
    current_user&.show_whitespace_in_diffs ? '0' : '1'
  end

  def endpoint_metadata_url(project, merge_request)
    params = request.query_parameters.merge(view: 'inline', diff_head: true, w: show_whitespace)

    diffs_metadata_project_json_merge_request_path(project, merge_request, 'json', params)
  end

  def endpoint_diff_batch_url(project, merge_request)
    per_page = current_user&.view_diffs_file_by_file ? '1' : DIFF_BATCH_ENDPOINT_PER_PAGE.to_s
    params = request
      .query_parameters
      .merge(view: 'inline', diff_head: true, w: show_whitespace, page: '0', per_page: per_page)
    params[:ck] = merge_request.diffs_batch_cache_key if merge_request.diffs_batch_cache_key

    diffs_batch_project_json_merge_request_path(project, merge_request, 'json', params)
  end

  def linked_file_url(project, merge_request)
    diff_by_file_hash_namespace_project_merge_request_path(
      format: 'json',
      id: merge_request.iid,
      namespace_id: project&.namespace.to_param,
      project_id: project&.path,
      file_hash: params[:file],
      diff_head: true
    )
  end

  def append_info_to_payload(payload)
    super

    return unless action_name == 'diffs' && @merge_request&.merge_request_diff.present?

    payload[:metadata] ||= {}
    payload[:metadata]['meta.diffs_files_count'] = @merge_request.merge_request_diff.files_count
  end

  def display_limit_warnings
    if @merge_request.reached_versions_limit?
      flash[:alert] = format(
        _("This merge request has reached the maximum limit of %{limit} versions and cannot be updated further. " \
          "Close this merge request and create a new one instead."), limit: Gitlab::CurrentSettings.diff_max_versions)
      return
    end

    return unless @merge_request.reached_diff_commits_limit?

    flash[:alert] = format(
      _("This merge request has reached the maximum limit of %{limit} diff commits and cannot be updated further. " \
        "Close this merge request and create a new one instead."), limit: Gitlab::CurrentSettings.diff_max_commits)
  end

  def diff_file_component(base_args)
    ::RapidDiffs::MergeRequestDiffFileComponent.new(
      **base_args.merge({ merge_request: @merge_request })
    )
  end

  def complete_diff_path
    return project_commit_path(project, commit, format: :diff) if commit

    merge_request_path(merge_request, format: :diff)
  end

  def email_format_path
    return project_commit_path(project, commit, format: :patch) if commit

    merge_request_path(merge_request, format: :patch)
  end

  def rapid_diffs_page_enabled?
    ::Feature.enabled?(:rapid_diffs_on_mr_show, current_user, type: :beta) &&
      params[:rapid_diffs_disabled] != 'true' &&
      (params[:rapid_diffs] == 'true' || cookies[:rapid_diffs_enabled] == 'true')
  end

  def auto_merge_strategy
    params[:auto_merge_strategy] || merge_request.default_auto_merge_strategy
  end

  def tracking_namespace_source
    project.namespace
  end

  def tracking_project_source
    project
  end
end

Projects::MergeRequestsController.prepend_mod_with('Projects::MergeRequestsController')
