require 'rails_helper'
module Tables
  RSpec.describe DiscomfortCalculator do
    let(:calculator) { described_class.new(table) }

    describe '#cohesion_penalty' do
      context 'when the table contains just two guests' do
        let(:table) do
          [
            create(:guest, affinity_group_list: ['family']),
            create(:guest, affinity_group_list: ['friends'])
          ]
        end

        before do
          allow(AffinityGroupsHierarchy.instance).to receive(:distance).and_return(distance)
        end

        context 'when they belong to the same group' do
          let(:distance) { 0 }

          it { expect(calculator.send(:cohesion_penalty)).to eq(0) }
        end

        context 'when they belong to completely unrelated groups' do
          let(:distance) { nil }

          it { expect(calculator.send(:cohesion_penalty)).to eq(1) }
        end

        context 'when they belong to groups at a distance of 1' do
          let(:distance) { 1 }

          it { expect(calculator.send(:cohesion_penalty)).to eq(0.5) }
        end

        context 'when they belong to groups at a distance of 2' do
          let(:distance) { 2 }

          it { expect(calculator.send(:cohesion_penalty)).to eq(Rational(2, 3)) }
        end

        context 'when they belong to groups at a distance of 3' do
          let(:distance) { 3 }

          it { expect(calculator.send(:cohesion_penalty)).to eq(Rational(3, 4)) }
        end
      end

      context 'when the table contains three guests' do
        let(:table) do
          [
            create(:guest, affinity_group_list: ['family']),
            create(:guest, affinity_group_list: ['friends']),
            create(:guest, affinity_group_list: ['work'])
          ]
        end

        before do
          allow(AffinityGroupsHierarchy.instance).to receive(:distance).with('family', 'friends').and_return(nil)
          allow(AffinityGroupsHierarchy.instance).to receive(:distance).with('friends', 'work').and_return(1)
          allow(AffinityGroupsHierarchy.instance).to receive(:distance).with('family', 'work').and_return(2)
        end

        it 'returns the sum of the penalties for each pair of guests' do
          expect(calculator.send(:cohesion_penalty)).to eq(1 + Rational(1, 2) + Rational(2, 3))
        end
      end

      context 'when the table contains four guests' do
        let(:table) do
          [
            create(:guest, affinity_group_list: ['family']),
            create(:guest, affinity_group_list: ['friends']),
            create(:guest, affinity_group_list: ['work']),
            create(:guest, affinity_group_list: ['school'])
          ]
        end

        before do
          allow(AffinityGroupsHierarchy.instance).to receive(:distance).with('family', 'friends').and_return(nil)
          allow(AffinityGroupsHierarchy.instance).to receive(:distance).with('friends', 'work').and_return(1)
          allow(AffinityGroupsHierarchy.instance).to receive(:distance).with('family', 'work').and_return(2)
          allow(AffinityGroupsHierarchy.instance).to receive(:distance).with('family', 'school').and_return(3)
          allow(AffinityGroupsHierarchy.instance).to receive(:distance).with('friends', 'school').and_return(4)
          allow(AffinityGroupsHierarchy.instance).to receive(:distance).with('work', 'school').and_return(5)
        end

        it 'returns the sum of the penalties for each pair of guests' do
          expect(calculator.send(:cohesion_penalty))
            .to eq(1 + Rational(1, 2) + Rational(2, 3) + Rational(3, 4) + Rational(4, 5) + Rational(5, 6))
        end
      end
    end
  end
end