<?php

declare(strict_types=1);

namespace WordPress\CloudflareWorkersAiProvider\Embeddings;

use WordPress\CloudflareWorkersAiProvider\Backfill\Backfill;

use const WordPress\CloudflareWorkersAiProvider\AIPCF_SETTINGS_OPTION;

if (!defined('ABSPATH')) {
    exit;
}

/**
 * Keeps the index table in step with content changes, and schedules the worker.
 * While embeddings are off nothing here runs except noticing that they were
 * switched on (and unscheduling the worker).
 */
final class Queue
{
    /** Selection settings: a change means reconciling what is in the store. */
    private const SELECTION_KEYS = ['embed_post_types', 'embed_statuses', 'embed_attachments', 'embed_tax_mode', 'embed_terms', 'embed_after'];

    /** Content settings: a change means every item's text differs, so all are queued again. */
    private const CONTENT_KEYS = ['embed_fields', 'embed_meta_keys', 'embed_store_text'];

    /** The minimum length: posts on either side of it are checked again (no neurons for unchanged text). */
    private const LENGTH_KEYS = ['embed_min_words'];

    public static function boot(): void
    {
        add_action(Ingest::HOOK, [self::class, 'runScheduled']);
        add_action('init', [self::class, 'schedule'], 20);
        Mover::boot();
        add_action('update_option_' . AIPCF_SETTINGS_OPTION, [self::class, 'onSettingsChange'], 10, 2);
        add_action('add_option_' . AIPCF_SETTINGS_OPTION, [self::class, 'onSettingsAdded'], 10, 2);
        add_action('aipcf_version_changed', [self::class, 'catchUp']);
        if (Settings::enabled()) {
            self::hookContent();
        }
    }

    public static function hookContent(): void
    {
        if (has_action('save_post', [self::class, 'onChange']) !== false) {
            return;
        }
        add_action('save_post', [self::class, 'onChange'], 20);
        add_action('add_attachment', [self::class, 'onChange'], 20);
        add_action('edit_attachment', [self::class, 'onChange'], 20);
        add_action('before_delete_post', [self::class, 'onDelete']);
        // Trashing an image (MEDIA_TRASH) may not pass through save_post.
        add_action('trashed_post', [self::class, 'onChange'], 20);
        add_action('untrashed_post', [self::class, 'onChange'], 20);
        add_action('set_object_terms', [self::class, 'onTerms'], 10, 4);
        add_action('added_post_meta', [self::class, 'onMeta'], 10, 3);
        add_action('updated_post_meta', [self::class, 'onMeta'], 10, 3);
        add_action('deleted_post_meta', [self::class, 'onMeta'], 10, 3);
        // Author names are embedded when "Author name" is ticked. WordPress changes them
        // without saving the posts, so re-queue that author's posts.
        add_action('profile_update', [self::class, 'onAuthorChange'], 10, 1);
        add_action('deleted_user', [self::class, 'onAuthorDeleted'], 10, 2);
    }

    /**
     * After an update, a downgrade and upgrade again, or a deactivation: content may have
     * changed while no hooks were watching. Every indexed item is checked again (unchanged
     * ones are recognised by their content hash and cost no neurons), and a reconcile adds
     * what is new and removes what was deleted.
     */
    public static function catchUp(): void
    {
        if (!Settings::enabled() || !IndexTable::exists()) {
            return;
        }
        IndexTable::requeueIndexed();
        Ingest::startReconcile();
        self::nudge();
    }

    public static function runScheduled(): void
    {
        Ingest::tick();
    }

    public static function schedule(): void
    {
        $next = wp_next_scheduled(Ingest::HOOK);
        if (Settings::enabled() && !$next) {
            wp_schedule_event(time() + 300, 'hourly', Ingest::HOOK);
        } elseif (!Settings::enabled() && $next) {
            wp_clear_scheduled_hook(Ingest::HOOK);
        }
    }

    /**
     * Runs the worker about a minute after a change, rather than at the next hourly tick.
     */
    public static function nudge(): void
    {
        $next = wp_next_scheduled(Ingest::HOOK);
        if ($next === false || $next > time() + 2 * MINUTE_IN_SECONDS) {
            wp_schedule_single_event(time() + MINUTE_IN_SECONDS, Ingest::HOOK);
        }
    }

    /**
     * @param int|string $postId
     */
    public static function onChange($postId): void
    {
        $postId = (int) $postId;
        if ($postId <= 0 || wp_is_post_revision($postId) || wp_is_post_autosave($postId) || !IndexTable::exists()) {
            return;
        }
        $post = get_post($postId);
        if (!$post instanceof \WP_Post || $post->post_status === 'auto-draft') {
            return;
        }
        $type = IndexTable::objectType($post);
        if (Selection::isEligible($post)) {
            IndexTable::markPending($type, $postId);
            self::nudge();
        } elseif (IndexTable::get($type, $postId) !== null) {
            IndexTable::markDeleting($type, $postId);
            self::nudge();
        }
        if ($type === 'post' && Settings::includeAttachments()) {
            // Images follow their post: unpublishing, protecting or leaving out the post
            // takes its images out of the store too (and publishing brings them back).
            foreach (get_children(['post_parent' => $postId, 'post_type' => 'attachment', 'fields' => 'ids', 'post_status' => 'any']) as $childId) {
                self::onChange((int) $childId);
            }
        }
    }

