count how many days within a date range are within another date range

Question

From October 1st to March 31 the fee is $1 (season 1). From April 1st to September 30 the fee is $2 (season 2).

How can I calculate the total fee of a given date range (user input) depending on how many days of this date range fall into season 1 and season 2?

The following gives me the number of days of the user´s date range, but I have no idea how to test against season 1 or season 2:

$user_input_start_date = getdate( $a );
$user_input_end_date = getdate( $b );

$start_date_new = mktime( 12, 0, 0, $user_input_start_date['mon'], $user_input_start_date['mday'], $user_input_start_date['year'] );
$end_date_new = mktime( 12, 0, 0, $user_input_end_date['mon'], $user_input_end_date['mday'], $user_input_end_date['year'] );

return round( abs( $start_date_new - $end_date_new ) / 86400 );

Given that a date range starts and ends in 2012 or starts in 2012 and ends in 2013 alone gives me 10 different possibilities of in which season a date range can start and where it can end.

There must be a better solution than iterating if/else and comparing dates over and over again for the following conditions:

1. Date range is completely within season 1
2. Date range starts in season 1 and ends in season 2
3. Date range starts in season 1, spans across season 2 and ends in the second part of season 1

... and so forth with "Starts in season 2", etc

This not a duplicate of How many days until X-Y-Z date? as that only deals with counting the number of days. It does not address the issue of comparing one date range with another.

Answer 1

At first I suggested using the DateTime class that PHP provides, naively assuming that it has some kind of thought-out API that one could use. It turns out that it does not. While it features very basic DateTime functionality, it is mostly unusable because, for most operations, it relies on the DateInterval class. In combination, those classes represent another masterpiece of bad API design.

An interval should be defined like so:

An interval in Joda-Time represents an interval of time from one millisecond instant to another instant. Both instants are fully specified instants in the datetime continuum, complete with time zone.

In PHP, however, an Interval is just a duration:

A date interval stores either a fixed amount of time (in years, months, days, hours etc) or a relative time string [such as "2 days"].

Unfortunately, PHP's DateInterval definition does not allow for intersection/overlap calculation (which the OP needs) because PHP's Intervals have no specific position in the datetime continuum. Therefore, I've implemented a (very rudimentary) class that adheres to JodaTime's definition of an interval. It is not extensively tested, but it should get the work done:

class ProperDateInterval {
    private $start = null;
    private $end = null;

    public function __construct(DateTime $start, DateTime $end) {
        $this->start = $start;
        $this->end = $end;
    }

    /**
    * Does this time interval overlap the specified time interval.
    */
    public function overlaps(ProperDateInterval $other) {
        $start = $this->getStart()->getTimestamp();
        $end = $this->getEnd()->getTimestamp();

        $oStart = $other->getStart()->getTimestamp();
        $oEnd = $other->getEnd()->getTimestamp();

        return $start < $oEnd && $oStart < $end;
    }

    /**
     * Gets the overlap between this interval and another interval.
     */
    public function overlap(ProperDateInterval $other) {
        if(!$this->overlaps($other)) {
            // I haven't decided what should happen here yet.
            // Returning "null" doesn't seem like a good solution.
            // Maybe ProperDateInterval::EMPTY?
            throw new Exception("No intersection."); 
        }

        $start = $this->getStart()->getTimestamp();
        $end = $this->getEnd()->getTimestamp();

        $oStart = $other->getStart()->getTimestamp();
        $oEnd = $other->getEnd()->getTimestamp();

        $overlapStart = NULL;
        $overlapEnd = NULL;
        if($start === $oStart || $start > $oStart) {
            $overlapStart = $this->getStart();
        } else {
            $overlapStart = $other->getStart();
        }

        if($end === $oEnd || $end < $oEnd) {
            $overlapEnd = $this->getEnd();
        } else {
            $overlapEnd = $other->getEnd();
        }

        return new ProperDateInterval($overlapStart, $overlapEnd);
    }

    /**
     * @return long The duration of this interval in seconds.
     */
    public function getDuration() {
        return $this->getEnd()->getTimestamp() - $this->getStart()->getTimestamp();
    }


    public function getStart() {
        return $this->start;
    }


    public function getEnd() {
        return $this->end;
    }
}

It may be used like so:

$seasonStart = DateTime::createFromFormat('j-M-Y', '01-Apr-2012');
$seasonEnd = DateTime::createFromFormat('j-M-Y', '30-Sep-2012');

$userStart = DateTime::createFromFormat('j-M-Y', '01-Jan-2012');
$userEnd = DateTime::createFromFormat('j-M-Y', '02-Apr-2012');

$i1 = new ProperDateInterval($seasonStart, $seasonEnd);
$i2 = new ProperDateInterval($userStart, $userEnd);

$overlap = $i1->overlap($i2);
var_dump($overlap->getDuration());

Answer 2

The key to this problem is to simplify it as much as possible. I think using an array as a lookup table for the cost of each day of the year is the way to go. The first thing to do then, is to generate the array. The array just represents each day of the year and doesn't represent any particular year. I chose to use 2012 to generate the lookup array as it is a leap year and so has every possible day in it.

function getSeasonArray()
{
    /**
     * I have chosen 2012 as it was a leap year. All we want to do is
     * generate an array which has avery day of the year in it.
     */
    $startDate = new DateTime('1st January 2012');
    //DatePeriod always drops the last day.
    $endDate = new DateTime('1st January 2013');
    $season2Start = new DateTime('1st April 2012');
    $season2End = new DateTime('1st October 2012');

    $allDays = new DatePeriod($startDate, new DateInterval('P1D'), $endDate);
    $season2Days = new DatePeriod($season2Start, new DateInterval('P1D'), $season2End);

    $seasonArray = array();

    foreach($allDays as $day){
        $seasonArray[] = $day->format('d-M');
        $seasonArray[$day->format('d-M')]['season'] = 1;
    }

    foreach($season2Days as $day){
        $seasonArray[$day->format('d-M')]['season'] = 2;
    }

    return $seasonArray;
}

Once that is done you just need the period over which to calculate:-

$bookingStartDate = new DateTime();//Or wherever you get this from
$bookingEndDate = new DateTime();
$bookingEndDate->setTimestamp(strtotime('+ 7 month'));//Or wherever you get this from
$bookingPeriod = new DatePeriod($bookingStartDate, new DateInterval('P1D'),   $bookingEndDate);

Then we can do the calculation:-

$seasons = getSeasonArray();
$totalCost = 0;
foreach($bookingPeriod as $day){
    $totalCost += $seasons[$day->format('d-M')]['season'];
    var_dump($day->format('d-M') . ' = $' . $seasons[$day->format('d-M')]['season']);
}
var_dump($totalCost);

I have chosen a long booking period, so that you can scan through the var_dump() output and verify the correct price for each day of the year.

This is a quick stab done between distractions at work and I'm sure that with a bit of thought you can mould it into a more elegant solution. I'd like to get rid of the double iteration for example, unfortunately, work pressures prevent me from spending further time on this.

See the PHP DateTime man page for further information on these useful classes.