Before("(@frontend_royalties or @ows_payee or @ows_ledger) and (not @royalties_qa_smoke)") do
  @royalties_db ||= Support::Helpers::RoyaltiesDB.new
  @royalties_db.clear_db
  @royalties_db.clear_dynamodb
end

Before("@delete_dag") do
  @royalties_pg ||= Support::Helpers::RoyaltiesPG.new
  @royalties_pg.clear_dags
end

Before("@sales_file") do
  @royalties_pg ||= Support::Helpers::RoyaltiesPG.new
  @royalties_pg.clear_dags

  sales_file_name = "cucumber_tests_sales_file.tsv"
  file_path = Dir.pwd + "/features/assets/royalties/#{sales_file_name}"
  sales_file_bucket = "qa-royalties-sales-files"

  s3 = Aws::S3::Resource.new(
    region: "us-east-1",
    access_key_id: ENV["AWS_ACCESS_KEY_ID"],
    secret_access_key: ENV["AWS_SECRET_ACCESS_KEY"]
  )

  res = s3.bucket(sales_file_bucket).objects(prefix: "stage", delimiter: "").collect(&:key)
  file_to_delete = res.find { |result| result.include?(sales_file_name) }

  unless file_to_delete.nil?
    s3 = Aws::S3::Client.new(region: "us-east-1")
    s3.delete_object(bucket: sales_file_bucket, key: file_to_delete)
  end

  s3 = Aws::S3::Resource.new(region: "us-east-1")
  obj = s3.bucket("qa-royalties-sales-files").object("stage/#{sales_file_name}")
  obj.upload_file(file_path)
end

After("@sales_file") do
  sales_file_name = "cucumber_tests_sales_file.tsv"
  sales_file_bucket = "qa-royalties-sales-files"

  s3 = Aws::S3::Resource.new(
    region: "us-east-1",
    access_key_id: ENV["AWS_ACCESS_KEY_ID"],
    secret_access_key: ENV["AWS_SECRET_ACCESS_KEY"]
  )

  res = s3.bucket(sales_file_bucket).objects(prefix: "stage", delimiter: "").collect(&:key)
  file_to_delete = res.find { |result| result.include?(sales_file_name) }

  unless file_to_delete.nil?
    s3 = Aws::S3::Client.new(region: "us-east-1")
    s3.delete_object(bucket: sales_file_bucket, key: file_to_delete)
  end
end

Then("I should see correct title and main links") do
  on(Royalties::HomePage) do |page|
    expected_links = ["Contracts", "Accounting Periods", "Admin", "Payees", "Payments"]

    page.wait_until { page.sidebar_link_elements.count > 0 }
    expect(page.breadcrumb_elements.map(&:text)).to eql ["PAYEES"]
    expect(page.sidebar_link_selected_element.text).to eql "Payees"
    expect(page.sidebar_link_elements.map(&:text)).to match_array expected_links
  end
end

And("I should be able to navigate via sidebar") do
  on(Royalties::HomePage) do |page|
    expect(page.sidebar_title_element.text).to eql "Accounting"
    page.sidebar_link_elements.each do |link|
      text = link.text
      link.click
      expect(page.title_element.text).to eql text.upcase
    end
  end
end

Then(/^I should be able to add (Artist|Distributor|Label) payee$/) do |payee_type|
  @payee_currency = "USD (US Dollar)"
  @payee_name = "orcd_autotest_#{Time.now.strftime('%s')}"
  on(Royalties::PayeesPage) do |page|
    page.add_new_payee_element.when_present.click
  end
  on(Royalties::AddPayeePage) do |page|
    expect(page.breadcrumb_elements.map(&:text)).to eql ["PAYEES", "NEW PAYEE"]
    page.fill_payee_basics(@payee_name, payee_type, @payee_currency)

    @contact_details_data = page.return_new_payment_contact_details
    page.fill_payee_payment_contact(@contact_details_data)
  end
  on(Royalties::PayeeDetails) do |page|
    page.wait_until { @browser.url.include?("/payee/") }
  end
  @payee_id = @browser.url.match(%r{\/payee\/(.*)}).captures[0]
  visit(Royalties::PayeeDetails, using_params: { payee_id: @payee_id }) do |page|
    page.wait_until { page.payee_type_element.exists? }
  end
end

And("I should be able to add check payment details") do
  on(Royalties::PayeeDetails) do |page|
    page.wait_until { (page.edit_payment_info_element.exists? || page.add_payment_info_element.exists?) }
  end
  payable_to = "testing_here"
  on(Royalties::PayeeDetails).add_or_edit_payment_info
  on(Royalties::PaymentDetailsPage) do |page|
    page.add_check_details(payable_to)
    page.save_button
  end
end

Then(/^I should be able to add payee with (.*?) payment agreement$/) do |payment_agreement|
  payee_currency = "USD (US Dollar)"
  on(Royalties::PayeesPage).add_new_payee
  on(Royalties::AddPayeePage) do |page|
    expect(page.breadcrumb_elements.map(&:text)).to eql ["PAYEES", "NEW PAYEE"]
    payee_name = "orcd_autotest_#{Time.now.strftime('%s')}"
    page.payee_name_element.send_keys payee_name
    page.select_payee_type "Artist"
    page.select_payee_currency payee_currency
    page.select_payment_agreement_type payment_agreement
    page.create_payee
  end
  on(Royalties::PayeeDetails) do |page|
    page.wait_until(10) do
      page.payment_agreement_type_element.parent.parent.text.include?(payment_agreement)
    end
  end
end

And("I should be able to navigate back to PayeesPage") do
  on(Royalties::PayeeDetails) do |page|
    page.breadcrumb_elements[0].click
  end
  on(Royalties::PayeesPage) do |page|
    page.wait_until { page.add_new_payee? }
  end
  expect(@browser.url).to include "/payees"
end

Then("I should be able to add runcontroller") do
  on(Royalties::RunControllersPage) do |page|
    page.wait_until { page.add_new_run_controller_element.exists? }
    expect(page.breadcrumb_elements.map(&:text)).to eql [
      "ADMIN",
      "MANAGE RUN CONTROLLERS"
    ]
    page.add_new_run_controller
    @runcontroller_name = "orcd_autotest_#{Time.now.strftime('%s')}"
    page.run_controller_name_input_element.send_keys @runcontroller_name
    page.save_runcontroller
    page.wait_until { page.add_new_run_controller? }
    expect(page.runcontrollers_table_element.column_values(0)).to include @runcontroller_name
  end
end

Given("I have a runcontroller created") do
  step "I am on the Royalties::RunControllersPage"
  step "I should be able to add runcontroller"
end

