# frozen_string_literal: true

require 'addressable/uri'

class Projects::CompareController < Projects::ApplicationController
  include DiffForPath
  include DiffHelper
  include RendersCommits
  include CompareHelper
  include Projects::TargetProjects
  include RapidDiffs::Resource

  # Authorize
  before_action :require_non_empty_project
  before_action :authorize_read_code!
  # Defining ivars
  before_action :define_diffs, only: [:show, :diff_for_path]
  before_action :define_environment, only: [:show]
  before_action :define_diff_notes_disabled, only: [:show, :diff_for_path]
  before_action :define_commits, only: [:show, :diff_for_path, :signatures]
  before_action :merge_request, only: [:index, :show]
  # Validation
  before_action :validate_refs!

  feature_category :source_code_management
  urgency :low, [:show, :create, :signatures]

  # Diffs may be pretty chunky, the less is better in this endpoint.
  # Pagination design guides: https://design.gitlab.com/components/pagination/#behavior
  COMMIT_DIFFS_PER_PAGE = 20

  def index
    compare_params
  end

  def show
    apply_diff_view_cookie!

    if rapid_diffs_enabled?
      @js_action_name = 'rapid_diffs'
      @rapid_diffs_presenter = ::RapidDiffs::ComparePresenter.new(
        compare,
        diff_view,
        diff_options,
        compare_params
      )
      return render action: :rapid_diffs
    end

    respond_to do |format|
      format.html do
        render locals: { pagination_params: params.permit(:page) }
      end

      format.patch do
        compare ? send_git_patch(source_project.repository, compare.diff_refs) : render_404
      end

      format.diff do
        compare ? send_git_diff(source_project.repository, compare.diff_refs) : render_404
      end
    end
  end

  def diff_for_path
    return render_404 unless compare

    render_diff_for_path(compare.diffs(diff_options))
  end

  def create
    from_to_vars = build_from_to_vars

    if from_to_vars[:from].blank? || from_to_vars[:to].blank?
      flash[:alert] = "You must select a Source and a Target revision"

      redirect_to project_compare_index_path(source_project, from_to_vars)
    elsif compare_params[:straight] == "true"
      redirect_to project_compare_with_two_dots_path(source_project, from_to_vars)
    else
      redirect_to project_compare_path(source_project, from_to_vars)
    end
  end

  def signatures
    respond_to do |format|
      format.json do
        render json: {
          signatures: @commits.select(&:has_signature?).map do |commit|
            {
              commit_sha: commit.sha,
              html: view_to_html_string('projects/commit/_signature', signature: commit.signature)
            }
          end
        }
      end
    end
  end

  def target_projects_json
    render json: ProjectSerializer.new.represent(get_target_projects)
  end

  private

  def build_from_to_vars
    {
      from: compare_params[:from].presence,
      to: compare_params[:to].presence,
      from_project_id: compare_params[:from_project_id].presence
    }
  end

  def validate_refs!
    invalid = [head_ref, start_ref].filter { |ref| !valid_ref?(ref) }

    return if invalid.empty?

    flash[:alert] = "Invalid branch name(s): #{invalid.join(', ')}"
    redirect_to project_compare_index_path(source_project)
  end

  # target == start_ref == from
  def target_project
    strong_memoize(:target_project) do
      target_project =
        if !compare_params.key?(:from_project_id)
          source_project.default_merge_request_target
        elsif compare_params[:from_project_id].to_i == source_project.id
          source_project
        else
          target_projects(source_project).find_by_id(compare_params[:from_project_id])
        end

      # Just ignore the field if it points at a non-existent or hidden project
      next source_project unless target_project && can?(current_user, :read_code, target_project)

      target_project
    end
  end

  # source == head_ref == to
  def source_project
    strong_memoize(:source_project) do
      # Eager load project's avatar url to prevent batch loading
      # for all forked projects
      project&.tap(&:avatar_url)
    end
  end

  def compare
    return @compare if defined?(@compare)

    @compare = CompareService.new(source_project, head_ref).execute(target_project, start_ref, straight: straight)
  end

  def straight
    compare_params[:straight] == "true"
  end

  def start_ref
    @start_ref ||= Addressable::URI.unescape(compare_params[:from]).presence
  end

  def head_ref
    return @ref if defined?(@ref)

    @ref = @head_ref = Addressable::URI.unescape(compare_params[:to]).presence
  end

  def define_commits
    strong_memoize(:commits) do
      if compare.present?
        if Feature.enabled?(:limit_commit_markdown_preload, project)
          commits = compare.commits

          # Only fetch pipeline information when we have fewer than the display limit
          commits = commits.with_latest_pipeline(head_ref) if commits.count < MergeRequestDiff::COMMITS_SAFE_SIZE

          limited, _ = limited_commits(commits, commits.count)

          set_commits_for_rendering(Commit.preload_markdown_cache!(limited), commits_count: commits.count)

        else
          commits = compare.commits.with_markdown_cache

          # Only fetch pipeline information when we have fewer than the display limit
          commits = commits.with_latest_pipeline(head_ref) if commits.count < MergeRequestDiff::COMMITS_SAFE_SIZE

          set_commits_for_rendering(commits)
        end
      else
        []
      end
    end
  end

  def define_diffs
    return if rapid_diffs_enabled?

    @diffs = compare.present? ? compare.diffs(diff_options) : []
  end

  def define_environment
    if compare
      environment_params = if source_project.repository.branch_exists?(head_ref)
                             { ref: head_ref }
                           else
                             { commit: compare.commit }
                           end

      environment_params[:find_latest] = true
      @environment = ::Environments::EnvironmentsByDeploymentsFinder.new(
        source_project,
        current_user,
        environment_params
      ).execute.last
    end
  end

  def define_diff_notes_disabled
    @diff_notes_disabled = compare.present?
  end

  # rubocop: disable CodeReuse/ActiveRecord
  def merge_request
    @merge_request ||= MergeRequestsFinder.new(current_user, project_id: target_project.id).execute.opened
      .find_by(source_project: source_project, source_branch: head_ref, target_branch: start_ref)
  end
  # rubocop: enable CodeReuse/ActiveRecord

  def compare_params
    @compare_params ||= params.permit(:from, :to, :from_project_id, :straight, :to_project_id)
  end

  def diffs_resource(options = {})
    compare&.diffs(diff_options.merge(options))
  end

  def rapid_diffs_force_disabled?
    ::Feature.enabled?(:rapid_diffs_debug, current_user, type: :ops) &&
      params.permit(:rapid_diffs_disabled)[:rapid_diffs_disabled] == 'true'
  end

  def rapid_diffs_enabled?
    ::Feature.enabled?(:rapid_diffs_on_compare_show, current_user, type: :beta) &&
      !rapid_diffs_force_disabled? &&
      params.permit(:format)[:format].blank?
  end
end

Projects::CompareController.prepend_mod
