<?php

namespace AOP\App\Database;

use AOP\App\Admin\AdminPages\SubpageWhatsNew;

use AOP\App\Plugin;

/**
 * Brings the plugin table and its data to the format of this version: the table definition of `DB`, and every
 * `page_value` as JSON instead of PHP-serialized. Safe to run again and again, and for a crash halfway.
 *
 * A row is only rewritten when reading the new form gives exactly what reading the old one gave. A row that does
 * not pass (an object in the old data, invalid text) stays as it is; `PageRepository` reads both forms.
 */
class Upgrader
{
    private const LOCK = 'aop_upgrading';

    /**
     * The rows as 0.9.x wrote them, kept for a while in case somebody goes back to that version.
     */
    public const BACKUP = Plugin::PREFIX_ . 'backup_before_json';

    /**
     * When the backup is removed (a timestamp). A small option of its own, so that checking it does not load the backup.
     */
    public const BACKUP_EXPIRES = Plugin::PREFIX_ . 'backup_expires';

    /**
     * Run when the stored `aop_db_version` is not this version's. Nothing to do for data another plugin owns.
     *
     * @return void
     */
    public static function maybeRun(): void
    {
        self::runIfNeeded();
    }

    /**
     * @return bool True when it ran.
     */
    public static function runIfNeeded(): bool
    {
        if (Plugin::isDisabled() || Plugin::dataOwner() !== 'free' || get_option(Plugin::PREFIX_ . 'db_version') === Plugin::DB_VERSION) {
            return false;
        }

        // Two requests at the same time must not both do it.
        if (get_transient(self::LOCK)) {
            return false;
        }

        set_transient(self::LOCK, 1, MINUTE_IN_SECONDS);

        try {
            self::run();
        } finally {
            delete_transient(self::LOCK);
        }

        return true;
    }

    /**
     * @return array{migrated: int, skipped: int} Rows rewritten as JSON, and rows that stay PHP-serialized.
     */
    public static function run(): array
    {
        // An update of a site that had the plugin (a fresh install already has the db version): tell what is new.
        if (get_option(Plugin::PREFIX_ . 'db_version') !== false) {
            SubpageWhatsNew::remember();
        }

        // Before anything is changed: the old rows, as they are.
        self::backup();

        DB::createPluginTable();

        $result = PageRepository::migrateToJson();

        update_option(Plugin::PREFIX_ . 'db_version', Plugin::DB_VERSION, false);

        return $result;
    }

    /**
     * Keep the rows that are still in the PHP-serialized form of 0.9.x, once. Version 0.9.x cannot read the JSON
     * form, so this is the way back. It is removed after `aop_backup_days` (90) days, or with the plugin.
     *
     * @return bool True when a backup was made now.
     */
    public static function backup(): bool
    {
        if (get_option(self::BACKUP, false) !== false) {
            return false;
        }

        $rows = [];

        foreach (PageRepository::rows() as $row) {
            if (PageRepository::formatOf($row->page_value) === 0) {
                $rows[] = [
                    'id' => (int) $row->id,
                    'time' => $row->time,
                    'menu_slug' => $row->menu_slug,
                    'page_value' => $row->page_value,
                    'plugin' => $row->plugin ?? Plugin::_NAME,
                ];
            }
        }

        if (! $rows) {
            return false;
        }

        /**
         * How many days the backup of the pages from before the JSON storage is kept.
         *
         * @since 1.0.0
         *
         * @param int $days Default 90.
         */
        $days = max(1, (int) apply_filters('aop_backup_days', 90));

        update_option(self::BACKUP, ['created' => time(), 'plugin_version' => Plugin::releaseVersion(), 'rows' => $rows], false);
        update_option(self::BACKUP_EXPIRES, time() + $days * DAY_IN_SECONDS, true);

        return true;
    }

    /**
     * Remove the backup when its time is up. Runs on every admin request; it reads one small option.
     */
    public static function expireBackup(): void
    {
        $expires = (int) get_option(self::BACKUP_EXPIRES, 0);

        if ($expires > 0 && time() > $expires) {
            self::deleteBackup();
        }
    }

    public static function deleteBackup(): void
    {
        delete_option(self::BACKUP);
        delete_option(self::BACKUP_EXPIRES);
    }

    /**
     * Put the pages back as they were before the upgrade, PHP-serialized, so that version 0.9.x can read them.
     * Replaces everything in the table: pages that were made or changed after the upgrade are lost. Not used by
     * the plugin itself; run it by hand, see `docs/schema.md`.
     *
     * @return int The number of pages that were put back, or 0 when there is no backup.
     */
    public static function restoreBackup(): int
    {
        $backup = get_option(self::BACKUP, false);

        if (! is_array($backup) || empty($backup['rows'])) {
            return 0;
        }

        return PageRepository::replaceAllWithLegacyRows($backup['rows']);
    }
}