Then("I should be able to view payee details") do
  visit(Royalties::PayeeDetails, using_params: { payee_id: @payee_id }) do |page|
    page.wait_until { page.breadcrumb_elements.map(&:text) == ["PAYEES", @payee_name.upcase] }
    expect(page.payee_type_element.parent.parent.text).to include @payee_type
    expect(page.payee_currency_element.parent.parent.text).to include @payee_currency
    expect(page.payment_details_element.text).to include "Payment Details"
    page.wait_until { page.payment_details_element.text.include?("PAYMENT METHOD") }
    expect(page.payment_details_element.text).to include "PAYMENT METHOD"

    fields_to_check = ["NAME", "EMAIL", "PHONE NUMBER", "ADDRESS",
                       "TOWN/CITY", "STATE/PROVINCE/REGION", "POSTAL CODE", "COUNTRY"]
    # page.show_payment_tax_contract_details_link_element.click
    fields_to_check.each do |elem|
      expect(page.payment_tax_contract_details_section_element.text).to include elem
    end
  end
end

Then("I should be able to view contract details") do
  visit(Royalties::ContractDetails, using_params: { contract_id: @contract_id }) do |page|
    page.wait_until { page.breadcrumb_elements.map(&:text) == ["CONTRACTS", @contract_name.upcase] }
    expect(page.general_section_element.a.text).not_to eql ""
    page.run_controller_section_element.tds[0..1].each do |cell|
      expect(cell.text).not_to eql ""
    end
    # TODO: uncomment once added back
    # expect(page.vendor_section_element.exists?).to be true
    # page.net_share_section_element.tds.each do |cell|
    #   expect(cell.text).not_to eql ""
    # end
    page.breadcrumb_elements[0].click
  end
  on(Royalties::ContractsPage) do |page|
    page.wait_until { page.contracts_table_element.exists? }
    expect(page.breadcrumb_elements.map(&:text)).to eql ["CONTRACTS"]
  end
end

Then("I should be able to create new contract") do
  data = DataHelpers::Contract.royalties_contract_data
  on(Royalties::AddContractPage) do |page|
    page.wait_until { page.contract_name_element.exists? }
    expect(page.breadcrumb_elements.map(&:text)).to eql ["CONTRACTS", "NEW CONTRACT"]
    page.fill_and_create_contract(
      @payee_name, @runcontroller_name, data[:vendor_id], data[:label_share]
    )
  end
end

Given(/^I have a new (.*?) payee created$/) do |payee_type|
  @payee_type = payee_type
  step "I am on the Royalties::PayeesPage"
  step "I should be able to add #{@payee_type} payee"
end

Given("I have a payee with a contract") do
  step "I have an open accounting period"
  step "I have a new contract"
  step "I should be able to view payee details"
end

Then("I should be able to view payee details sub-tabs") do
  on(Royalties::PayeeDetails) do |page|
    expect(page.payee_details_payee_info_tab_element.exists?).to be true
    page.payee_details_payee_info_tab_element.click
    expect(page.general_info_section_element.exists?).to be true
    expect(page.payment_details_section_element.exists?).to be true
    expect(page.payment_eligibility_section_element.exists?).to be true

    expect(page.payee_details_accounting_tab_element.exists?).to be true
    page.payee_details_accounting_tab_element.click
    expect(page.accounting_details_element.exists?).to be true

    expect(page.payee_details_contracts_tab_element.exists?).to be true
    page.payee_details_contracts_tab_element.click
    expect(page.contract_details_element.exists?).to be true
    expect(page.contract_details_element.text).to include @contract_name
  end
end

And("I have a new contract created with this payee") do
  step "I have a runcontroller created"
  step "I am on the Royalties::AddContractPage"
  data = DataHelpers::Contract.royalties_contract_data
  on(Royalties::AddContractPage) do |page|
    page.wait_until { page.contract_name_element.exists? }
    @contract_name = page.fill_and_create_contract(
      @payee_name, @runcontroller_name, data[:vendor_id], data[:label_share]
    )
  end
  on(Royalties::ContractDetails) do |page|
    # page.wait_until { page.payee_section_element.exists? }
    page.wait_until { page.general_section_element.exists? }
    @contract_id = @browser.url.match(%r{\/contract\/(.*)}).captures[0]
  end
end

Then("I should be able to edit payee details") do
  payee_currency = "USD (US Dollar)"
  payee_type = "Label"
  payee_name = "orcd_autotest_#{Time.now.strftime('%s')}"

  on(Royalties::PayeeDetails).edit_payee

  on(Royalties::AddPayeePage) do |page|
    page.wait_until { page.payee_name_element.value != "" }

    i = 0
    until (i == 5) || (page.payee_name_element.value == "")
      page.payee_name_element.clear
      i += 1
    end

    page.payee_name_element.send_keys payee_name
    page.select_payee_type payee_type
    page.select_payee_currency payee_currency
    page.save_payee
  end

  on(Royalties::PayeeDetails) do |page|
    page.wait_until { page.payee_type_element.exists? }
    page.wait_until { page.payee_currency_element.parent.parent.text.include?(payee_currency) }
    expect(page.payee_type_element.parent.parent.text).to include(payee_type)
  end
end

Then("I should be able to see list of contracts of the payee") do
  on(Royalties::ContractDetails) do |page|
    page.wait_until { page.general_section_element.exists? }
    page.a(text: @payee_name).click
  end
  on(Royalties::PayeeDetails) do |page|
    page.wait_until { page.payee_type_element.exists? }
    page.payee_details_contracts_tab_element.click
    page.wait_until(2) { page.td(text: @contract_name).exists? }
    expect(page.td(text: @contract_name).exists?).to be true
  end
end

Given("I have a new contract") do
  step "I have a new Artist payee created"
  step "I have a new contract created with this payee"
  step "I should be able to see list of contracts of the payee"
end

Then("I should be able to add contract adjustments") do
  on(Royalties::PayeeDetails).payee_details_contracts_tab_element.click
  on(Royalties::PayeeDetails).add_adjustments_element.when_present.click
  on(Royalties::AddAdjustment) do |page|
    apply_on_date = (Date.today + 30).strftime("%Y-%m-%d")
    memo = "orcd_autotest"
    amount = "1234"
    currency = "DKK (Danish Krone)"
    formatted_amount = "1,234.00"

    page.add_adjustment
    page.adjustment_amount_element.send_keys amount
    page.select_adjustment_currency(currency)
    page.apply_on_element.send_keys apply_on_date
    page.memo_element.send_keys memo
    page.save_adjustment
    page.wait_until(10) { page.adjustments_table_element.text.include?(apply_on_date) }
    expect(page.adjustments_table_element.text).to include memo
    expect(page.adjustments_table_element.text).to include formatted_amount
  end
end

Then("I should be able to view list of accounting periods") do
  on(Royalties::AccountingPeriodsPage) do |page|
    page.wait_until { page.periods_table_element.exists? }
    expect(page.breadcrumb_elements.map(&:text)).to eql ["ACCOUNTING PERIODS"]
    expect(page.add_new_period_element.exists?).to be true
    expect(page.periods_table_element.exists?).to be true
  end
end

# rubocop:disable Style/GlobalVars

