В текущей реализации нет гарантий, что для каждого конфликта литера будет заведен diff комментарий с указанием кода. Это связано с тем, что в Gitlab API, на мой взгляд, несколько неудобно организована отправка diff комментариев: необходимо указывать начальную и конечную позиции блоков кода как в старом файле, так и в новом, дополнительно предоставляя sha1 для файла. Но если у вас есть время поиграться с Gitlab API, можно написать еще несколько десятков строк кода и решить эту интересную задачку. Подробнее об Gitlab API можно почитать тут.

В случае нахождения задачи в Jira - будет предоставлен номер задачи и ссылка на нее. Если для задачи присутствует еще и эпик - он также предоставляется в подобном формате. На последней строке всегда присутствует номер версии и сборки.

Если же задача не будет найдена, в release notes будет представлена только информация о версии и номере сборки

Для начала переходим на страницу Firebase.
Если вы еще не создали проект Firebase, нажмите “Add project”.
После создания проекта, ассоциируем его с нашим iOS проектом. Для этого нажимаем “Add app” внутри проекта и выбираем iOS проект.
На данном этапе отобразится 5 шагов, самым главным для нас является “Apple bundle ID” - его берем из настроек проекта в Xcode.
Скачайте GoogleService-Info.plist и добавьте его в корень репозитория с iOS проектом. После завершения всех указанных шагов проект готов к работе.

Добавим возможность выкладывать сборки в Firebase.

Перейдите во вкладку “Release & Monitor” и выберете “App Distribution”. В открывшемся окне, нажмите “Get started”. 

Настройка почти завершена.

Перейдите в таб “Testers & Groups” и добавьте группу для теста “Add group” (при желании можете добавить в нее себя).

На этом настройка тестовых групп завершена, скопируйте название группы - оно понадобится при настройке GitLab CI/CD

Теперь, перейдите в настройки проекта:

В табе “General” располагается информация о проекте и привязанных к нему приложениях. Нас интересует секция “Your apps” - в ней можно найти информацию о проекте и при необходимости ее скорректировать.
Отмечу, что Bundle ID менять для приложения крайне не рекомендую.  При необходимости провести данную процедуру - стоит привязать новое приложение.

Скопируйте значение “App ID” - оно потребуется далее при настройке.

Так как файл довольно объемный, его можно взять из репозитория.
Здесь он представлен для ознакомления

# This file contains the fastlane.tools configuration
# You can find the documentation at https://docs.fastlane.tools
#
# For a list of all available actions, check out
#
#     https://docs.fastlane.tools/actions
#
# For a list of all available plugins, check out
#
#     https://docs.fastlane.tools/plugins/available-plugins
#

# Uncomment the line if you want fastlane to automatically update itself
# update_fastlane
require 'fileutils'

default_platform(:ios)
xcode_select "/Applications/Xcode.app"

