<?php
/**
 * Reconciliation engine for AILinkMaster.
 *
 * Compares the "intent" table (wp_ailm_link_rules) with the "reality" table
 * (wp_ailm_links, populated by AILM_Scout_Scanner) for a given post and brings
 * them into alignment:
 *
 *  - Links present in HTML but missing a rule → register as 'manual' with in_html=1.
 *  - Rules with in_html=1 whose link is no longer in HTML → mark 'failed'
 *    (plugin-managed) or delete (manual / pre-existing).
 *  - Rules with in_html=0 that ARE in HTML (e.g. inserted by AI/Gutenberg) →
 *    set in_html=1 so the injector won't duplicate them.
 *  - Recalculate _ailm_inbound_count for every touched target from the
 *    authoritative rule count.
 *
 * Designed to run on `save_post` (after the scanner at priority 10) at
 * priority 20. Also safe to call directly (e.g. from a bulk tool).
 *
 * Recursion guard: a static flag prevents re-entry when the reconciler
 * itself triggers meta updates.
 *
 * @since 2.1
 * @package AILinkMaster
 */

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

class AILM_Reconciler
{

    /**
     * Recursion guard. Set while reconcile_post() is running so that
     * update_post_meta() calls inside the reconciler do not re-trigger
     * save_post → reconcile_post in a loop.
     *
     * @var bool
     */
    private static $running = false;

    /**
     * Whether reconciliation is globally disabled (e.g. during bulk import).
     *
     * Set via AILM_Reconciler::disable() / enable() or the
     * 'ailm_skip_reconcile' filter.
     *
     * @var bool
     */
    private static $disabled = false;

    /**
     * Disable reconciliation globally.
     *
     * Used by bulk operations (CSV import, full-site sync) to avoid
     * per-post overhead when the operation itself manages rules.
     *
     * @return void
     */
    public static function disable()
    {
        self::$disabled = true;
    }

    /**
     * Re-enable reconciliation after a bulk operation.
     *
     * @return void
     */
    public static function enable()
    {
        self::$disabled = false;
    }

    /**
     * Hook handler for save_post.
     *
     * Runs at priority 20 (after AILM_Scout_Scanner::process_post at priority 10)
     * so that wp_ailm_links is already up to date for this post.
     *
     * @param int     $post_id Post ID being saved.
     * @param WP_Post $post    Post object (unused, accepted for hook signature).
     * @param bool    $update  Whether this is an update (unused).
     * @return void
     */
    public static function handle_save_post($post_id, $post = null, $update = null)
    {
        // Skip revisions and autosaves.
        if (wp_is_post_revision($post_id) || wp_is_post_autosave($post_id)) {
            return;
        }

        // Skip globally disabled state.
        if (self::$disabled) {
            return;
        }

        // Allow third-party code to skip reconciliation per-post.
        if (apply_filters('ailm_skip_reconcile', false, $post_id)) {
            return;
        }

        self::reconcile_post($post_id);
    }

    /**
     * Reconcile rules vs. reality for a single donor post.
     *
     * @param int $post_id Donor post ID.
     * @return array {
     *     @type int $created   Number of rules created (manual links found in HTML).
     *     @type int $confirmed Number of rules confirmed as in_html=1.
     *     @type int $failed    Number of rules marked failed (link removed from HTML).
     *     @type int $deleted   Number of rules deleted (manual link removed).
     * }
     */
    public static function reconcile_post($post_id)
    {
        $result = array(
            'created'   => 0,
            'confirmed' => 0,
            'failed'    => 0,
            'deleted'   => 0,
        );

        // Recursion guard.
        if (self::$running) {
            return $result;
        }
        self::$running = true;

        try {
            $result = self::do_reconcile($post_id);
        } finally {
            self::$running = false;
        }

        return $result;
    }