Given(/^I am logged in to abacus application$/) do
  unless $logged
    visit(Royalties::PayeesPage) do |page|
      page.wait_until { page.current_url.include?("qa-orchard.auth0.com") }
    end

    default = DataHelpers::UserConfig.lookup(:workstation, :label_7123_admin)
    on(Workstation::LoginPage) do |page|
      page.login_with(default[:username], default[:password])
      eventually do
        page.wait_until do
          page.current_url.include?(
            "qa-frontend-royalties-standalone.theorchard.io"
          ) || page.current_url.include?(DOMAINS[:royalties])
        end
        page.wait_until { page.current_url.include?("?code") }
        page.wait_until { !page.current_url.include?("?code") }
      end
    end
    $logged = true
  end
end

# rubocop:enable Style/GlobalVars

Given("I have an open accounting period") do
  step "I am on the Royalties::AccountingPeriodsPage"
  on(Royalties::AccountingPeriodsPage) do |page|
    accounting_period_name = "March 2020"

    if page.periods_table_element.rows == 1
      page.add_new_period
      page.period_name_element.send_keys accounting_period_name
      page.save_period
      page.wait_until { page.periods_table_element.rows == 2 }
      page.wait_until { page.periods_table_element.text.include?(accounting_period_name) }
      expect(page.open_period_element.text).to include "Open"
    end
  end
end

And("I have sales file added and processed") do
  step "I open details page for the open period"
  step "I should be able to add sales file"

  response_get_sales_files = Support::Services::OwsRoyalties
                             .retrieve_sales_files(@open_accounting_period_id)

  sales_file_id = JSON.parse(response_get_sales_files.body)[0]["sales_file_id"]

  put_body = {
    "amount" => "19000.0",
    "row_count" => 150,
    "main_url" => "https://orcd_testing.com/#{SecureRandom.uuid}"
  }

  Support::Services::OwsRoyalties.put_sales_file(sales_file_id, put_body)

  visit(Royalties::AccountingPeriodsPage) do |page|
    page.wait_until { page.open_period_element.exists? }
    expect(page.open_period_element.text).to include "Open"
  end
end

And("I should be able to set period to \"All Sales Delivered\"") do
  on(Royalties::AccountingPeriodsDetailsPage) do |page|
    page.deliver_sales
    page.confirm_deliver_sales
    page.wait_until { page.deliver_sales_element.disabled? }
    expect(page.add_sales_form_element.present?).to be false
  end
  visit(Royalties::AccountingPeriodsPage) do |page|
    expect(page.open_period_element.text).to include "\nAll Sales Delivered"
  end
end

Then("accounting period details page should be valid") do
  on(Royalties::AccountingPeriodsDetailsPage) do |page|
    page.wait_until { page.close_period_element.exists? }
    page.wait_until { page.breadcrumb_elements.map(&:text).include?(@period_name.upcase) }
    expect(page.eligible_sales_element.exists?).to be true
    expect(page.manage_runs_table_element.exists?).to be true
    expect(page.close_period_element.exists?).to be true
  end
end

And("I open details page for the open period") do
  visit(Royalties::AccountingPeriodsPage) do |page|
    page.wait_until { page.add_new_period_element.exists? }

    if page.accounting_periods_elements.count.zero?
      puts "There were no accounting periods on QA, can't proceed with current scenario"
      skip_this_scenario
    end

    open_period_element = page.periods_table_element
                              .trs.find do |elem|
                                elem.text.include?("Sales Available") ||
                                  elem.text.include?("All Sales Delivered") ||
                                  elem.text.include?("Open")
                              end
    if open_period_element.nil?
      puts "All accounting periods were closed, can't proceed with current scenario"
      skip_this_scenario
    end

    @period_name = open_period_element.span.text
    open_period_element.span.click
    @open_accounting_period_id = @browser.url.match(%r{period\/(.*)}).captures[0]
  end
end

Then("I should be able to add sales file") do
  on(Royalties::AccountingPeriodsDetailsPage) do |page|
    file_name = "cucumber_tests_sales_file.tsv"

    page.wait_until { page.eligible_sales_element.exists? }
    page.select_sales_file(file_name)
    page.file_display_name_element.send_keys "#{file_name}_#{Time.now.strftime('%s')}"
    page.add_sales_file
    page.wait_until { page.eligible_sales_element.text.include?(file_name) }
  end
end

And("I open run summary details if present") do
  on(Royalties::AccountingPeriodsDetailsPage) do |page|
    page.wait_until { page.close_period_element.exist? }

    # need this as there can be cases when we're having no runs executed on QA
    # and since the QA is read-only for royalties as for now, we have to skip the scenario then
    skip_this_scenario if page.run_details_links_elements.count.zero?
    row_numbr = rand(0..(page.run_details_links_elements.count - 1))
    @number_of_items = page.run_details_links_elements[row_numbr].text
    page.run_details_links_elements[row_numbr].click
    @run_summary_id = @browser.url.match(%r{accounting-run\/(.*)\/summary}).captures[0]
  end
end

Then("I should be able to download run summary details tsv") do
  @summary_download_url = Support::Services::OwsRoyalties.get_run_summary_download_url(@run_summary_id)
  @downloaded_file_path = FileSystemHelpers::Downloader.download(
    @summary_download_url["summary_url"], with_timestamp: false
  ).first
  expect(@downloaded_file_path).to include ".tsv"
end

# rubocop:disable Metrics/BlockLength

And("file content should be valid") do
  require "csv"
  parsed_file = CSV.read(@downloaded_file_path, col_sep: "\t", quote_char: "|")
  on(Royalties::AccountingRunSummaryPage) do |page|
    page.wait_until { page.summary_table_element.trs.count > 0 }
    table_rowcount = page.summary_table_element.tbody.trs.count

    rows_to_check = []
    if table_rowcount > 5
      i = 0
      while i != 5
        rows_to_check << page.summary_table_element.tbody.trs.to_a.sample
        i += 1
      end
    else
      rows_to_check << page.summary_table_element.tbody.trs.to_a.sample
    end

    rows_to_check.each do |row_to_check|
      row_text = row_to_check.text.delete(" ")
      row_text = row_text.gsub("contract0.00", "contract0") if row_text.include?("contract0.00")
      row_text = row_text.delete(",")
      row_text = row_text.downcase

      found = parsed_file.detect { |elem| elem.join.delete(" ").delete(",").downcase == row_text }
      expect(found).to_not be_nil
    end
  end
  parsed_file.each do |line|
    res = parsed_file.detect { |elem| ((elem[0] == line[0]) && (elem[1] != line[1])) }
    parsed_file.delete(res) unless res.nil?
  end
  expect(@number_of_items.to_i).to eql(parsed_file.count - 1)
end

# rubocop:enable Metrics/BlockLength

