<?php

declare(strict_types=1);

namespace FreshetBackup;

/**
 * Whether a backup has gone missing, and whether a catch-up run is owed.
 *
 * A run that *fails* reports itself: Status holds its outcome and the notice
 * carries its sentence. A run that *never happens* reports nothing, because
 * nothing recorded it — and WP-Cron only fires when a page is loaded, so a site
 * whose pages come from a cache can go days without a load that reaches PHP.
 *
 * Two answers, from one reading of the status row, the cron event and the
 * interval:
 *
 *   - **Overdue** — nothing has succeeded within twice the interval. The screen
 *     says so and an admin notice carries it, exactly as a failure does. Which
 *     sentence depends on the event: a due time stuck in the past means WP-Cron
 *     has stopped; a due time still moving means the runs themselves are
 *     failing, and blaming WP-Cron there would be a diagnosis of the wrong
 *     thing.
 *   - **Owed** — the due time passed more than a whole interval ago, so a cycle
 *     has been missed outright. `claim()` hands out one catch-up per interval
 *     and `Plugin::catchUp()` spends it.
 *
 * Nothing here opens a way in: it reads three option rows and the cron list.
 */
final class Health
{
    /** Overdue once this many intervals have gone by with no backup. */
    public const INTERVALS = 2;

    /** When the last catch-up was attempted. One option row, not autoloaded, never a secret. */
    public const ATTEMPT_OPTION = 'freshet_backup_catchup';

    /** @var callable(): int */
    private $clock;

    /** @var callable(): (int|false) */
    private $event;

    /**
     * @param (callable(): int)|null         $clock
     * @param (callable(): (int|false))|null $event when the backup event is due
     */
    public function __construct(
        private readonly Config $config,
        private readonly Status $status,
        ?callable $clock = null,
        ?callable $event = null,
    ) {
        $this->clock = $clock ?? 'time';
        $this->event = $event ?? static fn (): int|false => wp_next_scheduled(Schedule::HOOK);
    }

    /** How long a backup may be absent before it counts as missing. */
    public function grace(): int
    {
        return self::INTERVALS * $this->config->interval;
    }

    /** When a backup last worked, or null when none ever has. */
    public function lastSuccess(): ?int
    {
        return $this->status->success();
    }

    /** When the next run is due, or null when no backup event is on the cron list. */
    public function due(): ?int
    {
        $due = ($this->event)();

        return is_int($due) && $due > 0 ? $due : null;
    }

    /**
     * How long the scheduled run has been sitting past its time, in seconds; 0
     * when it is not. WP-Cron is always a little late — it waits for a page
     * load — so only a whole interval of lateness means anything.
     */
    public function late(): int
    {
        $due = $this->due();

        return $due === null ? 0 : max(0, ($this->clock)() - $due);
    }

    /**
     * True when no backup has been made for too long. Measured from the last
     * success where there is one; from the overdue event where there is not,
     * because a site that has never backed up has nothing else to measure from.
     *
     * Never from before the schedule was last set: shorten weekly to hourly the
     * day after a good run and that run is already "two intervals" old, though
     * the new schedule has not had its first turn yet.
     */
    public function overdue(): bool
    {
        if (!$this->config->enabled) {
            return false;
        }
        $success = $this->lastSuccess();
        if ($success === null) {
            return $this->late() > $this->grace();
        }
        $from = max($success, (int) get_option(Schedule::SET_OPTION, 0));

        return ($this->clock)() - $from > $this->grace();
    }

    /** True when a whole cycle has been missed, so a catch-up run is owed. */
    public function owed(): bool
    {
        return $this->config->enabled && $this->late() > $this->config->interval;
    }

    /** The sentence the screen and the notice carry, or null when nothing is missing. */
    public function problem(): ?string
    {
        if (!$this->overdue()) {
            return null;
        }
        $now = ($this->clock)();
        $success = $this->lastSuccess();

        // The event is still moving, so something is running the schedule and it
        // is the runs that fail. Status already carries the reason why. (Only a
        // site that has succeeded before can reach this: with no success at all,
        // overdue is itself measured from a stuck event.)
        if ($this->late() <= $this->config->interval) {
            return sprintf(
                /* translators: %s: a length of time, e.g. "3 days" */
                __('No backup has worked in %s. The schedule is still running, so the runs themselves are failing. The last error says why.', 'freshet-backup'),
                human_time_diff((int) $success, $now)
            );
        }

        $stopped = __('WP-Cron looks stopped. It only runs when someone visits the site, and a page cache can keep those visits from reaching it. Press Run backup now, then see the readme for how to keep backups on schedule.', 'freshet-backup');

        return $success === null
            ? sprintf(
                /* translators: %s: a length of time, e.g. "3 days" */
                __('No backup has been made yet, and the first one was due %s ago.', 'freshet-backup'),
                human_time_diff($now - $this->late(), $now)
            ) . ' ' . $stopped
            : sprintf(
                /* translators: 1: a length of time, e.g. "3 days"; 2: e.g. "every day" */
                __('No backup has worked in %1$s, and backups are set to run %2$s.', 'freshet-backup'),
                human_time_diff($success, $now),
                Schedule::describe($this->config->interval)
            ) . ' ' . $stopped;
    }

    /**
     * Take the catch-up slot, or refuse: one per interval, whether the run that
     * spends it works or not. Written before that run rather than after, so a
     * dump that dies does not bring the next wp-admin load straight back to it.
     */
    public function claim(): bool
    {
        if (!$this->owed()) {
            return false;
        }
        $now = ($this->clock)();
        if ($now - (int) get_option(self::ATTEMPT_OPTION, 0) < $this->config->interval) {
            return false;
        }
        update_option(self::ATTEMPT_OPTION, $now, false);

        return true;
    }
}