    /**
     * @param int|string $postId
     */
    public static function onDelete($postId): void
    {
        $post = get_post((int) $postId);
        if (!$post instanceof \WP_Post || !IndexTable::exists()) {
            return;
        }
        IndexTable::markDeleting(IndexTable::objectType($post), (int) $postId);
        self::nudge();
    }

    /**
     * @param int|string $userId
     */
    public static function onAuthorChange($userId): void
    {
        if (in_array('author', Settings::fields(), true) && IndexTable::exists()) {
            self::requeueAuthor((int) $userId);
        }
    }

    /**
     * A deleted user's posts are deleted (their vectors go with them) or given to $reassign.
     *
     * @param int|string      $userId
     * @param int|string|null $reassign
     */
    public static function onAuthorDeleted($userId, $reassign = null): void
    {
        if ($reassign && in_array('author', Settings::fields(), true) && IndexTable::exists()) {
            self::requeueAuthor((int) $reassign);
        }
    }

    private static function requeueAuthor(int $authorId): void
    {
        foreach (Selection::kinds() as $kind) {
            if ($kind === 'attachment') {
                continue;
            }
            for ($page = 1; ($ids = Selection::ids($kind, $page, 500, $authorId)) !== []; $page++) {
                IndexTable::markPendingMany('post', $ids);
            }
        }
        self::nudge();
    }

    /**
     * @param int|string $objectId
     * @param mixed      $terms
     * @param mixed      $ttIds
     * @param string     $taxonomy
     */
    public static function onTerms($objectId, $terms = null, $ttIds = null, $taxonomy = ''): void
    {
        if (Settings::taxMode() !== 'none' || in_array('terms', Settings::fields(), true)) {
            self::onChange($objectId);
        }
    }

    /**
     * @param mixed      $metaId
     * @param int|string $objectId
     * @param string     $metaKey
     */
    public static function onMeta($metaId, $objectId, $metaKey = ''): void
    {
        $watched = [Selection::EXCLUDE_META, '_wp_attachment_image_alt'];
        if (in_array('custom_fields', Settings::fields(), true)) {
            $watched = array_merge($watched, Settings::metaKeys());
        }
        if (in_array('meta_description', Settings::fields(), true)) {
            $watched[] = Backfill::metaDescriptionKey();
        }
        // Never this plugin's own meta (see Settings::sanitize): saving a related list is not an edit.
        if (strpos((string) $metaKey, '_aipcf_related') !== 0 && in_array((string) $metaKey, $watched, true)) {
            self::onChange($objectId);
        }
    }

    /**
     * @param mixed $old
     * @param mixed $new
     */
    public static function onSettingsChange($old, $new): void
    {
        // A key missing from either side is its default, not "changed": the stored option may
        // predate a setting, or have been written by code without every key.
        $old   = (is_array($old) ? $old : []) + Settings::defaults();
        $new   = (is_array($new) ? $new : []) + Settings::defaults();
        $wasOn = !empty($old['embeddings_enabled']);
        $isOn  = !empty($new['embeddings_enabled']);
        // Another store or index with the same model: copy the vectors there (no neurons).
        if (Mover::afterSave()) {
            self::nudge();
        }
        if (!$isOn) {
            if ($wasOn) {
                wp_clear_scheduled_hook(Ingest::HOOK);
            }
            return;
        }
        $changed = static function (array $keys) use ($old, $new): bool {
            foreach ($keys as $k) {
                if (($old[$k] ?? null) != ($new[$k] ?? null)) { // phpcs:ignore Universal.Operators.StrictComparisons.LooseNotEqual -- arrays compared by value
                    return true;
                }
            }
            return false;
        };
        if (!$wasOn) {
            IndexTable::install();
            State::resume();
            Ingest::startReconcile();
            self::hookContent();
            self::nudge();
            return;
        }
        if ($changed(self::CONTENT_KEYS)) {
            IndexTable::requeueIndexed();
        }
        if ($changed(self::LENGTH_KEYS)) {
            IndexTable::requeueIndexed();
            IndexTable::requeueSkipped();
            \WordPress\CloudflareWorkersAiProvider\Features\Related::flushCache();
            self::nudge();
        }
        if ($changed(self::SELECTION_KEYS) || $changed(self::CONTENT_KEYS)) {
            Ingest::startReconcile();
            self::nudge();
        }
    }

    /**
     * @param string $option
     * @param mixed  $value
     */
    public static function onSettingsAdded($option, $value): void
    {
        self::onSettingsChange([], $value);
    }
}