Then("I should be able to start the accounting run") do
  on(Royalties::AccountingPeriodsDetailsPage) do |page|
    page.wait_until { page.manage_runs_table_element.present? }
    page.deliver_sales
    page.confirm_deliver_sales
    page.run_mech_deductions
    Support::Services::OwsRoyalties.update_accounting_period_status(1, "Mechanicals Calculated")
    page.refresh
    page.wait_until { page.manage_runs_table_element.text.include?(@runcontroller_name) }
    @table_row = page.manage_runs_table_element.trs.find { |row| row.text.include?(@runcontroller_name) }
    @table_row.span(text: "Create").when_present.click
    page.wait_until { page.manage_runs_table_element.text.include?("Waiting to Run") }
    accounitng_runs = Support::Services::OwsRoyalties
                      .retrieve_accounting_runs(@open_accounting_period_id)

    acc_run = JSON.parse(accounitng_runs.body)["items"]
                  .find { |run| run["run_controller_name"] == @runcontroller_name }

    acc_run_id = acc_run["accounting_run_id"]

    Support::Services::OwsRoyalties.put_accounting_run(acc_run_id, "Running")
    page.refresh
    expect(@table_row.text).to include "Running"

    Support::Services::OwsRoyalties.put_accounting_run(acc_run_id, "Complete")
    page.refresh
    expect(@table_row.text).to include "Complete"
  end
end

And("I should be able to invalidate the accounting run") do
  on(Royalties::AccountingPeriodsDetailsPage) do |page|
    page.invalidate_accounting_run_element.click
    page.wait_until { @table_row.text.include?("Invalid") }
  end
end

And("I should be able to commit the accounting run") do
  on(Royalties::AccountingPeriodsDetailsPage) do |page|
    page.commit_accounting_run_element.click
    page.confirm_commit_accounting_run
    page.wait_until { @table_row.text.include?("Committing") }
  end
end

Then("Payees page should be valid") do
  on(Royalties::PayeesPage) do |page|
    page.wait_until { page.payees_table_element.exists? }
    expect(page.add_new_payee_element.present?).to be true
    # expect(page.payee_table_rows.count).to be true
    page.add_new_payee
  end
  on(Royalties::AddPayeePage) do |page|
    expect(page.payee_name_element.present?).to be true
    expect(page.create_payee_element.present?).to be true
  end
end

And("Contracts page should be valid") do
  visit(Royalties::ContractsPage) do |page|
    page.wait_until { page.contracts_table_element.exists? }
    expect(page.add_new_contract_element.present?).to be true
    page.add_new_contract
  end
  on(Royalties::AddContractPage) do |page|
    expect(page.contract_name_element.present?).to be true
    expect(page.payee_field_element.present?).to be true
    expect(page.runcontroller_dropdown_element.present?).to be true
    expect(page.create_contract_element.present?).to be true
  end
end

And("Accounting Periods page should be valid") do
  visit(Royalties::AccountingPeriodsPage) do |page|
    page.wait_until { page.add_new_period_element.exists? }
    expect(page.periods_table_element.present?).to be true
  end
end

And("Admin page should be valid") do
  visit(Royalties::RunControllersPage) do |page|
    page.wait_until { page.runcontrollers_table_element.exists? }
    expect(page.add_new_run_controller_element.present?).to be true
  end
end

When("I have an accounting run") do
  accounting_run_items = @royalties_db.select_accounting_run_items
  accounting_run_id = accounting_run_items.to_a.entries[0]["accounting_run_id"]
  contract_items = @royalties_db.select_contract_items
  contract_id = contract_items.to_a.entries[0]["contract_id"]
  contract_name = contract_items.to_a.entries[0]["name"]
  @summary_item = { "contract_id" => contract_id,
                    "accounting_run_id" => accounting_run_id,
                    "adjustments_total" => "32.00",
                    "period_royalties" => "18.00",
                    "contract_name" => contract_name }
  @royalties_db.update_payee_count(accounting_run_id)

  # there's currently no way to create a run summary item in a DB as a fixture
  @royalties_db.create_run_summary_item(
    @summary_item["accounting_run_id"],
    @summary_item["contract_id"],
    @summary_item["period_royalties"],
    @summary_item["adjustments_total"]
  )
end

Then("I should be able to view Accounting Run Summary page") do
  step "I open details page for the open period"
  on(Royalties::AccountingPeriodsDetailsPage) do |page|
    page.button(text: "1").click
  end
  on(Royalties::AccountingRunSummaryPage) do |page|
    page.wait_until(30) { page.summary_table_element.text.include?(@summary_item["contract_name"]) }
    expect(page.summary_table_element.text).to include @summary_item["contract_name"]
    expect(page.summary_table_element.text).to include @summary_item["adjustments_total"]
    expect(page.summary_table_element.text).to include @summary_item["period_royalties"]
  end
end

Then("I should be able to upload exchange rates file") do
  file_path = "temp/exchange_rates.csv"
  file = CSV.open(file_path, "w", col_sep: "\t") do |csv|
    csv << %w[period_id currency_from_id currency_to_id rate]
    csv << [@open_accounting_period_id, "CAD", "AUD", "0.9"]
  end
  file.close

  on(Royalties::AccountingPeriodsDetailsPage) do |page|
    page.wait_until { page.upload_exchange_rates_div_element.exists? }
    page.upload_exchange_rates("#{Dir.pwd}/#{file_path}")
    page.wait_until { page.exchange_rates_checkmark_element.exists? }
    page.refresh
    page.wait_until { page.upload_exchange_rates_div_element.exists? }
  end
end

And("I should be able to run mechanical deductions") do
  on(Royalties::AccountingPeriodsDetailsPage) do |page|
    page.wait_until { page.manage_runs_table_element.present? }
    page.deliver_sales
    page.confirm_deliver_sales
    page.run_mech_deductions
  end
  visit(Royalties::AccountingPeriodsPage) do |page|
    expect(page.open_period_element.text).to include "Calculating Mechanicals"
    Support::Services::OwsRoyalties.update_accounting_period_status(1, "Mechanicals Calculated")
    page.refresh
    expect(page.open_period_element.text).to include "Mechanicals Calculated"
  end
end

Then("I should be able to skip the accounting run") do
  step "I should be able to set period to \"All Sales Delivered\""
  step "I open details page for the open period"
  on(Royalties::AccountingPeriodsDetailsPage) do |page|
    page.run_mech_deductions
    Support::Services::OwsRoyalties.update_accounting_period_status(1, "Mechanicals Calculated")
    page.refresh
    page.wait_until { !page.staging_url_element.present? }
    counter = 0
    loop do
      break if counter == 10 || page.manage_runs_table_element.text.include?("Skipped")
      counter += 1
      page.skip_accounting_run_element.click
      sleep 1
    end
  end
end

And("I should be able to undo the skip") do
  on(Royalties::AccountingPeriodsDetailsPage) do |page|
    page.undo_skip_accounting_run_element.click
    page.wait_until { page.manage_runs_table_element.text.include?("No Action Taken") }
  end
end

Then("I should be able to fill check payment details info") do
  payable_to = "testinghere"
  on(Royalties::PayeeDetails) do |page|
    page.wait_until { (page.edit_payment_info_element.exists? || page.add_payment_info_element.exists?) }
  end
  on(Royalties::PayeeDetails).add_or_edit_payment_info
  on(Royalties::PaymentDetailsPage) do |page|
    page.add_check_details(payable_to)
    page.save_button
  end
  on(Royalties::PayeeDetails) do |page|
    page.wait_until { page.edit_payment_info_element.exists? }
    expect(page.payment_method_element.text).to include "Check"
    expect(page.payable_to_element.text).to include payable_to
  end
