Kata\Algorithm\Finder

Complexity

Total Complexity

11

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	find()	0	31	6
A	sortFromOlderToYounger()	0	17	2
A	firstIsOlder()	0	4	1
A	addAgeDifference()	0	6	1

<?php

declare(strict_types = 1);

namespace Kata\Algorithm;

final class Finder
{
    /** @var Person[] */
    private $people;

    public function __construct(array $all_people)
    {
        $this->people = $all_people;
    }

    public function find(int $sorting_type): Comparator
    {
        /** @var Comparator[] $sorted_people_from_older_to_younger */
        $sorted_people_from_older_to_younger = [];

        foreach ($this->people as $index => $person)
        {
            for ($j = $index + 1; $j < count($this->people); $j++)

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

            {
                $person_to_compare_with = $this->people[$j];
                $current_couple         = $this->sortFromOlderToYounger($person, $person_to_compare_with);

                $sorted_people_from_older_to_younger[] = $current_couple;
            }
        }

        if (empty($sorted_people_from_older_to_younger))
        {
            return new Comparator();
        }

        $first_couple = $sorted_people_from_older_to_younger[0];

        $sorting_algorithm = $sorting_type == 1 ? SortClosest::class : SortFurthest::class;
        foreach ($sorted_people_from_older_to_younger as $current_couple)
        {
            $first_couple = (new $sorting_algorithm())->__invoke($current_couple, $first_couple);
        }

        return $first_couple;
    }

    /**
     * @param $person
     * @param $person_to_compare_with
     *
     * @return Comparator
     */
    private function sortFromOlderToYounger($person, $person_to_compare_with): Comparator
    {
        $result = new Comparator();
        if ($this->firstIsOlder($person, $person_to_compare_with))
        {
            $result->first_person  = $person;
            $result->second_person = $person_to_compare_with;
        }
        else
        {
            $result->first_person  = $person_to_compare_with;
            $result->second_person = $person;
        }
        $this->addAgeDifference($result);

        return $result;
    }

    /**
     * @param $person
     * @param $person_to_compare_with
     *
     * @return bool
     */
    private function firstIsOlder($person, $person_to_compare_with): bool
    {
        return $person->birthDate < $person_to_compare_with->birthDate;
    }

    private function addAgeDifference($result)
    {
        $result->age_difference = $result->second_person->birthDate->getTimestamp() - $result->first_person->birthDate->getTimestamp();

        return $result;
    }
}