# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Gitlab::Pagination::Keyset::Order do
  let(:table) { Arel::Table.new(:my_table) }
  let(:order) { nil }

  def run_query(query)
    ActiveRecord::Base.connection.execute(query).to_a
  end

  def build_query(order:, where_conditions: nil, limit: nil)
    <<-SQL
    SELECT id, year, month
      FROM (#{table_data}) my_table (id, year, month) 
      WHERE #{where_conditions || '1=1'} 
      ORDER BY #{order} 
      LIMIT #{limit || 999};
    SQL
  end

  def iterate_and_collect(order:, page_size:, where_conditions: nil)
    all_items = []

    loop do
      paginated_items = run_query(build_query(order: order, where_conditions: where_conditions, limit: page_size))
      break if paginated_items.empty?

      all_items.concat(paginated_items)
      last_item = paginated_items.last
      cursor_attributes = order.cursor_attributes_for_node(last_item)
      where_conditions = order.build_where_values(cursor_attributes).to_sql
    end

    all_items
  end

  subject do
    run_query(build_query(order: order))
  end

  shared_examples 'order examples' do
    it { expect(subject).to eq(expected) }

    context 'when paginating forwards' do
      subject { iterate_and_collect(order: order, page_size: 2) }

      it { expect(subject).to eq(expected) }

      context 'with different page size' do
        subject { iterate_and_collect(order: order, page_size: 5) }

        it { expect(subject).to eq(expected) }
      end
    end

    context 'when paginating backwards' do
      subject do
        last_item = expected.last
        cursor_attributes = order.cursor_attributes_for_node(last_item)
        where_conditions = order.reversed_order.build_where_values(cursor_attributes)

        iterate_and_collect(order: order.reversed_order, page_size: 2, where_conditions: where_conditions.to_sql)
      end

      it do
        expect(subject).to eq(expected.reverse[1..-1]) # removing one item because we used it to calculate cursor data for the "last" page in subject
      end
    end
  end

  context 'when ordering by a distinct column' do
    let(:table_data) do
      <<-SQL
      VALUES (1,  0, 0),
             (2,  0, 0),
             (3,  0, 0),
             (4,  0, 0),
             (5,  0, 0),
             (6,  0, 0),
             (7,  0, 0),
             (8,  0, 0),
             (9,  0, 0)
      SQL
    end

    let(:order) do
      Gitlab::Pagination::Keyset::Order.build([
        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
          attribute_name: 'id',
          column_expression: table['id'],
          order_expression: table['id'].desc,
          nullable: :not_nullable,
          distinct: true
        )
      ])
    end

    let(:expected) do
      [
        { "id" => 9, "year" => 0, "month" => 0 },
        { "id" => 8, "year" => 0, "month" => 0 },
        { "id" => 7, "year" => 0, "month" => 0 },
        { "id" => 6, "year" => 0, "month" => 0 },
        { "id" => 5, "year" => 0, "month" => 0 },
        { "id" => 4, "year" => 0, "month" => 0 },
        { "id" => 3, "year" => 0, "month" => 0 },
        { "id" => 2, "year" => 0, "month" => 0 },
        { "id" => 1, "year" => 0, "month" => 0 }
      ]
    end

    it_behaves_like 'order examples'
  end

  context 'when ordering by two non-nullable columns and a distinct column' do
    let(:table_data) do
      <<-SQL
      VALUES (1,  2010, 2),
             (2,  2011, 1),
             (3,  2009, 2),
             (4,  2011, 1),
             (5,  2011, 1),
             (6,  2009, 2),
             (7,  2010, 3),
             (8,  2012, 4),
             (9,  2013, 5)
      SQL
    end

    let(:order) do
      Gitlab::Pagination::Keyset::Order.build([
        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
          attribute_name: 'year',
          column_expression: table['year'],
          order_expression: table['year'].asc,
          nullable: :not_nullable,
          distinct: false
        ),
        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
          attribute_name: 'month',
          column_expression: table['month'],
          order_expression: table['month'].asc,
          nullable: :not_nullable,
          distinct: false
        ),
        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
          attribute_name: 'id',
          column_expression: table['id'],
          order_expression: table['id'].asc,
          nullable: :not_nullable,
          distinct: true
        )
      ])
    end

    let(:expected) do
      [
        { 'year' => 2009, 'month' => 2, 'id' => 3 },
        { 'year' => 2009, 'month' => 2, 'id' => 6 },
        { 'year' => 2010, 'month' => 2, 'id' => 1 },
        { 'year' => 2010, 'month' => 3, 'id' => 7 },
        { 'year' => 2011, 'month' => 1, 'id' => 2 },
        { 'year' => 2011, 'month' => 1, 'id' => 4 },
        { 'year' => 2011, 'month' => 1, 'id' => 5 },
        { 'year' => 2012, 'month' => 4, 'id' => 8 },
        { 'year' => 2013, 'month' => 5, 'id' => 9 }
      ]
    end

    it_behaves_like 'order examples'
  end

  context 'when ordering by nullable columns and a distinct column' do
    let(:table_data) do
      <<-SQL
      VALUES (1,  2010, null),
             (2,  2011, 2),
             (3,  null, null),
             (4,  null, 5),
             (5,  2010, null),
             (6,  2011, 2),
             (7,  2010, 2),
             (8,  2012, 2),
             (9,  null, 2),
             (10, null, null),
             (11, 2010, 2)
      SQL
    end

    let(:order) do
      Gitlab::Pagination::Keyset::Order.build([
        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
          attribute_name: 'year',
          column_expression: table['year'],
          order_expression: Gitlab::Database.nulls_last_order('year', :asc),
          reversed_order_expression: Gitlab::Database.nulls_first_order('year', :desc),
          order_direction: :asc,
          nullable: :nulls_last,
          distinct: false
        ),
        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
          attribute_name: 'month',
          column_expression: table['month'],
          order_expression: Gitlab::Database.nulls_last_order('month', :asc),
          reversed_order_expression: Gitlab::Database.nulls_first_order('month', :desc),
          order_direction: :asc,
          nullable: :nulls_last,
          distinct: false
        ),
        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
          attribute_name: 'id',
          column_expression: table['id'],
          order_expression: table['id'].asc,
          nullable: :not_nullable,
          distinct: true
        )
      ])
    end

    let(:expected) do
      [
        { "id" => 7, "year" => 2010, "month" => 2 },
        { "id" => 11, "year" => 2010, "month" => 2 },
        { "id" => 1, "year" => 2010, "month" => nil },
        { "id" => 5, "year" => 2010, "month" => nil },
        { "id" => 2, "year" => 2011, "month" => 2 },
        { "id" => 6, "year" => 2011, "month" => 2 },
        { "id" => 8, "year" => 2012, "month" => 2 },
        { "id" => 9, "year" => nil, "month" => 2 },
        { "id" => 4, "year" => nil, "month" => 5 },
        { "id" => 3, "year" => nil, "month" => nil },
        { "id" => 10, "year" => nil, "month" => nil }
      ]
    end

    it_behaves_like 'order examples'
  end

  context 'when ordering by nullable columns with nulls first ordering and a distinct column' do
    let(:table_data) do
      <<-SQL
      VALUES (1,  2010, null),
             (2,  2011, 2),
             (3,  null, null),
             (4,  null, 5),
             (5,  2010, null),
             (6,  2011, 2),
             (7,  2010, 2),
             (8,  2012, 2),
             (9,  null, 2),
             (10, null, null),
             (11, 2010, 2)
      SQL
    end

    let(:order) do
      Gitlab::Pagination::Keyset::Order.build([
        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
          attribute_name: 'year',
          column_expression: table['year'],
          order_expression: Gitlab::Database.nulls_first_order('year', :asc),
          reversed_order_expression: Gitlab::Database.nulls_last_order('year', :desc),
          order_direction: :asc,
          nullable: :nulls_first,
          distinct: false
        ),
        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
          attribute_name: 'month',
          column_expression: table['month'],
          order_expression: Gitlab::Database.nulls_first_order('month', :asc),
          order_direction: :asc,
          reversed_order_expression: Gitlab::Database.nulls_last_order('month', :desc),
          nullable: :nulls_first,
          distinct: false
        ),
        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
          attribute_name: 'id',
          column_expression: table['id'],
          order_expression: table['id'].asc,
          nullable: :not_nullable,
          distinct: true
        )
      ])
    end

    let(:expected) do
      [
        { "id" => 3, "year" => nil, "month" => nil },
        { "id" => 10, "year" => nil, "month" => nil },
        { "id" => 9, "year" => nil, "month" => 2 },
        { "id" => 4, "year" => nil, "month" => 5 },
        { "id" => 1, "year" => 2010, "month" => nil },
        { "id" => 5, "year" => 2010, "month" => nil },
        { "id" => 7, "year" => 2010, "month" => 2 },
        { "id" => 11, "year" => 2010, "month" => 2 },
        { "id" => 2, "year" => 2011, "month" => 2 },
        { "id" => 6, "year" => 2011, "month" => 2 },
        { "id" => 8, "year" => 2012, "month" => 2 }
      ]
    end

    it_behaves_like 'order examples'
  end

  context 'when ordering by non-nullable columns with mixed directions and a distinct column' do
    let(:table_data) do
      <<-SQL
      VALUES (1,  2010, 0),
             (2,  2011, 0),
             (3,  2010, 0),
             (4,  2010, 0),
             (5,  2012, 0),
             (6,  2012, 0),
             (7,  2010, 0),
             (8,  2011, 0),
             (9,  2013, 0),
             (10, 2014, 0),
             (11, 2013, 0)
      SQL
    end

    let(:order) do
      Gitlab::Pagination::Keyset::Order.build([
        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
          attribute_name: 'year',
          column_expression: table['year'],
          order_expression: table['year'].asc,
          nullable: :not_nullable,
          distinct: false
        ),
        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
          attribute_name: 'id',
          column_expression: table['id'],
          order_expression: table['id'].desc,
          nullable: :not_nullable,
          distinct: true
        )
      ])
    end

    let(:expected) do
      [
        { "id" => 7, "year" => 2010, "month" => 0 },
        { "id" => 4, "year" => 2010, "month" => 0 },
        { "id" => 3, "year" => 2010, "month" => 0 },
        { "id" => 1, "year" => 2010, "month" => 0 },
        { "id" => 8, "year" => 2011, "month" => 0 },
        { "id" => 2, "year" => 2011, "month" => 0 },
        { "id" => 6, "year" => 2012, "month" => 0 },
        { "id" => 5, "year" => 2012, "month" => 0 },
        { "id" => 11, "year" => 2013, "month" => 0 },
        { "id" => 9, "year" => 2013, "month" => 0 },
        { "id" => 10, "year" => 2014, "month" => 0 }
      ]
    end

    it 'takes out a slice between two cursors' do
      after_cursor = { "id" => 8, "year" => 2011 }
      before_cursor = { "id" => 5, "year" => 2012 }

      after_conditions = order.build_where_values(after_cursor)
      reversed = order.reversed_order
      before_conditions = reversed.build_where_values(before_cursor)

      query = build_query(order: order, where_conditions: "(#{after_conditions.to_sql}) AND (#{before_conditions.to_sql})", limit: 100)

      expect(run_query(query)).to eq([
        { "id" => 2, "year" => 2011, "month" => 0 },
        { "id" => 6, "year" => 2012, "month" => 0 }
      ])
    end
  end

  context 'when the passed cursor values do not match with the order definition' do
    let(:order) do
      Gitlab::Pagination::Keyset::Order.build([
        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
          attribute_name: 'year',
          column_expression: table['year'],
          order_expression: table['year'].asc,
          nullable: :not_nullable,
          distinct: false
        ),
        Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
          attribute_name: 'id',
          column_expression: table['id'],
          order_expression: table['id'].desc,
          nullable: :not_nullable,
          distinct: true
        )
      ])
    end

    context 'when values are missing' do
      it 'raises error'  do
        expect { order.build_where_values(id: 1) }.to raise_error(/Missing items: year/)
      end
    end

    context 'when extra values are present' do
      it 'raises error' do
        expect { order.build_where_values(id: 1, year: 2, foo: 3) }.to raise_error(/Extra items: foo/)
      end
    end

    context 'when values are missing and extra values are present' do
      it 'raises error'  do
        expect { order.build_where_values(year: 2, foo: 3) }.to raise_error(/Extra items: foo\. Missing items: id/)
      end
    end

    context 'when no values are passed' do
      it 'returns nil' do
        expect(order.build_where_values({})).to eq(nil)
      end
    end
  end

  context 'extract and apply cursor attributes' do
    let(:model) { Project.new(id: 100) }
    let(:scope) { Project.all }

    shared_examples 'cursor attribute examples' do
      describe '#cursor_attributes_for_node' do
        it { expect(order.cursor_attributes_for_node(model)).to eq({ id: '100' }.with_indifferent_access) }
      end

      describe '#apply_cursor_conditions' do
        context 'when params with string keys are passed' do
          subject(:sql) { order.apply_cursor_conditions(scope, { 'id' => '100' }).to_sql }

          it { is_expected.to include('"projects"."id" < 100)') }
        end

        context 'when params with symbol keys are passed' do
          subject(:sql) { order.apply_cursor_conditions(scope, { id: '100' }).to_sql }

          it { is_expected.to include('"projects"."id" < 100)') }
        end
      end
    end

    context 'when string attribute name is given' do
      let(:order) do
        Gitlab::Pagination::Keyset::Order.build([
          Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
            attribute_name: 'id',
            order_expression: Project.arel_table['id'].desc,
            nullable: :not_nullable,
            distinct: true
          )
        ])
      end

      it_behaves_like 'cursor attribute examples'
    end

    context 'when symbol attribute name is given' do
      let(:order) do
        Gitlab::Pagination::Keyset::Order.build([
          Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
            attribute_name: :id,
            order_expression: Project.arel_table['id'].desc,
            nullable: :not_nullable,
            distinct: true
          )
        ])
      end

      it_behaves_like 'cursor attribute examples'
    end
  end
end