end

Then("I should be able to fill wire transfer payment details info") do
  wire_transfer_details = { account_name: "test",
                            bank_name: "test",
                            bank_origin: "US",
                            account_number: "123456789",
                            routing_number: "123456789",
                            swift_code: "123456789",
                            iban_number: "123456789" }
  on(Royalties::PayeeDetails) do |page|
    page.wait_until { (page.edit_payment_info_element.exists? || page.add_payment_info_element.exists?) }
    page.add_or_edit_payment_info
  end
  on(Royalties::PaymentDetailsPage) do |page|
    page.add_wire_transfer_details(wire_transfer_details)
    page.fill_wt_bank_address
  end
  on(Royalties::PayeeDetails) do |page|
    page.wait_until { page.edit_payment_info_element.exists? }
    expect(page.payment_method_element.text).to include "Wire Transfer"
    expect(page.account_name_element.text).to include wire_transfer_details[:account_name]
    expect(page.bank_name_element.text).to include wire_transfer_details[:bank_name]
  end
end

Then(/^I should be able to fill western union payment details info: (.*?)$/) do |wu_status|
  on(Royalties::PayeeDetails) do |page|
    page.wait_until { (page.edit_payment_info_element.exists? || page.add_payment_info_element.exists?) }
    page.add_or_edit_payment_info
  end
  on(Royalties::PaymentDetailsPage) do |page|
    page.add_western_union_details(wu_status)
    page.save_button
  end
  on(Royalties::PayeeDetails) do |page|
    page.wait_until { page.edit_payment_info_element.exists? }
    expect(page.payment_method_element.text).to include "Western Union"
    expect(page.western_union_status_element.text).to include wu_status
  end
end

Then("I should be able to add Artist payee with payment contact details") do
  on(Royalties::PayeesPage).add_new_payee
  on(Royalties::AddPayeePage) do |page|
    expect(page.breadcrumb_elements.map(&:text)).to eql ["PAYEES", "NEW PAYEE"]
    page.payee_name_element.set "orcd_autotest_#{Time.now.strftime('%s')}"
    page.select_payee_type "Artist"
    page.select_payee_currency "USD (US Dollar)"
    page.select_payment_agreement_type "The Orchard"
    @contact_details_data = page.return_new_payment_contact_details
    page.select_contact_country @contact_details_data[:contact_country]
    page.contact_name_element.set @contact_details_data[:contact_name]
    page.contact_email_element.set @contact_details_data[:contact_email]
    page.contact_phone_element.set @contact_details_data[:contact_phone]
    page.contact_address_element.set @contact_details_data[:contact_address]
    page.contact_city_element.set @contact_details_data[:contact_city]
    page.contact_state_province_element.set @contact_details_data[:contact_state_province]
    page.contact_postal_code_element.set @contact_details_data[:contact_postal_code]
    page.create_payee
  end
  on(Royalties::PayeeDetails) do |page|
    page.wait_until { page.payee_type_element.exists? }
    # page.show_payment_tax_contract_details_link_element.click
    @contact_details_data.each do |elem|
      expect(page.payment_tax_contract_details_section_element.text).to include elem[1]
    end
  end
end

And("I should be able to edit payment contact details") do
  on(Royalties::PayeeDetails).edit_payee
  on(Royalties::AddPayeePage) do |page|
    @contact_details_data = page.return_edit_payment_contact_details
    page.select_contact_country @contact_details_data[:contact_country]
    page.contact_name_element.set @contact_details_data[:contact_name]
    page.contact_email_element.set @contact_details_data[:contact_email]
    page.contact_phone_element.set @contact_details_data[:contact_phone]
    page.contact_address_element.set @contact_details_data[:contact_address]
    page.contact_city_element.set @contact_details_data[:contact_city]
    page.contact_state_province_element.set @contact_details_data[:contact_state_province]
    page.contact_postal_code_element.set @contact_details_data[:contact_postal_code]
    page.save_payee
  end
  on(Royalties::PayeeDetails) do |page|
    page.wait_until { page.payee_type_element.exists? }
    # page.show_payment_tax_contract_details_link_element.click
    @contact_details_data.each do |elem|
      expect(page.payment_tax_contract_details_section_element.text).to include elem[1]
    end
  end
end

Then("I should be able to view payment method minimums") do
  currencies = ["USD (US Dollar)",
                "AUD (Australian Dollar)",
                "CAD (Canadian Dollar)",
                "CHF (Swiss Franc)",
                "DKK (Danish Krone)",
                "EUR (Euro)",
                "GBP (Pound Sterling)",
                "JPY (Yen)",
                "NOK (Norwegian Krone)",
                "SEK (Swedish Krona)"]

  on(Royalties::PaymentMethodMinimumsPage) do |page|
    page.wait_until { page.payment_minimums_section_element.text.include?("USD") }
    currencies.each do |currency|
      expect(page.payment_minimums_section_element.text).to include currency
    end
  end
end

Then("I should be able to edit payment method minimums") do
  on(Royalties::PaymentMethodMinimumsPage).edit_payment_minimums
  on(Royalties::EditPaymentMethodMinimumsPage) do |page|
    @new_values = { check: 40,
                    wire_transfer: 45,
                    western_union: 335 }

    page.us_dollar_check_value_element.set @new_values[:check]
    page.us_dollar_wire_transfer_value_element.set @new_values[:wire_transfer]
    page.us_dollar_western_union_value_element.set @new_values[:western_union]

    page.save
  end
  on(Royalties::PaymentMethodMinimumsPage) do |page|
    page.edit_payment_minimums_element.wait_until(&:present?)
    @browser.refresh
    page.edit_payment_minimums_element.wait_until(&:present?)

    @new_values.values.each do |value|
      page.wait_until { page.payment_minimums_section_element.text.include?("USD") }
      expect(page.payment_minimums_section_element.text).to include value.to_s
    end
  end
end

And("I should be able to see the minimums on the payee's page popup and navigate to admin page from it") do
  step "I am on the Royalties::PayeesPage"
  step "I should be able to add Artist payee"
  step "I should be able to fill check payment details info"

  on(Royalties::PayeeDetails) do |page|
    page.payment_method_info_icon_element.click
    @new_values.values.each do |value|
      expect(page.payment_help_popup_element.text).to include "$#{value}.00 USD"
    end
    page.view_in_admin_link_element.click
  end
  on(Royalties::PaymentMethodMinimumsPage) do |page|
    page.wait_until { page.payment_minimums_section_element.text.include?("USD") }
    @new_values.values.each do |value|
      expect(page.payment_minimums_section_element.text).to include "$#{value}.00"
    end
  end
end

