Arbor\Moment\DateRange

Complexity

Total Complexity

41

Size/Duplication

Total Lines	204
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	11	6
A	getStartDate()	0	4	1
A	getEndDate()	0	4	1
B	containsDate()	0	10	5
B	containsDateRange()	0	10	5
A	overlapsDateRange()	0	4	1
A	isBefore()	0	8	2
A	isNow()	0	4	1
A	isAfter()	0	8	2
A	intersect()	0	11	4
A	getShort()	0	4	1
A	getLong()	0	4	1
A	getAllDates()	0	19	4
A	getDuration()	0	8	3
A	__toString()	0	4	1
A	__clone()	0	5	3

<?php

declare(strict_types = 1);

namespace Arbor\Moment;

use Arbor\Moment\Comparator\DateTimeComparator;
use Arbor\Moment\Exception\InvalidArgumentException;
use Arbor\Moment\Formatter\DateRangeFormatter;

/**
 * Class DateRange
 *
 * @package Arbor\Moment
 * @author Igor Vuckovic <igor.vuckovic@arbor-education.com>
 */
class DateRange
{
    /** @var DateTime */
    private $startDate;

    /** @var DateTime */
    private $endDate;

    /** @var DateRangeFormatter */
    private $formatter;

    /**
     * @param DateTime|null $startDate
     * @param DateTime|null $endDate
     * @throws \InvalidArgumentException
     */
    public function __construct(DateTime $startDate = null, DateTime $endDate = null)
    {
        $this->startDate = $startDate ? clone $startDate : null;
        $this->endDate = $endDate ? clone $endDate : null;

        if ($startDate && $endDate && $endDate < $startDate) {
            throw InvalidArgumentException::startDateNotBeforeEndDate($startDate, $endDate);
        }

        $this->formatter = new DateRangeFormatter($this);
    }

    /**
     * @return DateTime|null
     */
    public function getStartDate()
    {
        return $this->startDate;
    }

    /**
     * @return DateTime|null
     */
    public function getEndDate()
    {
        return $this->endDate;
    }

    /**
     * @param DateTime $date
     * @return bool
     */
    public function containsDate(DateTime $date) : bool
    {
        if ($this->startDate === null) {
            return $this->endDate === null || $this->endDate >= $date;
        } elseif ($this->endDate === null) {
            return $this->startDate <= $date;
        }

        return $this->startDate <= $date && $this->endDate >= $date;
    }

    /**
     * @param DateRange $dateRange
     * @return bool
     */
    public function containsDateRange(DateRange $dateRange) : bool
    {
        if ($this->startDate === null && $this->endDate === null) {
            return true;
        }

        return $this->startDate <= $dateRange->getStartDate()
            && $dateRange->getEndDate() !== null
            && $this->endDate >= $dateRange->getEndDate();
    }

    /**
     * @param DateRange $dateRange
     * @return bool
     */
    public function overlapsDateRange(DateRange $dateRange) : bool
    {
        return $this->intersect($dateRange) !== null;
    }

    /**
     * @param DateTime $date
     * @return bool
     */
    public function isBefore(DateTime $date) : bool
    {
        if ($this->endDate === null) {
            return false;
        }

        return $this->endDate <= $date;
    }

    /**
     * @return bool
     */
    public function isNow() : bool
    {
        return $this->containsDate(new DateTime());
    }

    /**
     * @param DateTime $date
     * @return bool
     */
    public function isAfter(DateTime $date) : bool
    {
        if ($this->startDate === null) {
            return false;
        }

        return $this->startDate >= $date;
    }

    /**
     * @param DateRange $dateRange
     * @return DateRange|null
     */
    public function intersect(DateRange $dateRange)
    {
        $latestStartDate = DateTimeComparator::getLatestDate($this->startDate, $dateRange->startDate);
        $earliestEndDate = DateTimeComparator::getEarliestDate($this->endDate, $dateRange->endDate);

        if ($latestStartDate && $earliestEndDate && ($latestStartDate >= $earliestEndDate)) {
            return null;
        }

        return new DateRange($latestStartDate, $earliestEndDate);
    }

    /**
     * @param string $nullPlaceholder
     * @return string
     */
    public function getShort(string $nullPlaceholder = 'Ongoing') : string
    {
        return $this->formatter->getShort($nullPlaceholder);
    }

    /**
     * @param string $nullPlaceholder
     * @return string
     */
    public function getLong(string $nullPlaceholder = 'Ongoing') : string
    {
        return $this->formatter->getLong($nullPlaceholder);
    }

    /**
     * @return DateTime[]
     * @throws InvalidArgumentException
     */
    public function getAllDates() : array
    {
        if ($this->getStartDate() === null || $this->getEndDate() === null) {
            throw InvalidArgumentException::dateRangeWithoutBoundaries();
        }

        $startDate = $this->startDate;
        $endDate = $this->endDate;
        $referenceDate = clone $startDate;
        $referenceDate->setDateType(DateTime::TYPE_DATE);

        $dates = [];
        while ($referenceDate <= $endDate) {
            $dates[$referenceDate->getUnixTimestamp()] = clone $referenceDate;
            $referenceDate->add(new \DateInterval('P1D'));
        }

        return array_values($dates);
    }

    /**
     * @return Time|null
     */
    public function getDuration()
    {
        if ($this->startDate && $this->endDate) {
            return Time::fromSeconds($this->endDate->getTimestamp() - $this->startDate->getTimestamp());
        }

        return null;
    }

    /**
     * @return string
     */
    public function __toString() : string
    {
        return $this->getLong();
    }

    /**
     *
     */
    public function __clone()
    {
        $this->startDate = ($this->startDate ? clone $this->startDate : null);
        $this->endDate = ($this->endDate ? clone $this->endDate : null);
    }
}