Popy\Calendar\Converter\UnixTimeConverter\DateSolar

Complexity

Total Complexity

8

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	2
A	toUnixTime()	0	17	2
B	fromUnixTime()	0	61	4

<?php

namespace Popy\Calendar\Converter\UnixTimeConverter;

use Popy\Calendar\Converter\Conversion;
use Popy\Calendar\Converter\UnixTimeConverterInterface;
use Popy\Calendar\Converter\CompleteLeapYearCalculatorInterface;
use Popy\Calendar\ValueObject\DateSolarRepresentationInterface;

/**
 * Handles DateSolarRepresentationInterface.
 *
 * The eraDayIndex is calculated using an "eraStart" reference date. Year, year
 * length and leap days calculations are delegated to a LeapYearCalculator.
 */
class DateSolar implements UnixTimeConverterInterface
{
    /**
     * Era start unix time.
     *
     * @var integer
     */
    protected $eraStart;

    /**
     * Day length in seconds.
     *
     * @var integer|float|string
     */
    protected $dayLengthInSeconds = 24 * 3600;

    /**
     * Leap year calculator.
     *
     * @var CompleteLeapYearCalculatorInterface
     */
    protected $calculator;

    /**
     * Class constructor.
     *
     * @param CompleteLeapYearCalculatorInterface $calculator         Leap year calculator.
     * @param integer                     $eraStart           Era start unix time.
     * @param integer|float|string|null   $dayLengthInSeconds Day length in seconds.
     */
    public function __construct(CompleteLeapYearCalculatorInterface $calculator, $eraStart, $dayLengthInSeconds = null)
    {
        $this->calculator = $calculator;
        $this->eraStart   = $eraStart;

        if (null !== $dayLengthInSeconds) {
            $this->dayLengthInSeconds = $dayLengthInSeconds;
        }
    }

    /**
     * @inheritDoc
     */
    public function fromUnixTime(Conversion $conversion)
    {
        if (!$conversion->getTo() instanceof DateSolarRepresentationInterface) {
            return;
        }

        $res = $conversion->getTo();

        // TODO : remove code repetition by using a separate abstraction
        // handling basic math operations.

        if (is_integer($this->dayLengthInSeconds)) {
            // bc not needed/not available

            // Relative time from era start.
            $relativeTime = $conversion->getUnixTime() - $this->eraStart;

            // Calculating global day index. Floor is used to properly handle
            // negative values
            $eraDayIndex = (int)floor($relativeTime / $this->dayLengthInSeconds);

            $time = $relativeTime - $eraDayIndex * $this->dayLengthInSeconds;

            // TODO : handle the loss as microseconds ?
            if (is_float($time)) {

The condition is_float($time) can never be true.

                $time = (int)ceil($time);
            }

            $conversion->setUnixTime($time);
        } else {
            // Using bc math if available for non int dayLengthInSeconds in
            // order to stay as precise as possible.

            // Relative time from era start.
            $relativeTime = bcsub($conversion->getUnixTime(), $this->eraStart);

            // Calculating global day index. Floor is used to properly handle
            // negative values
            $eraDayIndex = floor(
                bcdiv($relativeTime, $this->dayLengthInSeconds)

bcdiv($relativeTime, $this->dayLengthInSeconds) of type string is incompatible with the type double expected by parameter $value of floor().

            );

            // TODO : handle the loss as microseconds ?
            $time = ceil(bcsub(

bcsub($relativeTime, bcmul($eraDayIndex, $this->dayLengthInSeconds)) of type string is incompatible with the type double expected by parameter $value of ceil().

                $relativeTime,
                bcmul($eraDayIndex, $this->dayLengthInSeconds)
            ));

            $conversion->setUnixTime((int)$time);
        }

        list($year, $dayIndex) = $this->calculator
            ->getYearAndDayIndexFromErayDayIndex($eraDayIndex)

It seems like $eraDayIndex can also be of type double; however, parameter $eraDayIndex of Popy\Calendar\Converter\CompleteLeapYearCalculatorInterface::getYearAndDayIndexFromErayDayIndex() does only seem to accept integer, maybe add an additional type check?

        ;

        $res = $res
            ->withYear($year, $this->calculator->isLeapYear($year))
            ->withDayIndex($dayIndex, $eraDayIndex)

It seems like $eraDayIndex can also be of type double; however, parameter $eraDayIndex of Popy\Calendar\ValueObject\DateSolarRepresentationInterface::withDayIndex() does only seem to accept null|integer, maybe add an additional type check?

        ;

        $conversion->setTo($res);
    }

    /**
     * @inheritDoc
     */
    public function toUnixTime(Conversion $conversion)
    {
        $input = $conversion->getTo();

        if (!$input instanceof DateSolarRepresentationInterface) {
            return;
        }

        $year = (int)$input->getYear();
        $eraDayIndex = $input->getDayIndex()
            + $this->calculator->getYearEraDayIndex($year)
        ;

        // TODO : BC Math implementation
        $conversion->setUnixTime(intval(
            $conversion->getUnixTime() + $this->eraStart
            + $eraDayIndex * $this->dayLengthInSeconds
        ));
    }
}