# rubocop:disable Metrics/BlockLength
Then("I should be able to add Artist payee with payment_schedule and payment_minimum") do
  on(Royalties::PayeesPage).add_new_payee

  on(Royalties::AddPayeePage) do |page|
    expect(page.breadcrumb_elements.map(&:text)).to eql ["PAYEES", "NEW PAYEE"]
    page.payee_name_element.set "orcd_autotest_#{Time.now.strftime('%s')}"
    page.select_payee_type "Artist"
    page.select_payee_currency "USD (US Dollar)"
    page.select_payment_agreement_type "The Orchard"
    @payment_schedule = ["30 days after month end", "45 days after month end", "60 days after month end",
                         "90 days after month end", "30 days after quarter end", "45 days after quarter end",
                         "60 days after quarter end", "90 days after quarter end"].sample
    puts "payment_schedule option was: #{@payment_schedule}"
    page.select_payment_schedule @payment_schedule
    @payment_minimum = "450.00"
    page.payment_minimum_element.set @payment_minimum

    @contact_details_data = page.return_new_payment_contact_details
    page.fill_payee_payment_contact(@contact_details_data)
  end
  on(Royalties::PayeeDetails) do |page|
    page.wait_until(10) { page.payment_schedule_element.parent.parent.text.include?(@payment_schedule) }
    expect(page.payment_minimum_element.parent.parent.text).to include @payment_minimum
    page.edit_payee
  end
  on(Royalties::AddPayeePage) do |page|
    page.wait_until { page.payment_minimum_element.value.include?(@payment_minimum) }
    expect(page.payment_schedule_element.text).to include @payment_schedule
    expect(page.payment_minimum_element.value).to eq @payment_minimum
  end
end
# rubocop:enable Metrics/BlockLength

And("I should be able to edit Artist payee with payment_schedule and payment_minimum") do
  on(Royalties::AddPayeePage) do |page|
    @payment_schedule = "90 days after quarter end"
    page.select_payment_schedule @payment_schedule
    @payment_minimum = "150.00"
    page.payment_minimum_element.set @payment_minimum
    page.save_payee
  end
  on(Royalties::PayeeDetails) do |page|
    page.wait_until(10) { page.payment_schedule_element.parent.parent.text.include?(@payment_schedule) }
    expect(page.payment_minimum_element.parent.parent.text).to include @payment_minimum
    page.edit_payee
  end
  on(Royalties::AddPayeePage) do |page|
    page.wait_until { page.payment_minimum_element.value.include?(@payment_minimum) }
    expect(page.payment_schedule_element.text).to include @payment_schedule
    expect(page.payment_minimum_element.value).to eq @payment_minimum
  end
end

And("I should be able to put payee's Payment Eligibility on hold") do
  @hold_reason = "testing hold reason"
  on(Royalties::PayeeDetails) do |page|
    expect(page.payment_hold_status_section_element.text).to include "Active"
    page.edit_payment_eligibility
  end
  on(Royalties::PaymentHoldPage) do |page|
    page.payment_status_on_hold
    page.hold_start_date_element.set Date.parse(Time.now.utc.to_s).to_s
    page.reason_field_element.set @hold_reason
    page.place_hold
  end
  on(Royalties::PayeeDetails) do |page|
    expect(page.payment_hold_status_section_element.text).to include "On Hold"
  end
end

And("I should be able to put payee's Payment Eligibility active") do
  @hold_removal_reason = "no longer on hold"
  on(Royalties::PayeeDetails).edit_payment_eligibility
  on(Royalties::PaymentHoldPage) do |page|
    page.payment_status_active
    page.hold_start_date_element.set Date.parse(Time.now.utc.to_s).to_s
    page.reason_field_element.set @hold_removal_reason
    page.remove_hold
  end
  on(Royalties::PayeeDetails) do |page|
    expect(page.payment_hold_status_section_element.text).to include "Active"
  end
end

Then("I should be able to view payee's payment hold history") do
  on(Royalties::PayeeDetails) do |page|
    page.wait_until(10) { page.payment_hold_section_element.exists? }
    page.wait_until(10) { page.payment_hold_section_element.text.include?("Hold Removed") }
    hold_removed_entry = page.payment_hold_section_element
                             .trs.find { |elem| elem.text.include?("Hold Removed") }
    hold_added_entry = page.payment_hold_section_element
                           .trs.find { |elem| elem.text.include?("Placed On Hold") }
    expect(hold_added_entry.text).to include @hold_reason
    expect(hold_removed_entry.text).to include @hold_removal_reason
    expect(hold_removed_entry.text).to include "Denis S."
    expect(hold_added_entry.text).to include "Denis S."
    expect(hold_removed_entry.text).to include Date.parse(Time.now.utc.to_s).to_s
    expect(hold_added_entry.text).to include Date.parse(Time.now.utc.to_s).to_s
  end
end

# rubocop:disable Metrics/BlockLength

Then("I should be able to add payee's accounting details") do
  visit(Royalties::PayeeDetails, using_params: { payee_id: @payee_id }) do |page|
    page.wait_until { page.payee_type_element.exists? }
  end
  on(Royalties::PayeeDetails) do |page|
    column_names = ["Date", "Opening Balance", "Transaction Type",
                    "Accounting Period", "Amount", "Ending Balance"]
    page.payee_details_accounting_tab_element.click
    expect(page.outstanding_balance_element.present?).to be true
    expect(page.payment_currency_element.present?).to be true

    column_names.each do |name|
      expect(page.accounting_details_element.text).to include name.upcase
    end

    response_get_accounting_periods = Support::Services::OwsRoyalties.retrieve_accounting_periods

    @opened_period = JSON.parse(response_get_accounting_periods.body)["items"]
                         .find { |period| period["closed_date"].nil? }

    accounitng_runs = Support::Services::OwsRoyalties
                      .retrieve_accounting_runs(@opened_period["accounting_period_id"])

    @accounting_run = JSON.parse(accounitng_runs.body)["items"]
                          .find { |run| run["accounting_run_status"] == "No Action Taken" }

    @abacus_event_body = Support::Services::OwsAbacusEvent
                         .generate_abacus_event(@accounting_run["accounting_run_id"])
    response_post_abacus_event = Support::Services::OwsAbacusEvent
                                 .post_abacus_event(@abacus_event_body)
    @ledger_payee_body = Support::Services::OwsLedger.generate_ledger_payee(
      JSON.parse(response_post_abacus_event.body)["abacus_event_id"], @payee_id
    )
    Support::Services::OwsLedger.post_ledger_payee(@ledger_payee_body)
  end
end

# rubocop:enable Metrics/BlockLength

Then("I should be able to view payee's accounting details section") do
  @browser.refresh
  on(Royalties::PayeeDetails) do |page|
    page.payee_details_accounting_tab_element.click
    page.wait_until do
      page.outstanding_balance_element.text.include?(
        @ledger_payee_body[0][:currency_amount].to_s
      )
    end
    expect(page.accounting_details_element.text).to include @opened_period["accounting_period_name"]
    expect(page.accounting_details_element.text).to include @accounting_run["start_date"].to_s
    expect(page.accounting_details_element.text).to include @contract_name
  end
end

