<?php
/**
 * Ledger and approval-queue health alarms.
 *
 * @package AgentFirewall
 */

declare(strict_types=1);

namespace AgentFirewall\Alert;

use AgentFirewall\Ledger\LedgerWriter;
use AgentFirewall\Pending\ExpiryCron;
use AgentFirewall\Pending\PendingActionService;
use AgentFirewall\Repository\PendingRepository;
use Closure;
use DateTimeImmutable;

defined( 'ABSPATH' ) || exit;

/**
 * Raises two alarms that used to be silent (AF-20.2, free under ADR-14 §3):
 *
 * - **Chain broken.** The ledger is verified daily, the way
 *   `wp agent-firewall verify` does it, rather than only when somebody
 *   thinks to run that command.
 * - **Queue backlog.** An action held for over a day, checked hourly after
 *   the expiry sweep. The threshold is never later than half the pending
 *   TTL, so the alarm always lands with time left to decide.
 *
 * Each fires once per problem, then a daily reminder while it lasts; a
 * repair, or an emptied queue, makes the next occurrence new. The throttle
 * lives here, once for every channel, in an option rather than a transient:
 * an evicted transient would turn a daily reminder into an hourly one.
 * AnomalyNotifier and WebhookDispatcher deliver the events.
 */
final class HealthCheck {

	/**
	 * Daily verification hook.
	 */
	public const HOOK = 'adaf_health_verify';

	/**
	 * Alarm state: what was last raised, and when.
	 */
	public const OPTION_STATE = 'adaf_health_alerts';

	/**
	 * Age at which a held action counts as a backlog.
	 */
	private const BACKLOG_AFTER = 86400;

	/**
	 * Gap between reminders for an unresolved problem.
	 */
	private const REMIND_AFTER = 86400;

	/**
	 * Current time.
	 *
	 * @var Closure(): DateTimeImmutable
	 */
	private Closure $now;

	/**
	 * Constructor.
	 *
	 * @param LedgerWriter                       $writer  Chain verifier.
	 * @param PendingRepository                  $pending Approval queue.
	 * @param (Closure(): DateTimeImmutable)|null $now    Clock; defaults to now.
	 */
	public function __construct(
		private readonly LedgerWriter $writer,
		private readonly PendingRepository $pending,
		?Closure $now = null
	) {
		$this->now = $now ?? static fn (): DateTimeImmutable => new DateTimeImmutable( 'now' );
	}

	/**
	 * Hook both checks. Scheduling waits for init (see RetentionCron).
	 */
	public function register(): void {
		add_action( 'init', array( $this, 'schedule' ) );
		add_action( self::HOOK, array( $this, 'verify_chain' ) );
		// After ExpiryCron's own handler, so what just expired is not counted.
		add_action( ExpiryCron::HOOK, array( $this, 'check_backlog' ), 20 );
	}

	/**
	 * Ensure the daily verification is scheduled. Safe to call repeatedly.
	 */
	public function schedule(): void {
		if ( false === wp_next_scheduled( self::HOOK ) ) {
			wp_schedule_event( time(), 'daily', self::HOOK );
		}
	}

	/**
	 * Remove the schedule (deactivation).
	 */
	public static function unschedule(): void {
		wp_clear_scheduled_hook( self::HOOK );
	}

	/**
	 * Verify the chain; raise adaf_anomaly_chain_broken( $entry_id, $reminder ).
	 */
	public function verify_chain(): void {
		$state  = $this->state();
		$broken = $this->writer->verify();

		if ( null === $broken ) {
			unset( $state['chain'] );
			$this->save( $state );
			return;
		}

		$now      = ( $this->now )()->getTimestamp();
		$previous = $state['chain'] ?? null;
		$same     = is_array( $previous ) && ( $previous['entry'] ?? null ) === $broken;
		if ( $same && $now - (int) ( $previous['at'] ?? 0 ) < self::REMIND_AFTER ) {
			return;
		}

		$state['chain'] = array(
			'entry' => $broken,
			'at'    => $now,
		);
		$this->save( $state );

		do_action( 'adaf_anomaly_chain_broken', $broken, $same );
	}

	/**
	 * Check the queue; raise adaf_anomaly_queue_backlog( $count, $oldest ).
	 */
	public function check_backlog(): void {
		$state  = $this->state();
		$oldest = $this->pending->oldest_held_at();

		if ( null === $oldest ) {
			unset( $state['backlog'] );
			$this->save( $state );
			return;
		}

		$now = ( $this->now )()->getTimestamp();
		if ( $now - $oldest->getTimestamp() < $this->threshold() ) {
			return;
		}

		$last = $state['backlog']['at'] ?? null;
		if ( is_int( $last ) && $now - $last < self::REMIND_AFTER ) {
			return;
		}

		$state['backlog'] = array( 'at' => $now );
		$this->save( $state );

		do_action( 'adaf_anomaly_queue_backlog', $this->pending->count_by_status( 'pending' ), $oldest );
	}

	/**
	 * Backlog threshold: a day, or half the pending TTL if that is sooner.
	 */
	private function threshold(): int {
		$ttl = get_option( 'adaf_pending_ttl', PendingActionService::DEFAULT_TTL );
		$ttl = is_numeric( $ttl ) && (int) $ttl > 0 ? (int) $ttl : PendingActionService::DEFAULT_TTL;

		return min( self::BACKLOG_AFTER, intdiv( $ttl, 2 ) );
	}

	/**
	 * Stored alarm state.
	 *
	 * @return array<string, mixed>
	 */
	private function state(): array {
		$state = get_option( self::OPTION_STATE, array() );

		return is_array( $state ) ? $state : array();
	}

	/**
	 * Store alarm state. Not autoloaded: read only by cron.
	 *
	 * @param array<string, mixed> $state State.
	 */
	private function save( array $state ): void {
		update_option( self::OPTION_STATE, $state, false );
	}
}