    /**
     * Internal reconciliation logic.
     *
     * @param int $post_id Donor post ID.
     * @return array Result counts.
     */
    private static function do_reconcile($post_id)
    {
        global $wpdb;

        if (!class_exists('AILM_Link_DB') || !class_exists('AILM_Link_Repository')) {
            return array('created' => 0, 'confirmed' => 0, 'failed' => 0, 'deleted' => 0);
        }

        $rules_table = AILM_Link_DB::get_rules_table();
        $links_table = AILM_Link_DB::get_links_table();

        // -----------------------------------------------------------------
        // 1. Load reality: internal links found by the scanner in this post.
        // -----------------------------------------------------------------
        // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.InterpolatedNotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter
        $real_links = $wpdb->get_results(
            $wpdb->prepare(
                "SELECT target_id, url, anchor, rule_id FROM {$links_table} WHERE donor_id = %d AND link_type = 'internal'", // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared
                $post_id
            )
        );

        // Build a lookup: normalized_url|lowercase_anchor => real link data.
        $real_map = array();
        $touched_targets = array();
        foreach ($real_links as $rl) {
            $clean_url = untrailingslashit(strtok($rl->url, '?'));
            $key = $clean_url . '|' . mb_strtolower(trim($rl->anchor), 'UTF-8');
            $real_map[$key] = $rl;
            if ((int) $rl->target_id > 0) {
                $touched_targets[(int) $rl->target_id] = true;
            }
        }

        // -----------------------------------------------------------------
        // 2. Load intent: active rules for this donor.
        // -----------------------------------------------------------------
        // We query ALL active rules (not just in_html=0) because we need to
        // verify that in_html=1 rules still have their link in HTML.
        // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, WordPress.DB.PreparedSQL.InterpolatedNotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter
        $rules = $wpdb->get_results(
            $wpdb->prepare(
                "SELECT id, target_id, target_url, anchor, source, status, in_html FROM {$rules_table} WHERE donor_id = %d AND status = 'active'", // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared
                $post_id
            )
        );

        $created = 0;
        $confirmed = 0;
        $failed = 0;
        $deleted = 0;

        // Track which real links were matched to an existing rule.
        $matched_real_keys = array();

        // -----------------------------------------------------------------
        // 3. For each active rule, check if its link is in HTML.
        // -----------------------------------------------------------------
        foreach ($rules as $rule) {
            $clean_url = untrailingslashit(strtok($rule->target_url, '?'));
            $key = $clean_url . '|' . mb_strtolower(trim($rule->anchor), 'UTF-8');

            $in_html_now = isset($real_map[$key]);

            if ($in_html_now) {
                $matched_real_keys[$key] = true;

                // The link IS in HTML. Ensure in_html=1 so the injector skips it.
                if (!isset($rule->in_html) || (int) $rule->in_html !== 1) {
                    AILM_Link_Repository::mark_in_html((int) $rule->id, true);
                    $confirmed++;
                }
            } else {
                // The link is NOT in HTML anymore.
                if (isset($rule->in_html) && (int) $rule->in_html === 1) {
                    // Was in HTML, now gone. Someone removed it.
                    $source = $rule->source;
                    if (in_array($source, array('manual', 'pre_existing', 'editor_manual'), true)) {
                        // Manual / imported link removed by user → delete the rule.
                        AILM_Link_Repository::delete_rule((int) $rule->id);
                        $deleted++;
                    } else {
                        // Plugin-managed link removed (ai, ki_manual, orphan_rescue, etc.)
                        // → mark failed so the injector can retry on next pass.
                        AILM_Link_Repository::update_rule_status((int) $rule->id, 'failed');
                        AILM_Link_Repository::mark_in_html((int) $rule->id, false);
                        $failed++;
                    }
                }
                // If in_html was already 0 (pending injection) and the link is
                // not in HTML, that's expected — the injector hasn't run yet.
                // Leave it alone.
            }
        }

        // -----------------------------------------------------------------
        // 4. For each real link NOT matched to a rule → register as manual.
        // -----------------------------------------------------------------
        foreach ($real_map as $key => $rl) {
            if (isset($matched_real_keys[$key])) {
                continue; // Already has a rule.
            }

            $target_id = (int) $rl->target_id;
            if ($target_id <= 0) {
                continue; // Couldn't resolve to a post (external or unresolved).
            }

            // Register as a manual link already present in HTML.
            $target_url = get_permalink($target_id);
            if (!$target_url) {
                continue;
            }

            AILM_Link_Repository::register_link(
                $post_id,
                $target_url,
                $rl->anchor,
                'manual',
                1,
                true // in_html = true
            );
            $created++;
            $touched_targets[$target_id] = true;
        }

        // -----------------------------------------------------------------
        // 5. Recalculate _ailm_inbound_count for all touched targets.
        // -----------------------------------------------------------------
        foreach (array_keys($touched_targets) as $target_id) {
            $count = AILM_Link_Repository::get_active_inbound_rule_count($target_id);
            update_post_meta($target_id, '_ailm_inbound_count', $count);
        }

        // Invalidate caches.
        if (method_exists('AILM_Link_Repository', 'invalidate_cache')) {
            AILM_Link_Repository::invalidate_cache();
        }

        return array(
            'created'   => $created,
            'confirmed' => $confirmed,
            'failed'    => $failed,
            'deleted'   => $deleted,
        );
    }
}