Then(/^I should be able to search for a payee by (.*?)$/) do |search_criteria|
  step "I am on the Royalties::PayeesPage"
  on(Royalties::PayeesPage) do |page|
    case search_criteria
    when "name"
      page.search_by_name @payee_name
    when "currency"
      page.search_by_currency "USD (US Dollar)"
    when "agreement"
      page.search_by_agreement "The Orchard"
    when "status"
      page.search_by_status "Missing Info"
    when "balance"
      page.search_by_balance "Greater than 0"
    end
  end
end

# TODO: refactor once page is ready
# This is going to be heavily refactored once page is fully developed so
# I guess it's safe to disable this cop for now
# rubocop:disable Metrics/BlockLength

Then("I should be able to add payment groups") do
  @royalties_pg ||= Support::Helpers::RoyaltiesPG.new
  @royalties_pg.clear_dags

  group_name = "orcd_test_group_#{Time.now.strftime('%s')}"
  on(Royalties::PaymentsPage).new_payment
  on(Royalties::NewPaymentPage) do |page|
    payment_name = "new_group_payment_#{Time.now.strftime('%s')}"
    page.new_group_btn
    page.group_name_element.send_keys group_name
    page.payment_name_element.send_keys payment_name
    page.select_payment_currency "USD (US Dollar)"
    page.select_payment_agreement "Phonofile"
    page.select_payment_schedule "30 days after quarter end"
    page.continue_btn
    page.wait_until(5) { page.payment_group_details_section_element.text.include?(payment_name) }
    expect(page.payment_group_details_section_element.text).to include group_name
  end

  @royalties_pg.clear_dags

  visit(Royalties::PaymentsPage).new_payment
  on(Royalties::NewPaymentPage) do |page|
    payment_name = "existing group payment"
    page.existing_group_btn
    page.payment_name_element.send_keys payment_name
    page.select_group_name group_name
    page.continue_btn
    page.wait_until(5) { page.payment_group_details_section_element.text.include?(payment_name) }
    expect(page.payment_group_details_section_element.text).to include group_name
  end

  @royalties_pg.clear_dags

  visit(Royalties::PaymentsPage).new_payment
  on(Royalties::NewPaymentPage) do |page|
    payment_name = "specific group payment"
    page.specific_group_btn
    page.payment_name_element.send_keys payment_name
    page.select_specific_payee @payee_name
    page.continue_btn
    page.wait_until(5) { page.payment_group_details_section_element.text.include?(payment_name) }
    expect(page.payment_group_details_section_element.text).to include @payee_name
  end
end

# rubocop:enable Metrics/BlockLength

Then("I should be able to add payee to a payment group payment") do
  @payment_group_body = Support::Services::OwsPayment.generate_payment_group_body
  @payment_group_payment_id = Support::Services::OwsPayment
                              .generate_payment_group_payment(@payment_group_body)

  @post_body = [{
    currency_code: "CAD",
    current_balance: "800.00",
    last_payment: "500.00",
    payee_id: @payee_id
  }]
  Support::Services::OwsPayment.post_group_payment_payees_bulk(@payment_group_payment_id, @post_body)

  # payment_statuses = ["initial_review", "sent_for_approval", "approved", "posted"]
  payment_statuses = ["initial_review"]
  payment_statuses.each do |status|
    body = { payment_status: status }
    Support::Services::OwsPayment.put_payment_group_payment(@payment_group_payment_id, body)
  end
end

Then("I should be able to see the payee on a group payment page") do
  visit(Royalties::PaymentPage, using_params: { payee_id: @payment_group_payment_id }) do |page|
    page.payee_tab_element.click
    page.wait_until { page.payees_section_element.text.include?(@payee_name) }
    expect(page.payees_section_element.text).to include @payee_name
    expect(page.payees_section_element.text).to include @post_body[0][:current_balance]
    expect(page.payees_section_element.text).to include @post_body[0][:last_payment]
    expect(page.payees_section_element.text).to include @post_body[0][:currency_code]
  end
end

And("I should be able to see an entry on payment overview section") do
  on(Royalties::PaymentPage) do |page|
    page.payment_overview_tab_element.click
    expect(page.overview_section_element.text).to include @post_body[0][:currency_code]
    expect(page.overview_section_element.text).to include @post_body[0][:current_balance]
    expect(page.overview_section_element.trs.count).to eq 2
  end
end

And("I should be able to see an entry on payments page") do
  visit(Royalties::PaymentsPage) do |page|
    page.wait_until(15) { page.payments_table_element.trs.count == 2 }
    page.wait_until(15) { page.payments_table_element.text.include?(@payment_group_body[:group_name]) }
    expect(page.payments_table_element.text).to include @post_body[0][:current_balance]
    expect(page.payments_table_element.text).to include @post_body[0][:currency_code]
    expect(page.payments_table_element.text).to include Date.parse(Time.now.utc.to_s).to_s
  end
end

Given(/^I have (\d+) payees associated with payment group payment$/) do |nr_of_payees|
  @payees_list = []
  (1..nr_of_payees).each do
    step "I am on the Royalties::PayeesPage"
    step "I should be able to add Artist payee"
    payee = {}
    payee[:id] = @payee_id
    payee[:name] = @payee_name
    @payees_list.push(payee)
  end

  @payment_group_body = Support::Services::OwsPayment.generate_payment_group_body
  @payment_group_payment_id = Support::Services::OwsPayment
                              .generate_payment_group_payment(@payment_group_body)

  @post_body = [{
    currency_code: "CAD", current_balance: "800.00", last_payment: "500.00", payee_id: @payees_list[0][:id]
  },
                {
                  currency_code: "CAD", current_balance: "300.00",
                  last_payment: "100.00", payee_id: @payees_list[1][:id]
                }]
  Support::Services::OwsPayment.post_group_payment_payees_bulk(@payment_group_payment_id, @post_body)

  # payment_statuses = ["initial_review", "sent_for_approval", "approved", "posted"]
  payment_statuses = ["initial_review"]
  payment_statuses.each do |status|
    body = { payment_status: status }
    Support::Services::OwsPayment.put_payment_group_payment(@payment_group_payment_id, body)
  end
end

Then("I should be able to delete a payee from the payment") do
  visit(Royalties::PaymentPage, using_params: { payee_id: @payment_group_payment_id }) do |page|
    page.payee_tab_element.click
    @payees_list.each do |payee|
      expect(page.payees_section_element.text).to include payee[:name]
    end

    payee_to_delete_row = page.payees_section_element
                              .trs.find { |elem| elem.text.include?(@payees_list[0][:name]) }
    payee_to_delete_row.element.hover
    page.trash_icon_element.click
    page.confirm_delete

    page.wait_until(10) { page.payees_section_element.text.include?(@payees_list[1][:name]) }
    page.wait_until(10) { !page.payees_section_element.text.include?(@payees_list[0][:name]) }
  end
end

