# Copyright (C) 2024 Manuel Bustillo

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

    let(:family) { create(:group, name: 'family') }
    let(:friends) { create(:group, name: 'friends') }
    let(:work) { create(:group, name: 'work') }
    let(:school) { create(:group, name: 'school') }

    describe '#cohesion_penalty' do
      before do
        # Overridden in each test except trivial cases
        allow(AffinityGroupsHierarchy.instance).to receive(:distance).and_call_original

        %w[family friends work school].each do |group|
          allow(AffinityGroupsHierarchy.instance).to receive(:distance).with(group, group).and_return(0)
        end

        allow(AffinityGroupsHierarchy.instance).to receive(:distance).with(family.id, friends.id).and_return(nil)
        allow(AffinityGroupsHierarchy.instance).to receive(:distance).with(friends.id, work.id).and_return(1)
        allow(AffinityGroupsHierarchy.instance).to receive(:distance).with(family.id, work.id).and_return(2)
        allow(AffinityGroupsHierarchy.instance).to receive(:distance).with(family.id, school.id).and_return(3)
        allow(AffinityGroupsHierarchy.instance).to receive(:distance).with(friends.id, school.id).and_return(4)
        allow(AffinityGroupsHierarchy.instance).to receive(:distance).with(work.id, school.id).and_return(5)
      end
      context 'when the table contains just two guests' do
        context 'when they belong to the same group' do
          let(:table) { create_list(:guest, 2, group: family) }

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

        context 'when they belong to completely unrelated groups' do
          let(:table) do
            [
              create(:guest, group: family),
              create(:guest, group: friends)
            ]
          end
          it { expect(calculator.send(:cohesion_penalty)).to eq(1) }
        end

        context 'when they belong to groups at a distance of 1' do
          let(:table) do
            [
              create(:guest, group: friends),
              create(:guest, group: work)
            ]
          end

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

        context 'when they belong to groups at a distance of 2' do
          let(:table) do
            [
              create(:guest, group: family),
              create(:guest, group: work)
            ]
          end

          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(:table) do
            [
              create(:guest, group: family),
              create(:guest, group: school)
            ]
          end

          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, group: family),
            create(:guest, group: friends),
            create(:guest, group: work)
          ]
        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 of different groups' do
        let(:table) do
          [
            create(:guest, group: family),
            create(:guest, group: friends),
            create(:guest, group: work),
            create(:guest, group: school)
          ]
        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

      context 'when the table contains four guests of two evenly split groups' do
        let(:table) do
          [
            create_list(:guest, 2, group: family),
            create_list(:guest, 2, group: friends)
          ].flatten
        end

        it 'returns the sum of the penalties for each pair of guests' do
          expect(calculator.send(:cohesion_penalty)).to eq(4)
        end
      end

      context 'when the table contains six guests of two unevenly split groups' do
        let(:table) do
          [
            create_list(:guest, 2, group: family),
            create_list(:guest, 4, group: friends)
          ].flatten
        end

        it 'returns the sum of the penalties for each pair of guests' do
          expect(calculator.send(:cohesion_penalty)).to eq(8)
        end
      end

      context 'when the table contains six guests of three evenly split groups' do
        let(:table) do
          [
            create_list(:guest, 2, group: family),
            create_list(:guest, 2, group: friends),
            create_list(:guest, 2, group: work)
          ].flatten
        end

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

      context 'when the table contains six guests of three unevenly split groups' do
        let(:table) do
          [
            create_list(:guest, 3, group: family),
            create_list(:guest, 2, group: friends),
            create_list(:guest, 1, group: work)
          ].flatten
        end

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