<?php
/**
 * How much work one step is allowed to do.
 *
 * @package Transtrix
 */

namespace Transtrix\Runner;

defined( 'ABSPATH' ) || exit;

/**
 * A step must stop before the host does.
 *
 * The budget is derived, never constant. A host reporting max_execution_time=30
 * and a host reporting 0 need different answers, and a constant picked for one
 * of them silently truncates work on the other.
 *
 * set_time_limit() is attempted but never relied on: it is in disable_functions
 * on plenty of shared hosts, and PHP-FPM's request_terminate_timeout and a
 * proxy's 504 are both independent of max_execution_time anyway. The 0.6 factor
 * is the actual protection.
 */
class Budget {

	/**
	 * Lowest budget worth starting a step for, in seconds.
	 */
	const FLOOR = 5;

	/**
	 * Highest budget, in seconds. Beyond this a proxy is the binding limit.
	 */
	const CEILING = 20;

	/**
	 * Fraction of memory_limit above which a step stops taking new work.
	 */
	const MEMORY_FRACTION = 0.7;

	/**
	 * When this budget started, as a unix timestamp with microseconds.
	 *
	 * @var float
	 */
	private $started = 0.0;

	/**
	 * How long this budget lasts, in seconds.
	 *
	 * @var float
	 */
	private $seconds = 0.0;

	/**
	 * Memory ceiling in bytes, or 0 when there is no limit.
	 *
	 * @var int
	 */
	private $memory_ceiling = 0;

	/**
	 * Begin a budget for this request.
	 *
	 * @return self
	 */
	public static function start(): self {
		$budget = new self();

		$budget->started        = microtime( true );
		$budget->seconds        = self::derive_seconds();
		$budget->memory_ceiling = self::derive_memory_ceiling();

		// Room for one slow entry past the budget, and still well inside the
		// lock's lifetime: a step outliving its lock would run twice at once.
		if ( function_exists( 'set_time_limit' ) ) {
			set_time_limit( Step_Lock::TTL - 60 ); // phpcs:ignore Squiz.PHP.DiscouragedFunctions.Discouraged -- one long export or restore step, bounded by the step lock.
		}

		return $budget;
	}

	/**
	 * Whether this step should stop taking new work.
	 *
	 * @return bool
	 */
	public function spent(): bool {
		return $this->expired() || $this->exhausted();
	}

	/**
	 * Whether the time budget is used up.
	 *
	 * @return bool
	 */
	public function expired(): bool {
		return $this->elapsed() >= $this->seconds;
	}

	/**
	 * Whether memory is close enough to the ceiling to stop.
	 *
	 * @return bool
	 */
	public function exhausted(): bool {
		if ( 0 === $this->memory_ceiling ) {
			return false;
		}

		return memory_get_usage( true ) > ( $this->memory_ceiling * self::MEMORY_FRACTION );
	}

	/**
	 * How long this budget lasts.
	 *
	 * @return float
	 */
	public function seconds(): float {
		return $this->seconds;
	}

	/**
	 * How long this budget has been running.
	 *
	 * @return float
	 */
	public function elapsed(): float {
		return microtime( true ) - $this->started;
	}

	/**
	 * Seconds of work one step may attempt on this host.
	 *
	 * @return float
	 */
	private static function derive_seconds(): float {
		$ini = (int) ini_get( 'max_execution_time' );

		$seconds = $ini > 0
			? max( self::FLOOR, min( self::CEILING, (int) floor( $ini * 0.6 ) ) )
			: self::CEILING;

		/**
		 * Filter the per-step time budget, in seconds.
		 *
		 * @param float $seconds Derived budget.
		 */
		$seconds = (float) apply_filters( 'transtrix_step_budget', (float) $seconds );

		return max( 1.0, $seconds );
	}

	/**
	 * The memory ceiling in bytes, or 0 when unlimited.
	 *
	 * @return int
	 */
	private static function derive_memory_ceiling(): int {
		$limit = wp_convert_hr_to_bytes( (string) ini_get( 'memory_limit' ) );

		return $limit > 0 ? (int) $limit : 0;
	}
}