Then("I should be able to delete the payment") do
  visit(Royalties::PaymentPage, using_params: { payee_id: @payment_group_payment_id }) do |page|
    page.payment_options_element.click
    page.delete_payment_element.click
    page.confirm_delete_payment
  end
  on(Royalties::PaymentsPage) do |page|
    page.wait_until(30) { page.no_results_element.present? }
    page.wait_until(30) { page.payments_table_element.trs.count == 1 }
  end
end

And("I should be able to add a note for a payee") do
  visit(Royalties::PaymentPage, using_params: { payee_id: @payment_group_payment_id }) do |page|
    page.payee_tab_element.click
    page.wait_until(30) { page.payees_section_element.trs.count == 2 }

    note = "test_note"
    page.add_note
    page.note_text_element.send_keys note
    page.save_note

    page.wait_until(30) { page.payees_section_element.text.include?(note) }
  end
end

And("I should be able to approve the payment") do
  @browser.refresh
  on(Royalties::PaymentsPage) do |page|
    page.wait_until { page.payments_table_element.text.include?("Initial Review") }
  end
  visit(Royalties::PaymentPage, using_params: { payee_id: @payment_group_payment_id }) do |page|
    page.send_for_approval
    page.wait_until { page.approve_element.present? }
    expect(page.approvals_count_element.text).to eq "Approvals (0/3)"
  end

  visit(Royalties::PaymentsPage) do |page|
    page.wait_until { page.payments_table_element.text.include?("Sent For Approval") }
  end

  (1..3).each do |i|
    visit(Royalties::PaymentPage, using_params: { payee_id: @payment_group_payment_id }) do |page|
      page.approve
      page.wait_until { page.approvals_count_element.text.include?("Approvals (#{i}/3)") }
    end

    visit(Royalties::PaymentsPage) do |page|
      if i == 3
        page.wait_until { page.payments_table_element.text.include?("Approved") }
      else
        page.wait_until { page.payments_table_element.text.include?("Approvals #{i}/3") }
      end
    end
  end
end

And("I should be able to post the payment") do
  visit(Royalties::PaymentPage, using_params: { payee_id: @payment_group_payment_id }) do |page|
    page.post_payment_element.click
    page.wait_until { page.payment_group_details_element.text.include?("Payment Posted") }
  end
end

Then("I should be able to fill contract term details") do
  visit(Royalties::ContractDetails, using_params: { contract_id: @contract_id }) do |page|
    page.add_base_terms_element.click
  end

  label = "Carly's Test Label"
  transaction_type = "Segments"
  service = "121 Music"
  country = "Poland"
  label_share = "12"
  on(Royalties::EditContractTermsPage) do |page|
    page.select_contract_term_label(label)
    page.select_contract_term_transaction_type(transaction_type)
    page.select_contract_term_service(service)
    page.select_contract_term_country(country)
    page.term_label_share_element.send_keys label_share
    page.save
  end
  on(Royalties::ContractDetails) do |page|
    page.wait_until { page.base_terms_section_element.text.include?(label) }
    expect(page.base_terms_section_element.text).to include service
    expect(page.base_terms_section_element.text).to include country
    expect(page.base_terms_section_element.text).to include label_share
    expect(page.base_terms_section_element.text).to include transaction_type
  end
end

Then("I should be able to add a contract product exception") do
  product_name = "La Copa Rota"
  transaction_type = "Segments"
  service = "121 Music"
  country = "Poland"
  labels_share = "12"
  on(Royalties::ContractDetails) do |page|
    page.add_product_exception_element.click
  end
  on(Royalties::NewContractProductExceptionPage) do |page|
    page.search_for_product product_name
    page.select_transaction_type transaction_type
    page.select_service service
    page.select_country country
    page.labels_share_element.send_keys labels_share
    page.save
  end
  on(Royalties::ContractDetails) do |page|
    page.wait_until { page.product_exceptions_section_element.text.include?(product_name) }
    expect(page.product_exceptions_section_element.text).to include transaction_type
    expect(page.product_exceptions_section_element.text).to include service
    expect(page.product_exceptions_section_element.text).to include country
    expect(page.product_exceptions_section_element.text).to include labels_share
  end
end

Then("I should be able to add a contract track exception") do
  track_name = "Mindfields - Neotek"
  transaction_type = "Segments"
  service = "121 Music"
  country = "Poland"
  labels_share = "12"
  on(Royalties::ContractDetails) do |page|
    page.add_track_exception_element.click
  end
  on(Royalties::NewContractTrackExceptionPage) do |page|
    page.search_for_track track_name
    page.select_transaction_type transaction_type
    page.select_service service
    page.select_country country
    page.labels_share_element.send_keys labels_share
    page.save
  end
  on(Royalties::ContractDetails) do |page|
    page.wait_until { page.track_exceptions_section_element.text.include?(track_name) }
    expect(page.track_exceptions_section_element.text).to include transaction_type
    expect(page.track_exceptions_section_element.text).to include service
    expect(page.track_exceptions_section_element.text).to include country
    expect(page.track_exceptions_section_element.text).to include labels_share
  end
end

Then("I should be able to add a contract mechanical deductions") do
  deduction_type = "Ringtones"
  who_pays = "Both"
  admin_fees = "No"
  on(Royalties::ContractDetails) do |page|
    page.add_mechanical_deduction
  end
  on(Royalties::NewContractMechanicalDeductionPage) do |page|
    page.select_deduction_type(deduction_type)
    page.select_who_pays(who_pays)
    page.select_admin_fees_taken(admin_fees)
    page.save
  end
  on(Royalties::ContractDetails) do |page|
    page.wait_until { page.mechanical_deductions_section_element.text.include?(deduction_type) }
    expect(page.mechanical_deductions_section_element.text).to include who_pays
    expect(page.mechanical_deductions_section_element.text).to include admin_fees
  end
end

Then("I should be able to see valid admin links") do
  on(Royalties::AdminPage) do |page|
    links = ["MANAGE PAYMENT METHOD MINIMUMS", "MANAGE RUN CONTROLLERS", "STATUTORY RATE TABLE"]
    links.each do |link|
      expect(page.dashboard_container_element.text).to include link
    end
  end
end

Then("StatutoryRatesPage should be valid") do
  on(Royalties::StatutoryRatesPage) do |page|
    sections = ["UNITED STATES MECHANICAL RATES", "UNITED STATES RINGTONE RATES"]
    sections.each do |section|
      expect(page.statutory_rates_container_element.text).to include section
    end
  end
end

When("I assign a period_id to the accounting period") do
  on(Royalties::AccountingPeriodsPage) do |page|
    @period_id = "42"
    page.edit_period_id_element.click
    page.period_id_value_element.send_keys "42"
    page.save_period_id
    page.wait_until { page.button(name: "editBtn-#{@period_id}").present? }
  end
end

Then("I should be able to see it on accounting period details list") do
  on(Royalties::AccountingPeriodsPage) do |page|
    page.open_period_element.span.click
  end

  on(Royalties::AccountingPeriodsDetailsPage) do |page|
    expect(page.page_title_element.text).to include "Period #{@period_id}"
    expect(page.breadcrumb_active_element.text).to include "PERIOD #{@period_id}"
  end
end