<?php
namespace Strikewise\Calculator;

defined( 'ABSPATH' ) || exit;

/**
 * Calculates the "prior price" required by Art. 6a of Directive 98/6/EC
 * (Omnibus Directive, in Germany § 11 PAngV): the lowest price applied
 * during the N days BEFORE the price reduction started.
 *
 * Rules implemented here (see concept, section "Berechnungslogik"):
 * - The running sale price never counts towards its own reference.
 * - A reduction that is deepened step by step without interruption keeps its
 *   original start (§ 11 Abs. 2 PAngV, Art. 6a(5)). The exception is narrow
 *   (Commission guidance 2021/C 526/02, section 4.3): once the sale price goes
 *   up again, the chain ends and the lower sale price before counts as prior price.
 * - If the history does not reach back N days (new product), the lowest known
 *   price before the start is used and the result is marked incomplete.
 * - Extra intervals (prices of public coupon campaigns) count for the lowest
 *   price, but never decide which price applies now.
 *
 * Pure PHP without WordPress dependencies, so it can be unit-tested in isolation.
 */
final class ReferenceCalculator {

	/** Only reductions get a reference (legal default). */
	const MODE_REDUCTION = 'reduction';

	/** Always show the lowest price of the last N days, also without a reduction. */
	const MODE_ALWAYS = 'always';

	const DAY = 86400;

	/**
	 * @param Interval[] $intervals History of one product in one currency, any order.
	 * @param int        $now       Point in time to calculate for.
	 * @param int        $days      Length of the period before the reduction.
	 * @param string     $mode      MODE_REDUCTION or MODE_ALWAYS.
	 * @param Interval[] $extra     Further prices that were applied, e.g. public coupon prices.
	 */
	public function calculate( array $intervals, int $now, int $days = 30, string $mode = self::MODE_REDUCTION, array $extra = array() ): Reference {
		$intervals = array_values(
			array_filter(
				$intervals,
				static function ( Interval $i ) {
					return ! $i->is_empty();
				}
			)
		);
		usort(
			$intervals,
			static function ( Interval $a, Interval $b ) {
				return $a->from <=> $b->from;
			}
		);

		$current_index = null;
		foreach ( $intervals as $index => $interval ) {
			if ( $interval->covers( $now ) ) {
				$current_index = $index;
			}
		}

		if ( null === $current_index ) {
			return new Reference( Reference::STATUS_NO_DATA );
		}

		$current = $intervals[ $current_index ];

		if ( ! $current->reduced ) {
			if ( self::MODE_ALWAYS !== $mode ) {
				return new Reference( Reference::STATUS_NOT_REDUCED );
			}
			// Sliding window that includes today's price.
			return $this->lowest( $intervals, $now - $days * self::DAY, $now + 1, null, $extra );
		}

		$t0 = $this->reduction_start( $intervals, $current_index );

		return $this->lowest( $intervals, $t0 - $days * self::DAY, $t0, $t0, $extra );
	}

	/**
	 * Walks back over contiguous reduced intervals whose price never went up,
	 * to find where the progressive reduction began.
	 *
	 * @param Interval[] $intervals Sorted by start.
	 */
	private function reduction_start( array $intervals, int $index ): int {
		while ( $index > 0 ) {
			$previous = $intervals[ $index - 1 ];
			$current  = $intervals[ $index ];

			if ( ! $previous->reduced || $previous->to !== $current->from || $current->price > $previous->price + 0.00005 ) {
				break;
			}
			--$index;
		}

		return $intervals[ $index ]->from;
	}

	/**
	 * Lowest price among intervals overlapping [start, end).
	 *
	 * @param Interval[] $intervals Sorted by start.
	 * @param int        $start     Start of the period.
	 * @param int        $end       End of the period (exclusive).
	 * @param int|null   $t0        Start of the reduction.
	 * @param Interval[] $extra     Count for the price, not for the completeness of the history.
	 */
	private function lowest( array $intervals, int $start, int $end, ?int $t0, array $extra = array() ): Reference {
		$lowest   = null;
		$earliest = null;

		foreach ( $intervals as $interval ) {
			if ( ! $interval->overlaps( $start, $end ) ) {
				continue;
			}
			if ( null === $lowest || $interval->price < $lowest ) {
				$lowest = $interval->price;
			}
			if ( null === $earliest || $interval->from < $earliest ) {
				$earliest = $interval->from;
			}
		}

		if ( null === $lowest ) {
			return new Reference( Reference::STATUS_NO_HISTORY, null, $t0, false );
		}

		foreach ( $extra as $interval ) {
			if ( ! $interval->is_empty() && $interval->overlaps( $start, $end ) && $interval->price < $lowest ) {
				$lowest = $interval->price;
			}
		}

		return new Reference( Reference::STATUS_OK, $lowest, $t0, $earliest <= $start );
	}
}