platform :ios do
  desc "Build step"
  desc "### Example:"
  desc "```\n[bundler exec] fastlane build_before_tests [--env FASTLANE_ENVIRONMENT]\n```"
  lane :build_before_tests do |options|
    # Checks if all ENV variables were defined in the .env.PROJECT_NAME file
    verify_env_variables(['CICD_CLONE_PATH', 'BUILD_SCHEME', 'CICD_LOGS_HOME', 'CICD_DERIVED_DATA_PATH', 'DESTINATION', 'CICD_BUILD_RESULTS_PATH'])

    # Perform linting
    perform_linting()

    # Define project location based on Xcode project or workspace
    project_location = ENV['CICD_CLONE_PATH'] + (ENV['XCWORKSPACE'].empty? ? ENV['XCODEPROJ'] : ENV['XCWORKSPACE'])
    puts "Project location:\t #{ project_location}"

    # Prepare build with fastlane scan
    scan(
      project: ENV['XCWORKSPACE'].empty? ? project_location : nil,
      workspace: ENV['XCWORKSPACE'].empty? ? nil : project_location,
      scheme: ENV['BUILD_SCHEME'],
      configuration: "Release",
      buildlog_path: ENV['CICD_LOGS_HOME'],
      derived_data_path: ENV['CICD_DERIVED_DATA_PATH'],
      destination: ENV['DESTINATION'],
      code_coverage: true,
      output_directory: ENV['CICD_BUILD_RESULTS_PATH'],
      skip_build: false,
      build_for_testing: true,
      clean: false
    )
  end


  desc "Prepare tests for project"
  desc "### Examples:"
  desc "```\n[bundler exec] fastlane run_unit_tests [--env FASTLANE_ENVIRONMENT]\n```"
  lane :run_unit_tests do |options|
    # Checks if all ENV variables were defined in the .env.PROJECT_NAME file
    verify_env_variables(['CICD_CLONE_PATH', 'TEST_SCHEME', 'CICD_LOGS_HOME', 'CICD_DERIVED_DATA_PATH', 'DESTINATION', 'CICD_TEST_RESULTS_PATH'])

    # Define project location based on Xcode project or workspace
    project_location = ENV['CICD_CLONE_PATH'] + (ENV['XCWORKSPACE'].empty? ? ENV['XCODEPROJ'] : ENV['XCWORKSPACE'])
    puts "Project location:\t #{ project_location}"

    # Perform test with fastlane scan
    scan(
      project: ENV['XCWORKSPACE'].empty? ? project_location : nil,
      workspace: ENV['XCWORKSPACE'].empty? ? nil : project_location,
      scheme: ENV['TEST_SCHEME'],
      configuration: "Debug",
      buildlog_path: ENV['CICD_LOGS_HOME'],
      derived_data_path: ENV['CICD_DERIVED_DATA_PATH'],
      destination: ENV['DESTINATION'], 
      test_without_building: false,
      output_directory: ENV['CICD_TEST_RESULTS_PATH'],
      clean: false,
      include_simulator_logs: false
     )
  end


  desc "Prepare IPA archive"
  desc "The lane to run by developers or CI/CD"
  desc "### Examples:"
  desc "```\n[bundler exec] fastlane build_archive type:\"development\" export_method:\"development\" [--env FASTLANE_ENVIRONMENT]\n```"
  desc "```\n[bundler exec] fastlane build_archive type:\"adhoc\" export_method:\"ad-hoc\" [--env FASTLANE_ENVIRONMENT]\n```"
  desc "### Options:"
  desc " * **`type`**: must be: [\"appstore\", \"adhoc\", \"development\", \"enterprise\", \"developer_id\", \"mac_installer_distribution\", \"developer_id_installer\"]"
  desc " * **`export_method`**: export_method must be: [\"app-store\", \"validation\", \"ad-hoc\", \"package\", \"enterprise\", \"development\", \"developer-id\", \"mac-application\"]"
  lane :build_archive do |options|
    # Checks if all ENV variables were defined in the .env.PROJECT_NAME file
    verify_env_variables(['CICD_ARCHIVES_LOCATION', 'CICD_RELEASE_NOTES_FILE_PATH', 'CICD_CLONE_PATH', 'XCODEPROJ', 'BUILD_SCHEME', 'PROJECT_NAME', 'CICD_IPA_ARCHIVE_NAME', 'APP_BUNDLE_ID', 'APP_CERTIFICATES_STORE'])

    # Prepare paths for archive and release notes
    archive_location = ENV['CICD_ARCHIVES_LOCATION']
    release_notes_path = ENV['CICD_RELEASE_NOTES_FILE_PATH']

    if File.exist?(release_notes_path)
      sh "cat /dev/null > #{release_notes_path}"
    else
      FileUtils.mkdir_p(archive_location)
      FileUtils.touch(release_notes_path)
    end 

    # Sync code signing
    sync_code_signing(
          type: options[:type],
          app_identifier: ENV['APP_BUNDLE_ID'],
          readonly: true,
          git_url: ENV['APP_CERTIFICATES_STORE']
    )
    
    # Preparing release notes
    current_branch_name = git_current_branch(ENV['CICD_CLONE_PATH'])
    ticket_number = current_branch_name.match(/(?:\/)([A-Z]+-\d+)/)[1]
    prepare_release_notes(
      ticket_number: "#{ticket_number}"
    )
    parsed_version, parsed_build = parse_version_and_build("#{release_notes_path}")
    new_build = parsed_build.to_i
    new_version = parsed_version.to_i

    # Incrementing build number for archive
    increment_build_number(
      xcodeproj: ENV['CICD_CLONE_PATH'] + ENV['XCODEPROJ'],
      build_number: "#{new_build}"
    )

    # Define project location based on Xcode project or workspace
    project_location = ENV['CICD_CLONE_PATH'] + (ENV['XCWORKSPACE'].empty? ? ENV['XCODEPROJ'] : ENV['XCWORKSPACE'])
    puts "Project location:\t #{ project_location}"
     
    # Determine configuration
    configuration = options[:type] == "appstore" ? "Release" : "Debug"
 
    # Preparing ipa archive with fastlane gym
    gym(
      project: ENV['XCWORKSPACE'].empty? ? project_location : nil,
      workspace: ENV['XCWORKSPACE'].empty? ? nil : project_location,
      scheme: ENV['BUILD_SCHEME'],
      configuration: configuration,
      clean: true,
      output_directory: archive_location,
      output_name: ENV['CICD_IPA_ARCHIVE_NAME'],
      export_method: options[:export_method],
      skip_package_dependencies_resolution: true
    )
  end
  

  desc "Send IPA archive to Testflight"
  desc "### Examples:"
  desc "```\n[bundler exec] fastlane deploy_tf skip_submission:true [--env FASTLANE_ENVIRONMENT]\n```"
  desc "### Options:"
  desc " * **`skip_submission`**: skip the distributing action of pilot and only upload the ipa file true|false(by default)"
  lane :deploy_tf do |options|
    # Checks if all ENV variables were defined in the .env.PROJECT_NAME file
    verify_env_variables(['CICD_ARCHIVES_LOCATION', 'PROJECT_NAME', 'CICD_IPA_FULL_PATH', 'APP_BUNDLE_ID', 'APP_CERTIFICATES_STORE'])

    # Sync code signing
    sync_code_signing(
      type: "development",
      app_identifier: ENV['APP_BUNDLE_ID'],
      readonly: true,
      git_url: ENV['APP_CERTIFICATES_STORE']
    )
    
    # Get credentials for App Store Connect
    apiKey = app_store_connect_api_key(
      is_key_content_base64: true,
      duration: 1200,
      in_house: false # if it is enterprise or not
    )
    
    # Send .ipa archive to the Testflight silently
    testflight(
      app_identifier: options[:appIdentifier],
      skip_waiting_for_build_processing: options[:skip_submission],
      skip_submission: options[:skip_submission],
      ipa: ENV['CICD_IPA_FULL_PATH'],
      api_key: apiKey,
      changelog: ""
    )
  end


  desc "Send Archive to Firebase" 
  desc "### Examples:"
  desc "```\n[bundler exec] fastlane deploy_firebase [--env FASTLANE_ENVIRONMENT]\n```"
  desc "### Options:"
  desc " * **`fb_groups`**: testers groups created in firebase concole app distribution tab"
  desc " * **`fb_release_notes`**: release notes for the specified project archive"
  lane :deploy_firebase do |options|
    # Checks if all ENV variables were defined in the .env.PROJECT_NAME file
    verify_env_variables(['FB_APP_KEY', 'FB_TEST_GROUPS', 'CICD_RELEASE_NOTES_FILE_PATH', 'CICD_IPA_FULL_PATH'])

    # Push ipa archive with specified release notes to the Firebase App Distribution with notification to the specified test groups
    release = firebase_app_distribution(
      app: ENV['FB_APP_KEY'],
      testers: ENV['FB_TEST_GROUPS'],
      release_notes_file: ENV['CICD_RELEASE_NOTES_FILE_PATH'],
      ipa_path: ENV['CICD_IPA_FULL_PATH']
    )
  end


  desc "Get certificates for specified project"
  desc "### Examples:"
  desc "```\n[bundler exec] fastlane certificates [--env FASTLANE_ENVIRONMENT]\n```"
  lane :certificates do |options|
    # Checks if all ENV variables were defined in the .env.PROJECT_NAME file
    verify_env_variables(['APP_BUNDLE_ID', 'APP_CERTIFICATES_STORE'])

    sync_code_signing(
      type: "development",
      app_identifier: ENV['APP_BUNDLE_ID'],
      force_for_new_devices: true,
      git_url: ENV['APP_CERTIFICATES_STORE'],
      readonly: true
    )
    sync_code_signing(
      type: "adhoc",
      app_identifier: ENV['APP_BUNDLE_ID'],
      force_for_new_devices: true,
      git_url: ENV['APP_CERTIFICATES_STORE'],
      readonly: true
    )
    sync_code_signing(
      type: "appstore",
      app_identifier: ENV['APP_BUNDLE_ID'],
      git_url: ENV['APP_CERTIFICATES_STORE'],
      readonly: true
    )
  end


  desc "Generate new certificates for specified project"
  desc "### Examples:"
  desc "```\n[bundler exec] fastlane generate_new_certificates [--env FASTLANE_ENVIRONMENT]\n```"
  lane :generate_new_certificates do |options|
    # Checks if all ENV variables were defined in the .env.PROJECT_NAME file
    verify_env_variables(['APP_BUNDLE_ID', 'APP_CERTIFICATES_STORE'])

    sync_code_signing(
      type: "development",
      app_identifier: ENV['APP_BUNDLE_ID'],
      git_url: ENV['APP_CERTIFICATES_STORE'],
      force_for_new_devices: true,
      readonly: false
    )
    sync_code_signing(
      type: "adhoc",
      app_identifier: ENV['APP_BUNDLE_ID'],
      git_url: ENV['APP_CERTIFICATES_STORE'],
      force_for_new_devices: true,
      readonly: false
    )
    sync_code_signing(
      type: "appstore",
      app_identifier: ENV['APP_BUNDLE_ID'],
      git_url: ENV['APP_CERTIFICATES_STORE'],
      force_for_new_devices: true,
      readonly: false
    )  
  end


  desc "Lint step"
  desc "### Examples:"
  desc "```\n[bundler exec] fastlane perform_linting [--env FASTLANE_ENVIRONMENT]\n```"
  lane :perform_linting do |options|
    # Checks if all ENV variables were defined in the .env.PROJECT_NAME file
    verify_env_variables(['CICD_CLONE_PATH', 'CICD_LINTER_LOCK_FILE', 'CICD_LINTER_RESULTS_FILE'])
  
    # Frist three variables - just for readability
    cicd_clone_path = ENV['CICD_CLONE_PATH']
    linter_lock_file = ENV['CICD_LINTER_LOCK_FILE']
    linter_result_file = ENV['CICD_LINTER_RESULTS_FILE']
    previous_merge_commit = git_last_merge_commit(cicd_clone_path)
    current_commit = git_current_commit(cicd_clone_path)
    current_branch_name = git_current_branch(cicd_clone_path)

    puts "Previous merge commit hash:\t #{previous_merge_commit}"
    puts "Last commit hash:\t\t #{current_commit}"
    puts "Swiftlint lock file:\t  #{linter_lock_file}"
    
    # Reading installed lock or prepareing linter internal files 
    linter_commit = read_linter_commit(linter_lock_file)

    if linter_commit == current_commit
      puts "Linting was already performed for the current commit. Skipping lint steps."
    else
      files_to_lint = git_diff_swift_files(previous_merge_commit, current_commit, cicd_clone_path)
      puts "Files to lint: #{files_to_lint}"

      if files_to_lint.empty?
        puts "No swift files changed. Skipping lint"
      else 
        lint_swift_files(files_to_lint, linter_result_file, cicd_clone_path, current_branch_name)
      end

      File.open(linter_lock_file, "w") { |file| file.write(current_commit) }
    end
  end
  

  desc "Send message to Gitlab"
  desc "### Examples:"
  desc "```\n[bundler exec] fastlane send_message commit_ref:\"BRANCH_NAME\" file_to_comment:\"FILEPATH\" line_to_comment:\"\"  gitlab_message:\"MESSAGE_TO_POST\" [--env FASTLANE_ENVIRONMENT]\n```"
  desc "### Options:"
  desc "* **`commit_ref`**: current brnach name. This will be used to detect opened MR"
  desc "* **`gitlab_message`**: message to post in the new MR thread"
  desc "* **`file_to_comment`**: file to add comment to. Note that all subpaths of the project should be included, providing just file name is not sufficient."
  desc "* **`line_to_comment`**: line in the file that should be comented"
  lane :send_message do |options|
    # Checks if all ENV variables were defined in the .env.PROJECT_NAME file
    verify_env_variables(['GIT_PROJECT_ID', 'CI_API_TOKEN'])

    merge_request_iid = get_merge_request_iid(options[:commit_ref])
    if merge_request_iid
      json_data = prepare_json_data(options, merge_request_iid)
      post_comment_to_merge_request(options, merge_request_iid, json_data)
    else
      UI.error("Failed to retrieve merge request IID")
    end
  end


  desc "Get project information from JIRA"
  desc "### Examples:"
  desc "```\n[bundler exec] fastlane get_jira_info ticket_number:\"TICKET_NUMBER\" [--env FASTLANE_ENVIRONMENT]\n```"
  desc "### Options:"
  desc " * **`ticket_number`**: ticket number usually corresponds to branch_name in project"
  lane :get_jira_info do |options|
    # Checks if all ENV variables were defined in the .env.PROJECT_NAME file
    verify_env_variables(['CICD_RELEASE_NOTES_FILE_PATH', 'JIRA_API_KEY','JIRA_HOST_NAME', 'JIRA_TICKET_URL'])

    # Gather ticket related data
    ticket_summary = execute_jira_api_get_request("/issue/#{options[:ticket_number]}/?fields=summary")
    if ticket_summary.include?('errorMessages') || ticket_summary.include?('Not Found')
      puts "Couldn't find relevant ticket information in JIRA. Skipping all steps."
    else
      ticket_link="#{ENV['JIRA_TICKET_URL']}/#{options[:ticket_number]}"
      ticket_notes="Ticket:\t#{options[:ticket_number]}\t#{ticket_link}\n"

      # Gather Epic related information
      editmeta_response = execute_jira_api_get_request("/issue/#{options[:ticket_number]}/editmeta")
      epic_custom_field_id = `echo '#{editmeta_response}' | jq -r '.fields | to_entries[] | select(.value.name == "Epic Link") | .value.fieldId' | tr -d '\n'`
      epic_ticket_response = execute_jira_api_get_request("/issue/#{options[:ticket_number]}?fields=#{epic_custom_field_id}")
      epic_ticket_number = `echo '#{epic_ticket_response}' | jq -r '.fields.#{epic_custom_field_id}' | tr -d '\n'`
      if epic_ticket_number && !epic_ticket_number.strip.empty? && epic_ticket_number != "null"
        epic_ticket_link="#{ENV['JIRA_TICKET_URL']}/#{epic_ticket_number}"
        ticket_notes+="Epic:\t#{epic_ticket_number}\t#{epic_ticket_link}\n"
      end
        
      # Write ticket information to release notes file
      File.open(ENV['CICD_RELEASE_NOTES_FILE_PATH'], "a") { |file| file.puts ticket_notes }
    end
  end
  
  desc "Saves version and build info to the release notes"
  desc "### Examples:"
  desc "```\n[bundler exec] fastlane prepare_release_notes ticket_number:\"TICKET_NUMBER\"  [--env FASTLANE_ENVIRONMENT]\n```"
  desc "### Options:"
  desc " * **`ticket_number`**: ticket number usually corresponds to branch_name in project"
  lane :prepare_release_notes do |options|
    # Checks if all ENV variables were defined in the .env.PROJECT_NAME file
    verify_env_variables(['CICD_CLONE_PATH', 'XCODEPROJ'])

    # Gathering current version and build of the project
    project_location = ENV['CICD_CLONE_PATH'] + ENV['XCODEPROJ']
    version_number = get_version_number(xcodeproj: project_location)
    build_number = latest_testflight_build_number()
    puts "Local Version Number:\t\t#{version_number}"
    puts "Current Testflight Build Number:\t#{build_number}"

    # Adding ticket relevant information to the release notes
    if options[:ticket_number]
      ticket_number = options[:ticket_number]&.upcase
      puts "Ticket number: #{ticket_number}"
      get_jira_info(ticket_number: ticket_number)
    end

    # Adding version info to the release notes
    build_number += 1
    new_build_info = "Version and build: #{version_number}.#{build_number}"
    File.open(ENV['CICD_RELEASE_NOTES_FILE_PATH'], "a") do |file|
      file.puts "" if file.size > 0
      file.puts new_build_info
    end
  end

  # Methods

  # "Method to get last merge commit"
  def git_last_merge_commit(clone_path)
    `cd #{clone_path} && git log --merges --oneline --format="%H" | head -n1 | tr -d '\n'`
  end

  # "Method to get current commit"
  def git_current_commit(clone_path)
    `cd #{clone_path} && git rev-parse HEAD | tr -d '\n'`
  end

  # "Method to get current branch"
  def git_current_branch(clone_path)
    `cd #{clone_path} && git branch --show-current | tr -d '\n'`
  end

  # "Method to get changed files"
  def git_diff_swift_files(previous_commit, current_commit, clone_path)
  `cd #{clone_path} && git diff #{previous_commit} #{current_commit} --name-only | grep .swift`.split("\n")
  end

  # "Method to read current lock or create linter lock and result files if no lock deteted"
  desc "this prevents on running linter on already processed iteration of pipeline"
  def read_linter_commit(lock_file)
    if File.exist?(lock_file)
      File.read(lock_file).strip
    else
      FileUtils.mkdir_p(File.dirname(lock_file))
      FileUtils.touch(lock_file)
      FileUtils.touch(ENV['CICD_LINTER_RESULTS_FILE'])
      nil
    end
  end

  # "Method to lint specified file"
  def lint_swift_files(files_to_lint, result_file, clone_path, current_branch_name)
    files_to_lint.each do |file|
      swiftlint(
        mode: :lint,
        output_file: result_file,
        config_file: "#{clone_path}.swiftlint.yml",
        files: ["#{clone_path}#{file}"],
        raise_if_swiftlint_error: false,
        ignore_exit_status: true
      )

      parse_linter_results(ENV['CICD_LINTER_RESULTS_FILE'], file, current_branch_name)
    end
  end

  # "Method to parse swiftlint result file"
  def parse_linter_results(result_file, filename, current_branch_name)
    File.open(result_file, "r") do |file|
      file.each_line do |line|
        parsed_data = parse_line(line.chomp)
        if parsed_data
          prepared_string = "**`#{filename}`**  \nSwiftlint #{parsed_data[:issue_level]} at line `#{parsed_data[:line_number]}`  \nlinter rule violated: `#{parsed_data[:rule_name]}`  \n#{parsed_data[:issue_long_description]}"
          send_message(
            commit_ref: "#{current_branch_name}",
            gitlab_message: "#{prepared_string}",
            file_to_comment: "#{filename}",
            line_to_comment: parsed_data[:line_number]
          )
        else
          puts "Failed to parse line."
        end
      end
    end
  end

  # "Method to parse swiftlint result line"
  def parse_line(line)
    pattern = /^(.*\/)*(.+):(\d+):(\d+): (\w+): (.+): (.+) \((\w+)\)$/
    match = line.match(pattern)

    if match
      full_filename = line["#{ENV['CICD_CLONE_PATH']}".length..-1].split(':')[0]
      puts full_filename
      filename = full_filename.sub(/^#{Regexp.escape("#{ENV['CICD_CLONE_PATH']}")}/, '')
      line_number = match[3]
      column_number = match[4]
      issue_level = match[5]
      issue_short_description = match[6]
      issue_long_description = match[7]
      rule_name = match[8]

      return {
        filename: filename,
        line_number: line_number.to_i,
        column_number: column_number.to_i,
        issue_level: issue_level,
        issue_short_description: issue_short_description,
        issue_long_description: issue_long_description,
        rule_name: rule_name
      }
    else
      return nil
    end
  end

  # "Method to parse release notes"
  def parse_version_and_build(file_path)
    version_line = File.readlines(file_path).find { |line| line.start_with?('Version and build:') }
    if version_line
      version_build = version_line.split(':').last.strip
      version, build = version_build.split('.').first(2).join('.'), version_build.split('.').last
      return version, build
    else
      put "Version line not found in file"
    end
  end

  # "Method to get MR id related to the branch"
  def get_merge_request_iid(commit_ref)
    response = execute_gitlab_api_get_request("/merge_requests?scope=all&state=opened&source_branch=#{commit_ref}")
    merge_request_iid = JSON.parse(response).first['iid'] if response && !response.empty?
    merge_request_iid
  end

  #"Method to prepare data for MR comment in Gitlab"
  def prepare_json_data(options, merge_request_iid)
    merge_request_info = execute_gitlab_api_get_request("/projects/#{ENV['GIT_PROJECT_ID']}/merge_requests/#{merge_request_iid}")
    json_data = JSON.parse(merge_request_info)
    diff_refs = json_data['diff_refs']
    base_sha = diff_refs['base_sha']
    start_sha = diff_refs['start_sha']
    head_sha = diff_refs['head_sha']

    characters_to_escape = ['"', "'", '\\', '$', '(', ')', '\\\\']
    escaped_gitlab_message = options[:gitlab_message].gsub(/(#{characters_to_escape.map { |c| Regexp.escape(c) }.join('|')})/, '\\\\\1').gsub("\n", "\\n")
    escaped_gitlab_filepath = options[:file_to_comment].gsub(/(#{characters_to_escape.map { |c| Regexp.escape(c) }.join('|')})/, '\\\\\1')

    "{\"body\": \"#{escaped_gitlab_message}\", \"position\": {\"base_sha\":\"#{base_sha}\", \"start_sha\":\"#{start_sha}\", \"head_sha\": \"#{head_sha}\", \"new_path\": \"#{escaped_gitlab_filepath}\", \"position_type\": \"text\", \"new_line\": #{options[:line_to_comment]}}}"
  end

  # "Method to send comment to Gitlab MR"
  def post_comment_to_merge_request(options, merge_request_iid, json_data)
    response = execute_gitlab_api_post_request("/projects/#{ENV['GIT_PROJECT_ID']}/merge_requests/#{merge_request_iid}/discussions?body=comment", json_data)
    status_code = response.strip.to_i
    if (200..299).include?(status_code)
      UI.success("Diff comment posted successfully")
    else
      UI.error("Failed to apply comment to a code block. Status code: #{status_code}")
      UI.message("Trying to send a simple note to...")
      note_comment_response = execute_gitlab_api_post_request("/projects/#{ENV['GIT_PROJECT_ID']}/merge_requests/#{merge_request_iid}/notes", json_data)
      note_comment_status_code = note_comment_response.strip.to_i
      UI.error("Issue with sending messages to the MR request. Status code: #{note_comment_status_code}") unless (200..299).include?(note_comment_status_code)
    end
  end

  # "Method to execute GET request with Gitlab API"
  def execute_gitlab_api_get_request(endpoint)
    url = "#{ENV['FASTLANE_GITLAB_API_URL']}#{endpoint}"
    `curl -s --request GET --header 'PRIVATE-TOKEN: #{ENV['CI_API_TOKEN']}' '#{url}'`
  end

  # "Method to execute POST request with Gitlab API"
  def execute_gitlab_api_post_request(endpoint, json_data)
    url = "#{ENV['FASTLANE_GITLAB_API_URL']}#{endpoint}"
    `curl -s -o /dev/null --request POST --header "PRIVATE-TOKEN: #{ENV['CI_API_TOKEN']}" --header "Content-Type: application/json" --data '#{json_data}' -w "%{http_code}\n" '#{url}'`
  end
 
  # "Method to execute GET request with JIRA API"
  def execute_jira_api_get_request(endpoint)
    url = "#{ENV['JIRA_HOST_NAME']}#{endpoint}"
    `curl -s --header 'Authorization: Bearer #{ENV['JIRA_API_KEY']}' '#{url}'`
  end

  # "Method to check if ENV variable was defined"
  def verify_env_variables(variables)
    variables.each do |var|
      unless ENV[var]
        puts "Environment variable #{var} is not defined."
        error_message = "Please make sure that #{var} was properly defined in your environment."
        UI.user_error!(error_message)
      end
    end
  end
end