<?php
if ( ! defined( 'ABSPATH' ) ) exit;

/**
 * Admin REST API and WP admin page.
 * React dashboard communicates via /wp-json/semantic-admin/v1/
 */
class Semantic_Admin_API {

    const NS = 'semantic-admin/v1';

    /** Hook suffixes for our admin pages, captured so enqueue() can target them. */
    private static $page_hooks = [];

    public static function init() {
        add_action( 'admin_menu',            [ __CLASS__, 'admin_menu' ] );
        add_action( 'admin_init',            [ __CLASS__, 'maybe_redirect_to_setup' ] );
        // Admin-bar pill styling — attached to core's `admin-bar` stylesheet (front + admin)
        add_action( 'wp_enqueue_scripts',    [ __CLASS__, 'admin_bar_inline_css' ] );
        add_action( 'admin_enqueue_scripts', [ __CLASS__, 'admin_bar_inline_css' ] );
        add_action( 'admin_enqueue_scripts', [ __CLASS__, 'enqueue' ] );
        add_action( 'admin_enqueue_scripts', [ __CLASS__, 'dashboard_widget_assets' ] );
        add_action( 'rest_api_init',         [ __CLASS__, 'register_routes' ] );
        add_action( 'wp_dashboard_setup',    [ __CLASS__, 'register_dashboard_widget' ] );
        add_action( 'admin_bar_menu',        [ __CLASS__, 'admin_bar_item' ], 999 );
        add_action( 'enqueue_block_editor_assets', [ __CLASS__, 'enqueue_editor_panel' ] );

        // Keep the admin-bar "N pages not in AI Data Layer" count fresh — the
        // transient is hour-cached, so bust it whenever the publish set changes.
        add_action( 'save_post',      [ __CLASS__, 'flush_unanalysed_cache' ] );
        add_action( 'deleted_post',   [ __CLASS__, 'flush_unanalysed_cache' ] );
        add_action( 'trashed_post',   [ __CLASS__, 'flush_unanalysed_cache' ] );
        add_action( 'untrashed_post', [ __CLASS__, 'flush_unanalysed_cache' ] );
    }

    /** Invalidate the cached unanalysed-page count (admin-bar pill). */
    public static function flush_unanalysed_cache() {
        delete_transient( 'semantic_unanalysed_count' );
    }

    /** Adds the "Add to AI Data Layer" button to the Gutenberg post-publish panel. */
    public static function enqueue_editor_panel() {
        $screen = get_current_screen();
        if ( $screen && ! in_array( $screen->post_type, Semantic_Settings::post_types(), true ) ) return;

        wp_enqueue_script(
            'semantic-editor-panel',
            SEMANTIC_URL . 'admin/js/editor-panel.js',
            [ 'wp-plugins', 'wp-edit-post', 'wp-element', 'wp-components', 'wp-data', 'wp-api-fetch' ],
            SEMANTIC_VERSION,
            true
        );
        wp_localize_script( 'semantic-editor-panel', 'semanticEditorData', [
            'postTypes'    => Semantic_Settings::post_types(),
            'autoAnalyse'  => Semantic_Settings::auto_analyse(),
            'pricingUrl'   => 'https://ai-datalayer.com/pricing',
            'billingUrl'   => admin_url( 'admin.php?page=semantic' ),
            'setupUrl'     => admin_url( 'admin.php?page=semantic-setup' ),
        ] );
    }

    // ── WP Dashboard widget ───────────────────────────────────────────────────

    public static function register_dashboard_widget() {
        wp_add_dashboard_widget(
            'semantic_ai_data_layer',
            'AI Data Layer — Semantic Score',
            [ __CLASS__, 'render_dashboard_widget' ]
        );
    }

    /** Register + enqueue the dashboard widget CSS (Dashboard screen only). */
    public static function dashboard_widget_assets( $hook ) {
        if ( 'index.php' !== $hook ) return;
        wp_register_style( 'semantic-dashboard-widget', false, [], SEMANTIC_VERSION );
        wp_enqueue_style( 'semantic-dashboard-widget' );
        wp_add_inline_style( 'semantic-dashboard-widget', self::dashboard_widget_css() );
    }

    /** CSS for the at-a-glance dashboard widget (enqueued, not echoed inline). */
    private static function dashboard_widget_css() {
        return ".aidl-widget{font-family:'Inter',system-ui,sans-serif;padding:4px 0;}"
            . ".aidl-scores{display:flex;gap:12px;flex-wrap:wrap;margin-bottom:16px;align-items:flex-end;}"
            . ".aidl-dial{text-align:center;display:inline-block;}"
            . ".aidl-dial span{display:block;font-size:10px;color:#5A6A7A;text-transform:uppercase;letter-spacing:.06em;margin-top:3px;font-weight:500;}"
            . ".aidl-btns{display:flex;gap:8px;flex-wrap:wrap;}"
            . ".aidl-btn{display:inline-block;padding:7px 14px;border-radius:6px;font-size:12px;font-weight:600;text-decoration:none;cursor:pointer;font-family:inherit;}"
            . ".aidl-btn-primary{background:#0D1F3C;color:#1ECBA4;}"
            . ".aidl-btn-secondary{background:transparent;color:#0D1F3C;border:1px solid rgba(13,31,60,.2);}";
    }

    public static function render_dashboard_widget() {
        $c    = Semantic_Cohesion::latest() ?: [];
        $url  = admin_url( 'admin.php?page=semantic' );
        $scores = [
            'Overall'      => (int) ( $c['score']          ?? 0 ),
            'Connectivity' => (int) ( $c['connectivity']   ?? 0 ),
            'Clusters'     => (int) ( $c['clusters']       ?? 0 ),
            'Depth'        => (int) ( $c['depth']          ?? 0 ),
            'Alignment'    => (int) ( $c['core_alignment'] ?? 0 ),
        ];

        echo '<div class="aidl-widget">';
        echo '<div class="aidl-scores">';
        foreach ( $scores as $label => $score ) {
            $size   = $label === 'Overall' ? 72 : 54;
            $r      = $label === 'Overall' ? 28 : 20;
            $cx     = $size / 2;
            $circ   = 2 * M_PI * $r;
            $dash   = $circ * ( 1 - $score / 100 );
            $color  = $score >= 70 ? '#1ECBA4' : ( $score >= 40 ? '#f59e0b' : '#ef4444' );
            $fs     = $label === 'Overall' ? 14 : 11;
            echo '<div class="aidl-dial">'
                . '<svg width="' . esc_attr( $size ) . '" height="' . esc_attr( $size ) . '" viewBox="0 0 ' . esc_attr( $size ) . ' ' . esc_attr( $size ) . '">'
                . '<circle cx="' . esc_attr( $cx ) . '" cy="' . esc_attr( $cx ) . '" r="' . esc_attr( $r ) . '" fill="none" stroke="rgba(13,31,60,.1)" stroke-width="5"/>'
                . '<circle cx="' . esc_attr( $cx ) . '" cy="' . esc_attr( $cx ) . '" r="' . esc_attr( $r ) . '" fill="none" stroke="' . esc_attr( $color ) . '" stroke-width="5"'
                . ' stroke-dasharray="' . esc_attr( $circ ) . '" stroke-dashoffset="' . esc_attr( $dash ) . '"'
                . ' stroke-linecap="round" transform="rotate(-90 ' . esc_attr( $cx ) . ' ' . esc_attr( $cx ) . ')"/>'
                . '<text x="' . esc_attr( $cx ) . '" y="' . esc_attr( $cx + 5 ) . '" text-anchor="middle" font-size="' . esc_attr( $fs ) . '" font-weight="700"'
                . ' fill="' . esc_attr( $color ) . '" font-family="Inter,system-ui,sans-serif">' . esc_html( $score ) . '</text>'
                . '</svg>'
                . '<span>' . esc_html( $label ) . '</span>'
                . '</div>';
        }
        echo '</div>';
        if ( ! empty( $c['computed_at'] ) ) {
            echo '<p style="font-size:11px;color:#9ca3af;margin:0 0 12px;">Updated: ' . esc_html( $c['computed_at'] ) . '</p>';
        }
        echo '<div class="aidl-btns">'
            . '<a href="' . esc_url( $url . '#recommendations' ) . '" class="aidl-btn aidl-btn-primary">View recommendations</a>'
            . '<a href="' . esc_url( $url . '#content' ) . '" class="aidl-btn aidl-btn-secondary">Analyse content</a>'
            . '</div>';
        echo '</div>';
    }

    // ── Admin bar notification ────────────────────────────────────────────────

    public static function admin_bar_item( $wp_admin_bar ) {
        if ( ! current_user_can( 'manage_options' ) ) return;

        // Billing problem takes priority — surfaced from the status cached by quota().
        // A failed payment blocks analysis, so flag it loudly and skip the usual pill.
        $billing = get_transient( 'semantic_billing_status' );
        if ( $billing === 'past_due' || $billing === 'unpaid' ) {
            $red_icon = '<svg viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect width="20" height="20" rx="4" fill="#0D1F3C"/><rect x="3" y="3" width="6" height="6" rx="1" fill="#ef4444"/><rect x="11" y="3" width="6" height="6" rx="1" fill="#ef4444" opacity=".7"/><rect x="3" y="11" width="6" height="6" rx="1" fill="#ef4444" opacity=".45"/><rect x="11" y="11" width="6" height="6" rx="1" fill="#ef4444" opacity=".3"/></svg>';
            $wp_admin_bar->add_node( [
                'id'    => 'semantic-billing',
                'title' => '<span class="aidl-bar-pill aidl-bar-pill--alert"><img src="data:image/svg+xml;base64,' . base64_encode( $red_icon ) . '" width="14" height="14" style="vertical-align:middle;margin-right:5px;" />Billing problem</span>',
                'href'  => admin_url( 'admin.php?page=semantic' ),
                'meta'  => [ 'title' => 'Your last payment failed — analysis is paused. Update your billing details.' ],
            ] );
            return;
        }

        // Cache count to avoid repeated DB hits on every admin page
        $cache_key  = 'semantic_unanalysed_count';
        $unanalysed = get_transient( $cache_key );

        if ( $unanalysed === false ) {
            global $wpdb;
            $post_types = Semantic_Settings::post_types();
            if ( empty( $post_types ) ) return;

            $placeholders = implode( ',', array_fill( 0, count( $post_types ), '%s' ) );
            // Published posts of tracked types that are neither already analysed
            // nor explicitly excluded from the AI Data Layer.
            $unanalysed = (int) $wpdb->get_var( $wpdb->prepare(
                "SELECT COUNT(*) FROM {$wpdb->posts} p
                 WHERE p.post_status='publish' AND p.post_type IN ($placeholders)
                   AND p.ID NOT IN ( SELECT post_id FROM {$wpdb->prefix}semantic_analyses WHERE status='completed' )
                   AND p.ID NOT IN ( SELECT post_id FROM {$wpdb->postmeta} WHERE meta_key=%s AND meta_value='1' )",
                array_merge( $post_types, [ Semantic_Settings::EXCLUDE_META ] )
            ) );
            set_transient( $cache_key, $unanalysed, HOUR_IN_SECONDS );
        }

        if ( $unanalysed < 1 ) return;

        $wp_admin_bar->add_node( [
            'id'     => 'semantic-unanalysed',
            'title'  => '<span class="aidl-bar-pill"><img src="data:image/svg+xml;base64,' . base64_encode( '<svg viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect width="20" height="20" rx="4" fill="#0D1F3C"/><rect x="3" y="3" width="6" height="6" rx="1" fill="#1ECBA4"/><rect x="11" y="3" width="6" height="6" rx="1" fill="#1ECBA4" opacity=".7"/><rect x="3" y="11" width="6" height="6" rx="1" fill="#1ECBA4" opacity=".45"/><rect x="11" y="11" width="6" height="6" rx="1" fill="#1ECBA4" opacity=".3"/></svg>' ) . '" width="14" height="14" style="vertical-align:middle;margin-right:5px;" />' . $unanalysed . ' page' . ( $unanalysed !== 1 ? 's' : '' ) . ' not in AI Data Layer</span>',
            'href'   => admin_url( 'admin.php?page=semantic' ),
            'meta'   => [ 'title' => 'Analyse your content in AI Data Layer' ],
        ] );
    }

    /**
     * Admin-bar pill styling. Added as inline CSS on core's `admin-bar` stylesheet
     * handle (which loads on both the front-end and admin toolbars) instead of
     * echoing a raw <style> tag into wp_head / admin_head.
     */
    public static function admin_bar_inline_css() {
        if ( ! is_admin_bar_showing() ) return;
        wp_add_inline_style( 'admin-bar', self::admin_bar_css() );
    }

    private static function admin_bar_css() {
        return '#wpadminbar #wp-admin-bar-semantic-unanalysed > .ab-item{padding:0 10px !important;}'
            . '#wpadminbar #wp-admin-bar-semantic-unanalysed .aidl-bar-pill{display:inline-flex;align-items:center;color:#1ECBA4;font-size:12px;font-weight:600;line-height:1;letter-spacing:0.01em;}'
            . '#wpadminbar #wp-admin-bar-semantic-unanalysed .aidl-bar-pill img{width:14px !important;height:14px !important;vertical-align:middle !important;margin-right:5px !important;flex-shrink:0 !important;display:inline-block !important;}'
            . '#wpadminbar #wp-admin-bar-semantic-billing > .ab-item{padding:0 10px !important;}'
            . '#wpadminbar #wp-admin-bar-semantic-billing .aidl-bar-pill{display:inline-flex;align-items:center;color:#ef4444;font-size:12px;font-weight:700;line-height:1;letter-spacing:0.01em;}'
            . '#wpadminbar #wp-admin-bar-semantic-billing .aidl-bar-pill img{width:14px !important;height:14px !important;vertical-align:middle !important;margin-right:5px !important;flex-shrink:0 !important;display:inline-block !important;}';
    }

    // -------------------------------------------------------------------------
    // Admin menu / page
    // -------------------------------------------------------------------------


    public static function admin_menu() {
        add_menu_page(
            'AI Data Layer',
            'AI Data Layer',
            'manage_options',
            'semantic',
            [ __CLASS__, 'admin_page' ],
            // Logo mark: 2x2 grid of squares at varying opacity on navy background (brand guidelines)
            'data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjAgMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PHJlY3QgeD0iMyIgeT0iMyIgd2lkdGg9IjYiIGhlaWdodD0iNiIgcng9IjEiIGZpbGw9IndoaXRlIiBvcGFjaXR5PSIxIi8+PHJlY3QgeD0iMTEiIHk9IjMiIHdpZHRoPSI2IiBoZWlnaHQ9IjYiIHJ4PSIxIiBmaWxsPSJ3aGl0ZSIgb3BhY2l0eT0iMC43Ii8+PHJlY3QgeD0iMyIgeT0iMTEiIHdpZHRoPSI2IiBoZWlnaHQ9IjYiIHJ4PSIxIiBmaWxsPSJ3aGl0ZSIgb3BhY2l0eT0iMC40NSIvPjxyZWN0IHg9IjExIiB5PSIxMSIgd2lkdGg9IjYiIGhlaWdodD0iNiIgcng9IjEiIGZpbGw9IndoaXRlIiBvcGFjaXR5PSIwLjMiLz48L3N2Zz4=',
            80
        );

        // Rename the auto-created first submenu (defaults to the parent label) and
        // add a dedicated "Setup" page. Setup is the only sub-item we expose by
        // design — the rest of navigation lives inside the SPA.
        self::$page_hooks[] = add_submenu_page( 'semantic', 'AI Data Layer', 'AI Data Layer', 'manage_options', 'semantic', [ __CLASS__, 'admin_page' ] );

        // Setup page: visible in the sidebar only until a licence is connected.
        // Once set, register it with a null parent — still reachable by URL (so the
        // first-run redirect target survives and re-config is possible) but hidden
        // from the menu, keeping the nav clean.
        $setup_parent = Semantic_Settings::license_key() ? null : 'semantic';
        self::$page_hooks[] = add_submenu_page( $setup_parent, 'First-time Setup', 'Setup', 'manage_options', 'semantic-setup', [ __CLASS__, 'setup_page' ] );
    }

    public static function admin_page() {
        echo '<div id="semantic-admin-root"></div>';
    }

    public static function setup_page() {
        echo '<div id="semantic-admin-root" data-view="setup"></div>';
    }

    /** On first run (no licence saved), send the main plugin page to Setup. */
    public static function maybe_redirect_to_setup() {
        if ( ! is_admin() || wp_doing_ajax() ) return;
        if ( ! current_user_can( 'manage_options' ) ) return;
        // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- Read-only admin page-load redirect (no state change); already manage_options-gated above.
        $page = isset( $_GET['page'] ) ? sanitize_key( wp_unslash( $_GET['page'] ) ) : '';
        if ( $page !== 'semantic' ) return;       // only the main page
        if ( Semantic_Settings::license_key() ) return;             // already set up

        wp_safe_redirect( admin_url( 'admin.php?page=semantic-setup' ) );
        exit;
    }

    /**
     * Cache-bust admin assets on every file change (mtime), so updates that ship
     * within the same plugin version still reach the browser instead of serving a
     * stale cached copy. Falls back to the plugin version if the file is missing.
     */
    private static function asset_ver( $rel ) {
        $mt = file_exists( SEMANTIC_DIR . $rel ) ? filemtime( SEMANTIC_DIR . $rel ) : 0;
        return $mt ? (string) $mt : SEMANTIC_VERSION;
    }

    public static function enqueue( $hook ) {
        if ( ! in_array( $hook, self::$page_hooks, true ) && $hook !== 'toplevel_page_semantic' ) return;
        $is_setup = ( strpos( (string) $hook, 'semantic-setup' ) !== false );

        wp_enqueue_script(
            'semantic-admin',
            SEMANTIC_URL . 'admin/js/app.js',
            [ 'wp-element', 'wp-api-fetch' ],
            self::asset_ver( 'admin/js/app.js' ),
            true
        );

        wp_enqueue_style(
            'semantic-admin',
            SEMANTIC_URL . 'admin/css/admin.css',
            [],
            self::asset_ver( 'admin/css/admin.css' )
        );

        wp_localize_script( 'semantic-admin', 'semanticAdminData', [
            'nonce'        => wp_create_nonce( 'wp_rest' ),
            'apiBase'      => rest_url( self::NS ),
            'siteUrl'      => home_url(),
            'version'      => SEMANTIC_VERSION,
            'view'         => $is_setup ? 'setup' : 'app',
            'dashboardUrl' => admin_url( 'admin.php?page=semantic' ),
            'setupUrl'     => admin_url( 'admin.php?page=semantic-setup' ),
            'pricingUrl'   => 'https://ai-datalayer.com/pricing',
        ] );
    }

    // -------------------------------------------------------------------------
    // REST routes
    // -------------------------------------------------------------------------

    public static function register_routes() {
        // Every admin route declares an explicit permission_callback at its own
        // registration site. require_admin() returns current_user_can( 'manage_options' ).

        // Dashboard overview
        register_rest_route( self::NS, '/dashboard',      [ 'methods' => 'GET',  'callback' => [ __CLASS__, 'dashboard' ],      'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/quota',          [ 'methods' => 'GET',  'callback' => [ __CLASS__, 'quota' ],          'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/activate-trial', [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'activate_trial' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );

        // Billing (Stripe) — proxy to Supabase edge functions, return a redirect URL
        register_rest_route( self::NS, '/billing/checkout', [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'billing_checkout' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/billing/portal',   [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'billing_portal' ],   'permission_callback' => [ __CLASS__, 'require_admin' ] ] );

        // Content list
        register_rest_route( self::NS, '/content', [ 'methods' => 'GET', 'callback' => [ __CLASS__, 'content_list' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/queue-progress', [ 'methods' => 'GET', 'callback' => [ __CLASS__, 'queue_progress' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );

        // Per-post analysis
        register_rest_route( self::NS, '/content/(?P<id>\d+)/analyze',  [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'trigger_analysis' ],   'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/content/(?P<id>\d+)/analysis', [ 'methods' => 'GET',  'callback' => [ __CLASS__, 'get_analysis' ],       'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/content/(?P<id>\d+)/approve',  [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'approve_suggestions' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/content/(?P<id>\d+)/apply',    [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'apply_suggestions' ],   'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/content/(?P<id>\d+)/status',   [ 'methods' => 'GET',  'callback' => [ __CLASS__, 'analysis_status' ],     'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/content/(?P<id>\d+)/exclude',  [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'set_exclude' ],         'permission_callback' => [ __CLASS__, 'require_admin' ] ] );

        // Approve / reject individual items
        register_rest_route( self::NS, '/entity/(?P<id>\d+)/approve', [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'approve_entity' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/entity/(?P<id>\d+)/reject',  [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'reject_entity' ],  'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/schema/(?P<id>\d+)/approve', [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'approve_schema' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/schema/(?P<id>\d+)/reject',  [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'reject_schema' ],  'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/link/(?P<id>\d+)/approve',   [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'approve_link' ],   'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/link/(?P<id>\d+)/reject',    [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'reject_link' ],    'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/faq/(?P<id>\d+)/approve',    [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'approve_faq' ],    'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/faq/(?P<id>\d+)/reject',     [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'reject_faq' ],     'permission_callback' => [ __CLASS__, 'require_admin' ] ] );

        // Inline edit individual items
        register_rest_route( self::NS, '/entity/(?P<id>\d+)', [ 'methods' => 'PATCH', 'callback' => [ __CLASS__, 'edit_entity' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/schema/(?P<id>\d+)', [ 'methods' => 'PATCH', 'callback' => [ __CLASS__, 'edit_schema' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/link/(?P<id>\d+)',   [ 'methods' => 'PATCH', 'callback' => [ __CLASS__, 'edit_link' ],   'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/faq/(?P<id>\d+)',    [ 'methods' => 'PATCH', 'callback' => [ __CLASS__, 'edit_faq' ],    'permission_callback' => [ __CLASS__, 'require_admin' ] ] );

        // Manual FAQ addition
        register_rest_route( self::NS, '/content/(?P<id>\d+)/faq', [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'add_faq_manually' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );

        // Bulk analyse all
        register_rest_route( self::NS, '/analyze-all', [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'analyze_all' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );

        // Entity registry
        register_rest_route( self::NS, '/registry',             [ 'methods' => 'GET', 'callback' => [ __CLASS__, 'registry' ],        'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/registry/(?P<id>\d+)', [ 'methods' => 'GET', 'callback' => [ __CLASS__, 'registry_detail' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );

        // Topic cluster graph
        register_rest_route( self::NS, '/clusters', [ 'methods' => 'GET', 'callback' => [ __CLASS__, 'clusters' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );

        // Cohesion
        register_rest_route( self::NS, '/cohesion',             [ 'methods' => 'GET',  'callback' => [ __CLASS__, 'cohesion' ],             'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/cohesion/recalculate', [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'recalculate_cohesion' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );

        // Entity Profile (org-level identity readiness) — admin-only UI data.
        register_rest_route( self::NS, '/entity-profile', [ 'methods' => 'GET', 'callback' => [ __CLASS__, 'entity_profile' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );
        register_rest_route( self::NS, '/entity-profile/link', [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'entity_profile_link' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ] );

        // Settings — permission_callback MUST be declared on each method entry.
        // register_rest_route() does NOT propagate a top-level permission_callback to
        // the individual endpoints of a multi-method route, so a shared/top-level one
        // would leave both methods unauthenticated.
        register_rest_route( self::NS, '/settings', [
            [ 'methods' => 'GET',  'callback' => [ __CLASS__, 'get_settings' ],  'permission_callback' => [ __CLASS__, 'require_admin' ] ],
            [ 'methods' => 'POST', 'callback' => [ __CLASS__, 'save_settings' ], 'permission_callback' => [ __CLASS__, 'require_admin' ] ],
        ] );
    }

    public static function require_admin() {
        return current_user_can( 'manage_options' );
    }

    // -------------------------------------------------------------------------
    // Callbacks
    // -------------------------------------------------------------------------

    public static function dashboard( $req ) {
        global $wpdb;

        $post_types = Semantic_Settings::post_types();
        $exclude    = Semantic_Settings::EXCLUDE_META;
        // In-scope pages = published, tracked types, not excluded from the layer.
        if ( empty( $post_types ) ) {
            $total = 0;
        } else {
            $ph    = implode( ',', array_fill( 0, count( $post_types ), '%s' ) );
            $total = (int) $wpdb->get_var( $wpdb->prepare(
                "SELECT COUNT(*) FROM {$wpdb->posts} WHERE post_status='publish' AND post_type IN ($ph)
                   AND ID NOT IN ( SELECT post_id FROM {$wpdb->postmeta} WHERE meta_key=%s AND meta_value='1' )",
                array_merge( $post_types, [ $exclude ] )
            ) );
        }

        // Exclude opted-out pages so analysed/pending stay consistent with $total
        // (which already excludes them) — otherwise excluding an analysed page would
        // skew the coverage / backlog maths.
        $analysed = (int) $wpdb->get_var( $wpdb->prepare(
            "SELECT COUNT(DISTINCT post_id) FROM {$wpdb->prefix}semantic_analyses
             WHERE status='completed'
               AND post_id NOT IN ( SELECT post_id FROM {$wpdb->postmeta} WHERE meta_key=%s AND meta_value='1' )",
            $exclude
        ) );
        // Distinct posts currently mid-analysis (quota already consumed for these).
        $pending = (int) $wpdb->get_var( $wpdb->prepare(
            "SELECT COUNT(DISTINCT post_id) FROM {$wpdb->prefix}semantic_analyses
             WHERE status IN ('pending','processing','validating')
               AND post_id NOT IN ( SELECT post_id FROM {$wpdb->postmeta} WHERE meta_key=%s AND meta_value='1' )",
            $exclude
        ) );
        $failed     = (int) $wpdb->get_var( "SELECT COUNT(*) FROM {$wpdb->prefix}semantic_analyses WHERE status='failed'" );
        $entities   = (int) $wpdb->get_var( "SELECT COUNT(*) FROM {$wpdb->prefix}semantic_entity_registry" );
        // Only count pending entities from the LATEST completed analysis per post — ignore superseded duplicates
        $pending_review = (int) $wpdb->get_var(
            "SELECT COUNT(*) FROM {$wpdb->prefix}semantic_suggested_entities
             WHERE approval_status = 'pending'
               AND analysis_id IN (
                   SELECT MAX(id) FROM {$wpdb->prefix}semantic_analyses
                   WHERE status = 'completed' GROUP BY post_id
               )"
        );

        $cohesion = Semantic_Cohesion::latest();

        $license_key = Semantic_Settings::license_key();

return rest_ensure_response( [
            'content'         => [ 'total' => $total, 'analysed' => $analysed, 'pending' => $pending, 'failed' => $failed ],
            'entities'        => [ 'registry_count' => $entities, 'pending_review' => $pending_review ],
            'cohesion'        => $cohesion,
            'license_key_set' => ! empty( $license_key ),
        ] );
    }

    // The UI hits /quota on every Settings/Dashboard load. Cache the validated
    // licence snapshot for 10 min to keep Edge Function calls down. Pass ?fresh=1
    // to bypass (used right after a billing action). Busted by flush_quota_cache()
    // on licence-key change, trial activation, and analysis completion.
    const QUOTA_CACHE = 'semantic_quota_cache';

    public static function quota( $req ) {
        $license_key = Semantic_Settings::license_key();
        if ( empty( $license_key ) ) {
            return rest_ensure_response( [ 'valid' => false, 'reason' => 'no_key' ] );
        }

        $fresh = $req && ! empty( $req->get_param( 'fresh' ) );
        if ( ! $fresh ) {
            $cached = get_transient( self::QUOTA_CACHE );
            if ( is_array( $cached ) ) return rest_ensure_response( $cached );
        }

        $domain = wp_parse_url( home_url(), PHP_URL_HOST );
        $res    = wp_remote_post( SEMANTIC_SUPABASE_URL . '/functions/v1/validate-license', [
            'timeout' => 6,
            'headers' => [ 'Content-Type' => 'application/json' ],
            'body'    => wp_json_encode( [ 'license_key' => $license_key, 'domain' => $domain ] ),
        ] );
        if ( is_wp_error( $res ) ) return rest_ensure_response( [ 'valid' => false, 'reason' => 'unreachable' ] );
        $code  = wp_remote_retrieve_response_code( $res );
        $body  = json_decode( wp_remote_retrieve_body( $res ), true );
        if ( $code !== 200 || empty( $body ) ) return rest_ensure_response( [ 'valid' => false, 'reason' => 'error' ] );

        // Cache the validated snapshot + the billing status (for the admin-bar pill).
        set_transient( self::QUOTA_CACHE, $body, 10 * MINUTE_IN_SECONDS );
        set_transient( 'semantic_billing_status', (string) ( $body['subscription_status'] ?? '' ), 6 * HOUR_IN_SECONDS );
        return rest_ensure_response( $body );
    }

    /** Invalidate the cached licence/quota snapshot (key change, trial, analysis). */
    public static function flush_quota_cache() {
        delete_transient( self::QUOTA_CACHE );
        delete_transient( 'semantic_billing_status' );
    }

    /**
     * Best-effort count of analyses the connected licence can still run, including
     * any top-up credits. Returns null for unlimited plans or when the figure
     * can't be determined (licence unreachable) — callers then apply no cap and
     * let the server-side reservation be the hard gate. Used to pre-cap "Analyse
     * All" so we don't queue dozens of pages that would only fail on quota.
     */
    private static function remaining_quota() {
        $resp = self::quota( null );                       // reuses the 10-min cache
        $snap = ( $resp instanceof WP_REST_Response ) ? $resp->get_data() : null;
        if ( ! is_array( $snap ) || empty( $snap['valid'] ) ) return null;
        $pr = $snap['posts_remaining'] ?? null;
        if ( $pr === null ) return null;                   // unlimited plan
        return max( 0, (int) $pr + (int) ( $snap['topup_balance'] ?? 0 ) );
    }

    /**
     * Start a Stripe Checkout session (subscription tier or one-time credit pack).
     * Proxies to the create-checkout-session edge function with the saved licence
     * key + this site's admin URL as the return target. Returns { url } to redirect to.
     */
    public static function billing_checkout( $req ) {
        $license_key = Semantic_Settings::license_key();
        if ( empty( $license_key ) ) return new WP_Error( 'no_key', 'Connect a licence first.', [ 'status' => 400 ] );

        $body = $req->get_json_params() ?: [];
        $item = isset( $body['item'] ) ? sanitize_text_field( $body['item'] ) : '';
        if ( ! in_array( $item, [ 'starter', 'growth', 'pro', 'pack_100', 'pack_500', 'pack_2000' ], true ) ) {
            return new WP_Error( 'bad_item', 'Unknown billing item.', [ 'status' => 400 ] );
        }
        // Credit packs may be bought in multiples (backlog planner); subs are qty 1.
        $qty = isset( $body['quantity'] ) ? max( 1, min( 50, (int) $body['quantity'] ) ) : 1;

        $res = wp_remote_post( SEMANTIC_SUPABASE_URL . '/functions/v1/create-checkout-session', [
            'timeout' => 15,
            'headers' => [ 'Content-Type' => 'application/json' ],
            'body'    => wp_json_encode( [
                'license_key' => $license_key,
                'item'        => $item,
                'quantity'    => $qty,
                'return_url'  => admin_url( 'admin.php?page=semantic' ),
            ] ),
        ] );
        return self::proxy_billing_url( $res );
    }

    /**
     * Open the Stripe Billing Portal (manage / cancel subscription, update card).
     * Proxies to create-portal-session. Returns { url } to redirect to.
     */
    public static function billing_portal( $req ) {
        $license_key = Semantic_Settings::license_key();
        if ( empty( $license_key ) ) return new WP_Error( 'no_key', 'Connect a licence first.', [ 'status' => 400 ] );

        $res = wp_remote_post( SEMANTIC_SUPABASE_URL . '/functions/v1/create-portal-session', [
            'timeout' => 15,
            'headers' => [ 'Content-Type' => 'application/json' ],
            'body'    => wp_json_encode( [
                'license_key' => $license_key,
                'return_url'  => admin_url( 'admin.php?page=semantic' ),
            ] ),
        ] );
        return self::proxy_billing_url( $res );
    }

    /** Normalise an edge-function billing response to { url } or a WP_Error. */
    private static function proxy_billing_url( $res ) {
        if ( is_wp_error( $res ) ) return new WP_Error( 'unreachable', 'Could not reach the billing service. Please try again.', [ 'status' => 502 ] );
        $code = wp_remote_retrieve_response_code( $res );
        $body = json_decode( wp_remote_retrieve_body( $res ), true );
        if ( $code >= 400 || empty( $body['url'] ) ) {
            return new WP_Error(
                $body['error'] ?? 'billing_error',
                $body['message'] ?? 'Billing request failed.',
                [ 'status' => $code ?: 500 ]
            );
        }
        return rest_ensure_response( [ 'url' => $body['url'] ] );
    }

    /**
     * One-click free-trial activation. Asks Supabase to mint a trial licence for
     * this domain (one per domain), then saves the returned key locally so the
     * user is immediately set up. Email defaults to the WP admin email.
     */
    public static function activate_trial( $req ) {
        // Already configured? Don't silently overwrite an existing key.
        if ( Semantic_Settings::license_key() ) {
            return new WP_Error( 'already_configured', 'A licence key is already saved. Remove it in Settings before activating a trial.', [ 'status' => 409 ] );
        }

        $domain = wp_parse_url( home_url(), PHP_URL_HOST );
        $email  = get_option( 'admin_email' );

        $res = wp_remote_post( SEMANTIC_SUPABASE_URL . '/functions/v1/activate-trial', [
            'timeout' => 15,
            'headers' => [ 'Content-Type' => 'application/json' ],
            'body'    => wp_json_encode( [ 'domain' => $domain, 'email' => $email ] ),
        ] );

        if ( is_wp_error( $res ) ) {
            return new WP_Error( 'unreachable', 'Could not reach the activation service. Please try again.', [ 'status' => 502 ] );
        }

        $code = wp_remote_retrieve_response_code( $res );
        $body = json_decode( wp_remote_retrieve_body( $res ), true );

        if ( $code !== 200 || empty( $body['license_key'] ) ) {
            $msg = $body['message'] ?? 'Trial activation failed. Please try again or enter a licence key manually.';
            return new WP_Error( $body['error'] ?? 'activation_failed', $msg, [ 'status' => $code ?: 400 ] );
        }

        // Persist the key and refresh the admin-bar count + licence cache.
        Semantic_Settings::set( [ 'license_key' => $body['license_key'] ] );
        self::flush_unanalysed_cache();
        self::flush_quota_cache();

        return rest_ensure_response( [
            'success'           => true,
            'tier'              => $body['tier'] ?? 'trial',
            'trial_posts_limit' => $body['trial_posts_limit'] ?? null,
        ] );
    }

    /** Mark a post excluded from (or included back into) the AI Data Layer. */
    public static function set_exclude( $req ) {
        $post_id = (int) $req['id'];
        if ( ! get_post( $post_id ) ) return new WP_Error( 'not_found', 'Post not found', [ 'status' => 404 ] );
        $body     = $req->get_json_params() ?: [];
        $excluded = ! empty( $body['excluded'] );
        Semantic_Settings::set_excluded( $post_id, $excluded );
        self::flush_unanalysed_cache();
        return rest_ensure_response( [ 'success' => true, 'id' => $post_id, 'excluded' => $excluded ] );
    }

    public static function content_list( $req ) {
        $page     = max( 1, (int) ( $req->get_param( 'page' ) ?: 1 ) );
        $per_page = 20;
        $search   = sanitize_text_field( $req->get_param( 'search' ) ?: '' );

        $args = [
            'post_type'      => Semantic_Settings::post_types(),
            'post_status'    => 'publish',
            'posts_per_page' => $per_page,
            'paged'          => $page,
            'orderby'        => 'modified',
            'order'          => 'DESC',
        ];
        if ( $search ) $args['s'] = $search;

        $query = new WP_Query( $args );
        $posts = [];

        global $wpdb;
        foreach ( $query->posts as $post ) {
            // The latest attempt (any status) AND the latest COMPLETED analysis. We
            // report the completed one as the row's status so a later failed or
            // in-progress re-analysis never HIDES already-applied data — the prior
            // analysis is untouched until a new one actually completes (supersede
            // runs only on success), so Review stays available the whole time.
            $latest = $wpdb->get_row( $wpdb->prepare(
                "SELECT id, status, finished_at, page_type, primary_topic_entity, error_message FROM {$wpdb->prefix}semantic_analyses
                 WHERE post_id = %d ORDER BY created_at DESC LIMIT 1",
                $post->ID
            ), ARRAY_A );
            $completed = $wpdb->get_row( $wpdb->prepare(
                "SELECT id, status, finished_at, page_type, primary_topic_entity, error_message FROM {$wpdb->prefix}semantic_analyses
                 WHERE post_id = %d AND status = 'completed' ORDER BY finished_at DESC LIMIT 1",
                $post->ID
            ), ARRAY_A );

            $primary = $completed ?: $latest; // prefer the reviewable, completed analysis

            // A newer attempt that hasn't completed (failed / in-progress) is shown
            // as a non-destructive flag, only when a completed analysis also exists.
            $retry_status = ( $completed && $latest && (int) $latest['id'] !== (int) $completed['id'] && $latest['status'] !== 'completed' )
                ? $latest['status'] : null;
            $retry_error  = ( $retry_status === 'failed' ) ? ( $latest['error_message'] ?? null ) : null;

            $pending_count = $primary ? (int) $wpdb->get_var( $wpdb->prepare(
                "SELECT
                   (SELECT COUNT(*) FROM {$wpdb->prefix}semantic_suggested_entities WHERE analysis_id=%d AND approval_status='pending') +
                   (SELECT COUNT(*) FROM {$wpdb->prefix}semantic_suggested_schema   WHERE analysis_id=%d AND approval_status='pending') +
                   (SELECT COUNT(*) FROM {$wpdb->prefix}semantic_suggested_links    WHERE analysis_id=%d AND approval_status='pending') +
                   (SELECT COUNT(*) FROM {$wpdb->prefix}semantic_suggested_faqs     WHERE analysis_id=%d AND approval_status='pending')",
                $primary['id'], $primary['id'], $primary['id'], $primary['id']
            ) ) : 0;

            $posts[] = [
                'id'                  => $post->ID,
                'title'               => $post->post_title,
                'url'                 => get_permalink( $post ),
                'post_type'           => $post->post_type,
                'modified'            => $post->post_modified,
                'analysis_status'     => $primary['status'] ?? 'not_started',
                'analysis_id'         => $primary['id'] ?? null,
                'finished_at'         => $primary['finished_at'] ?? null,
                'page_type'           => $primary['page_type'] ?? null,
                'primary_topic'       => $primary['primary_topic_entity'] ?? null,
                'error_message'       => $primary['error_message'] ?? null,
                'retry_status'        => $retry_status,
                'retry_error'         => $retry_error,
                'excluded'            => Semantic_Settings::is_excluded( $post->ID ),
                'pending_review_count'=> $pending_count,
            ];
        }

        return rest_ensure_response( [
            'posts'       => $posts,
            'total'       => $query->found_posts,
            'total_pages' => $query->max_num_pages,
            'page'        => $page,
        ] );
    }

    public static function trigger_analysis( $req ) {
        $post_id = (int) $req['id'];
        $post    = get_post( $post_id );
        if ( ! $post ) return new WP_Error( 'not_found', 'Post not found', [ 'status' => 404 ] );

        $analysis_id = Semantic_Queue::enqueue( $post_id );
        if ( is_wp_error( $analysis_id ) ) {
            return new WP_Error( $analysis_id->get_error_code(), $analysis_id->get_error_message(), [ 'status' => 400 ] );
        }
        return rest_ensure_response( [ 'analysis_id' => $analysis_id, 'status' => 'queued' ] );
    }

    public static function analysis_status( $req ) {
        global $wpdb;
        $post_id  = (int) $req['id'];
        $analysis = $wpdb->get_row( $wpdb->prepare(
            "SELECT id, status, error_message, started_at, finished_at, external_job_id FROM {$wpdb->prefix}semantic_analyses
             WHERE post_id = %d ORDER BY created_at DESC LIMIT 1",
            $post_id
        ), ARRAY_A );

        // While processing, do a live poll against the edge function so the UI gets fast feedback
        if ( $analysis && in_array( $analysis['status'], [ 'processing', 'validating' ], true ) && ! empty( $analysis['external_job_id'] ) ) {
            Semantic_Queue::check_and_store( (int) $analysis['id'], $analysis['external_job_id'] );
            // Re-fetch after potential update
            $analysis = $wpdb->get_row( $wpdb->prepare(
                "SELECT id, status, error_message, started_at, finished_at FROM {$wpdb->prefix}semantic_analyses WHERE id = %d",
                $analysis['id']
            ), ARRAY_A );
        }

        return rest_ensure_response( $analysis ?: [ 'status' => 'not_started' ] );
    }

    public static function get_analysis( $req ) {
        global $wpdb;
        $post_id = (int) $req['id'];

        $analysis = $wpdb->get_row( $wpdb->prepare(
            "SELECT * FROM {$wpdb->prefix}semantic_analyses WHERE post_id = %d AND status = 'completed' ORDER BY finished_at DESC LIMIT 1",
            $post_id
        ), ARRAY_A );

        if ( ! $analysis ) return new WP_Error( 'not_found', 'No completed analysis found', [ 'status' => 404 ] );

        $aid = $analysis['id'];

        // Exclude heavy fields not needed by the review UI to keep payload small
        $entities = $wpdb->get_results( $wpdb->prepare(
            "SELECT id, analysis_id, post_id, name, type, definition, relevance_score,
                    model_confidence, schema_reasoning, exclusion_reasoning,
                    wikidata_qid, wikidata_verified, aliases, same_as, roles,
                    canonical_entity_id, entity_registry_id, approval_status,
                    mentions, related_entities
             FROM {$wpdb->prefix}semantic_suggested_entities
             WHERE analysis_id = %d
             ORDER BY relevance_score DESC
             LIMIT 200",
            $aid
        ), ARRAY_A );

        $schema = $wpdb->get_results( $wpdb->prepare(
            "SELECT * FROM {$wpdb->prefix}semantic_suggested_schema WHERE analysis_id = %d",
            $aid
        ), ARRAY_A );

        $links = $wpdb->get_results( $wpdb->prepare(
            "SELECT * FROM {$wpdb->prefix}semantic_suggested_links WHERE analysis_id = %d ORDER BY confidence_score DESC",
            $aid
        ), ARRAY_A );

        $faqs = $wpdb->get_results( $wpdb->prepare(
            "SELECT * FROM {$wpdb->prefix}semantic_suggested_faqs WHERE analysis_id = %d ORDER BY ai_confidence DESC, id ASC",
            $aid
        ), ARRAY_A );

        // Decode JSON fields — use regular loop to avoid PHP reference bugs
        $entities = array_map( function( $e ) {
            $e['mentions']         = array_slice( json_decode( $e['mentions']         ?? '[]', true ) ?: [], 0, 1 ); // 1 mention max for UI
            $e['related_entities'] = json_decode( $e['related_entities'] ?? '[]', true ) ?: [];
            $e['roles']            = json_decode( $e['roles']            ?? '[]', true ) ?: [];
            $e['same_as']          = json_decode( $e['same_as']          ?? '[]', true ) ?: [];
            $e['aliases']          = json_decode( $e['aliases']          ?? '[]', true ) ?: [];
            return $e;
        }, $entities );

        $schema = array_map( function( $s ) {
            $s['schema_properties'] = json_decode( $s['schema_properties'] ?? '{}', true ) ?: [];
            return $s;
        }, $schema );

        $faqs = array_map( function( $f ) {
            $f['ai_optimization'] = json_decode( $f['ai_optimization'] ?? '{}', true ) ?: [];
            $f['entity_mentions'] = json_decode( $f['entity_mentions'] ?? '[]', true ) ?: [];
            return $f;
        }, $faqs );

        // Decode analysis-level JSON fields. The Review UI now surfaces the
        // previously-captured-but-hidden data as read-only "Insights": entity
        // relationships, the section outline, and the multi-audience summaries —
        // alongside the existing content_analysis / secondary_intents.
        foreach ( [ 'content_analysis', 'secondary_intents', 'summaries',
                    'content_sections', 'entity_relationships' ] as $col ) {
            $analysis[ $col ] = json_decode( $analysis[ $col ] ?? 'null', true );
        }
        // Strip only the raw cleaned content — large and never shown in the UI.
        // (llm_context_block stays: it's the human-readable retrieval block.)
        unset( $analysis['cleaned_content'] );

        return rest_ensure_response( [
            'analysis' => $analysis,
            'entities' => array_values( $entities ),
            'schema'   => array_values( $schema ),
            'links'    => array_values( $links ),
            // Page-to-page interconnection from real shared-entity overlap —
            // replaces the retired AI internal-link suggestions.
            'related'  => Semantic_Cohesion::related_pages( $post_id ),
            'faqs'     => array_values( $faqs ),
        ] );
    }

    public static function approve_suggestions( $req ) {
        global $wpdb;
        $post_id = (int) $req['id'];
        $body    = $req->get_json_params() ?: [];

        $analysis = $wpdb->get_row( $wpdb->prepare(
            "SELECT id FROM {$wpdb->prefix}semantic_analyses WHERE post_id = %d AND status='completed' ORDER BY finished_at DESC LIMIT 1",
            $post_id
        ), ARRAY_A );

        if ( ! $analysis ) return new WP_Error( 'not_found', 'No analysis found', [ 'status' => 404 ] );
        $aid = $analysis['id'];

        // Approve specific IDs or all pending
        $entity_ids = $body['entity_ids']  ?? null;
        $schema_ids = $body['schema_ids']  ?? null;
        $link_ids   = $body['link_ids']    ?? null;
        $faq_ids    = $body['faq_ids']     ?? null;
        $approve_all= ! empty( $body['approve_all'] );

        if ( $approve_all || $entity_ids === 'all' ) {
            $wpdb->update( $wpdb->prefix . 'semantic_suggested_entities', [ 'approval_status' => 'approved' ], [ 'analysis_id' => $aid, 'approval_status' => 'pending' ] );
            // Update registry for all newly approved entities
            $bulk_ids = $wpdb->get_col( $wpdb->prepare(
                "SELECT id FROM {$wpdb->prefix}semantic_suggested_entities WHERE analysis_id = %d AND approval_status = 'approved'", $aid
            ) );
            foreach ( $bulk_ids as $eid ) {
                Semantic_Entity_Registry::on_entity_approved( (int) $eid );
            }
        } elseif ( is_array( $entity_ids ) ) {
            foreach ( $entity_ids as $eid ) {
                $wpdb->update( $wpdb->prefix . 'semantic_suggested_entities', [ 'approval_status' => 'approved' ], [ 'id' => (int) $eid ] );
                Semantic_Entity_Registry::on_entity_approved( (int) $eid );
            }
        }

        if ( $approve_all || $schema_ids === 'all' ) {
            $wpdb->update( $wpdb->prefix . 'semantic_suggested_schema', [ 'approval_status' => 'approved' ], [ 'analysis_id' => $aid, 'approval_status' => 'pending' ] );
        } elseif ( is_array( $schema_ids ) ) {
            foreach ( $schema_ids as $sid ) {
                $wpdb->update( $wpdb->prefix . 'semantic_suggested_schema', [ 'approval_status' => 'approved' ], [ 'id' => (int) $sid ] );
            }
        }

        if ( $approve_all || $link_ids === 'all' ) {
            $wpdb->update( $wpdb->prefix . 'semantic_suggested_links', [ 'approval_status' => 'approved' ], [ 'analysis_id' => $aid, 'approval_status' => 'pending' ] );
        } elseif ( is_array( $link_ids ) ) {
            foreach ( $link_ids as $lid ) {
                $wpdb->update( $wpdb->prefix . 'semantic_suggested_links', [ 'approval_status' => 'approved' ], [ 'id' => (int) $lid ] );
            }
        }

        if ( $approve_all || $faq_ids === 'all' ) {
            $wpdb->update( $wpdb->prefix . 'semantic_suggested_faqs', [ 'approval_status' => 'approved' ], [ 'analysis_id' => $aid, 'approval_status' => 'pending' ] );
        } elseif ( is_array( $faq_ids ) ) {
            foreach ( $faq_ids as $fid ) {
                $wpdb->update( $wpdb->prefix . 'semantic_suggested_faqs', [ 'approval_status' => 'approved' ], [ 'id' => (int) $fid ] );
            }
        }

        return rest_ensure_response( [ 'success' => true ] );
    }

    public static function apply_suggestions( $req ) {
        global $wpdb;
        $post_id  = (int) $req['id'];
        $analysis = $wpdb->get_row( $wpdb->prepare(
            "SELECT id FROM {$wpdb->prefix}semantic_analyses WHERE post_id = %d AND status='completed' ORDER BY finished_at DESC LIMIT 1",
            $post_id
        ), ARRAY_A );

        if ( ! $analysis ) return new WP_Error( 'not_found', 'No analysis found', [ 'status' => 404 ] );
        $aid = $analysis['id'];

        // Write approved data to post meta so public endpoints serve them
        $entities = $wpdb->get_results( $wpdb->prepare(
            "SELECT * FROM {$wpdb->prefix}semantic_suggested_entities WHERE analysis_id=%d AND approval_status='approved'", $aid ), ARRAY_A );
        $schema = $wpdb->get_results( $wpdb->prepare(
            "SELECT * FROM {$wpdb->prefix}semantic_suggested_schema WHERE analysis_id=%d AND approval_status='approved'", $aid ), ARRAY_A );
        $links = $wpdb->get_results( $wpdb->prepare(
            "SELECT * FROM {$wpdb->prefix}semantic_suggested_links WHERE analysis_id=%d AND approval_status='approved'", $aid ), ARRAY_A );
        $faqs = $wpdb->get_results( $wpdb->prepare(
            "SELECT * FROM {$wpdb->prefix}semantic_suggested_faqs WHERE analysis_id=%d AND approval_status='approved'", $aid ), ARRAY_A );

        update_post_meta( $post_id, '_semantic_entities', $entities );
        update_post_meta( $post_id, '_semantic_schema',   $schema );
        update_post_meta( $post_id, '_semantic_links',    $links );
        update_post_meta( $post_id, '_semantic_faqs',     $faqs );
        update_post_meta( $post_id, '_semantic_applied_at', current_time( 'mysql' ) );

        // Recalculate cohesion after applying
        $calc = new Semantic_Cohesion();
        $calc->calculate();

        return rest_ensure_response( [ 'success' => true ] );
    }

    // Individual item approval
    public static function approve_entity( $req ) { return self::set_item_status( 'semantic_suggested_entities', (int) $req['id'], 'approved' ); }
    public static function reject_entity( $req )  { return self::set_item_status( 'semantic_suggested_entities', (int) $req['id'], 'rejected' ); }
    public static function approve_schema( $req ) { return self::set_item_status( 'semantic_suggested_schema',   (int) $req['id'], 'approved' ); }
    public static function reject_schema( $req )  { return self::set_item_status( 'semantic_suggested_schema',   (int) $req['id'], 'rejected' ); }
    public static function approve_link( $req )   { return self::set_item_status( 'semantic_suggested_links',    (int) $req['id'], 'approved' ); }
    public static function reject_link( $req )    { return self::set_item_status( 'semantic_suggested_links',    (int) $req['id'], 'rejected' ); }
    public static function approve_faq( $req )    { return self::set_item_status( 'semantic_suggested_faqs',     (int) $req['id'], 'approved' ); }
    public static function reject_faq( $req )     { return self::set_item_status( 'semantic_suggested_faqs',     (int) $req['id'], 'rejected' ); }

    public static function add_faq_manually( $req ) {
        global $wpdb;
        $post_id = (int) $req['id'];
        $body    = $req->get_json_params() ?: [];

        $question = sanitize_textarea_field( $body['question'] ?? '' );
        $answer   = wp_kses_post( $body['answer'] ?? '' );

        if ( ! $question || ! $answer ) {
            return new WP_Error( 'missing_fields', 'Question and answer are required.', [ 'status' => 400 ] );
        }

        // Get the current analysis to attach the FAQ to
        $analysis = $wpdb->get_row( $wpdb->prepare(
            "SELECT id FROM {$wpdb->prefix}semantic_analyses WHERE post_id = %d AND status = 'completed' ORDER BY finished_at DESC LIMIT 1",
            $post_id
        ), ARRAY_A );

        if ( ! $analysis ) {
            return new WP_Error( 'no_analysis', 'No completed analysis found for this post.', [ 'status' => 404 ] );
        }

        $wpdb->insert( $wpdb->prefix . 'semantic_suggested_faqs', [
            'analysis_id'     => $analysis['id'],
            'post_id'         => $post_id,
            'question'        => $question,
            'answer'          => $answer,
            'ai_confidence'   => 1.0,
            'ai_optimization' => wp_json_encode( [ 'question_intent' => 'definition' ] ),
            'entity_mentions' => '[]',
            'reasoning'       => 'Manually added by editor.',
            'approval_status' => 'approved',
        ] );

        $new_id = $wpdb->insert_id;

        return rest_ensure_response( [
            'success'  => true,
            'id'       => $new_id,
            'question' => $question,
            'answer'   => $answer,
        ] );
    }

    public static function edit_entity( $req ) {
        global $wpdb;
        $id   = (int) $req['id'];
        $body = $req->get_json_params() ?: [];

        // Handle manual Wikidata QID separately — set verified flag + build sameAs links
        if ( array_key_exists( 'wikidata_qid', $body ) ) {
            $qid = strtoupper( trim( (string) $body['wikidata_qid'] ) );
            if ( $qid === '' ) {
                // Cleared — remove QID and verification
                $wpdb->update( $wpdb->prefix . 'semantic_suggested_entities',
                    [ 'wikidata_qid' => null, 'wikidata_verified' => 0, 'same_as' => wp_json_encode( [] ) ],
                    [ 'id' => $id ] );
            } elseif ( preg_match( '/^Q\d+$/', $qid ) ) {
                $same_as = [ "https://www.wikidata.org/wiki/{$qid}" ];
                $wpdb->update( $wpdb->prefix . 'semantic_suggested_entities',
                    [ 'wikidata_qid' => $qid, 'wikidata_verified' => 1, 'same_as' => wp_json_encode( $same_as ) ],
                    [ 'id' => $id ] );
            } else {
                return new WP_Error( 'invalid_qid', 'QID must be in the form Q12345 (or blank).', [ 'status' => 400 ] );
            }
            unset( $body['wikidata_qid'] );
        }

        $allowed = [ 'name', 'type', 'definition', 'schema_reasoning' ];
        return self::patch_item( 'semantic_suggested_entities', $id, $body, $allowed );
    }

    public static function edit_schema( $req ) {
        $allowed = [ 'entity', 'type', 'reasoning', 'detection_method' ];
        $body    = $req->get_json_params() ?: [];
        $id      = (int) $req['id'];

        // schema_properties is JSON — handle separately
        $data = [];
        foreach ( $allowed as $k ) {
            if ( array_key_exists( $k, $body ) ) $data[ $k ] = sanitize_text_field( $body[ $k ] );
        }
        if ( ! empty( $body['schema_properties'] ) && is_array( $body['schema_properties'] ) ) {
            $data['schema_properties'] = wp_json_encode( $body['schema_properties'] );
        }

        if ( empty( $data ) ) return rest_ensure_response( [ 'success' => true ] );
        global $wpdb;
        $wpdb->update( $wpdb->prefix . 'semantic_suggested_schema', $data, [ 'id' => $id ] );
        return rest_ensure_response( [ 'success' => true, 'id' => $id ] );
    }

    public static function edit_link( $req ) {
        $allowed = [ 'anchor_text', 'target_page_title', 'target_url', 'relevance_reasoning', 'intent_classification' ];
        return self::patch_item( 'semantic_suggested_links', (int) $req['id'], $req->get_json_params() ?: [], $allowed );
    }

    public static function edit_faq( $req ) {
        $allowed = [ 'question', 'answer', 'reasoning' ];
        return self::patch_item( 'semantic_suggested_faqs', (int) $req['id'], $req->get_json_params() ?: [], $allowed );
    }

    private static function patch_item( $table, $id, array $body, array $allowed ) {
        global $wpdb;
        $data = [];
        foreach ( $allowed as $k ) {
            if ( array_key_exists( $k, $body ) ) {
                $data[ $k ] = sanitize_textarea_field( $body[ $k ] );
            }
        }
        if ( empty( $data ) ) return rest_ensure_response( [ 'success' => true ] );
        $wpdb->update( $wpdb->prefix . $table, $data, [ 'id' => $id ] );
        return rest_ensure_response( [ 'success' => true, 'id' => $id ] );
    }

    private static function set_item_status( $table, $id, $status ) {
        global $wpdb;
        $wpdb->update( $wpdb->prefix . $table, [ 'approval_status' => $status ], [ 'id' => $id ] );
        if ( $table === 'semantic_suggested_entities' && $status === 'approved' ) {
            Semantic_Entity_Registry::on_entity_approved( $id );
        }
        return rest_ensure_response( [ 'success' => true, 'id' => $id, 'status' => $status ] );
    }

    public static function analyze_all( $req ) {
        $posts = get_posts( [
            'post_type'      => Semantic_Settings::post_types(),
            'post_status'    => 'publish',
            'posts_per_page' => -1,
            'fields'         => 'ids',
        ] );
        // Don't queue pages the user has excluded from the data layer.
        $posts  = array_values( array_filter( $posts, fn( $id ) => ! Semantic_Settings::is_excluded( $id ) ) );

        // Pre-cap to the licence's remaining quota so we don't queue pages that
        // would only fail server-side on quota. null = unlimited/unknown → no cap
        // (the server-side reservation stays the hard gate).
        $skipped   = 0;
        $remaining = self::remaining_quota();
        if ( null !== $remaining && count( $posts ) > $remaining ) {
            $skipped = count( $posts ) - $remaining;
            $posts   = array_slice( $posts, 0, $remaining );
        }

        $ids    = Semantic_Queue::enqueue_all( $posts );
        $queued = count( array_filter( $ids, fn( $id ) => is_int( $id ) ) );

        // Track this bulk run so the Content page can show a progress bar while it drains.
        if ( $queued > 0 ) {
            set_transient( 'semantic_bulk', [ 'total' => $queued, 'started_at' => time() ], DAY_IN_SECONDS );
        }
        return rest_ensure_response( [ 'queued' => $queued, 'skipped' => $skipped ] );
    }

    /**
     * Progress of the current bulk ("Analyse All") run, for the Content-page bar.
     * Returns active=false when no bulk run is in flight. Derived from the live
     * queue counts vs the total recorded when the run started.
     */
    public static function queue_progress( $req ) {
        global $wpdb;

        $bulk = get_transient( 'semantic_bulk' );
        if ( ! is_array( $bulk ) || empty( $bulk['total'] ) ) {
            return rest_ensure_response( [ 'active' => false ] );
        }

        $total      = (int) $bulk['total'];
        $pending    = (int) $wpdb->get_var( "SELECT COUNT(*) FROM {$wpdb->prefix}semantic_analyses WHERE status = 'pending'" );
        $processing = (int) $wpdb->get_var( "SELECT COUNT(*) FROM {$wpdb->prefix}semantic_analyses WHERE status IN ('processing','validating')" );
        $remaining  = $pending + $processing;

        // Drained → clear the tracker and report complete.
        if ( $remaining <= 0 ) {
            delete_transient( 'semantic_bulk' );
            return rest_ensure_response( [ 'active' => false, 'total' => $total, 'done' => $total ] );
        }

        $done    = max( 0, $total - $remaining );
        $elapsed = max( 1, time() - (int) ( $bulk['started_at'] ?? time() ) );
        $rate    = $done / $elapsed; // analyses per second
        $eta     = ( $done >= 3 && $rate > 0 ) ? (int) round( $remaining / $rate ) : null; // null until the rate stabilises

        return rest_ensure_response( [
            'active'      => true,
            'total'       => $total,
            'done'        => $done,
            'pending'     => $pending,
            'processing'  => $processing,
            'eta_seconds' => $eta,
            'started_at'  => (int) ( $bulk['started_at'] ?? 0 ),
        ] );
    }

    /** Org-level identity readiness profile for the Entity Profile tab. */
    public static function entity_profile( $req ) {
        return rest_ensure_response( Semantic_Entity_Profile::build_profile() );
    }

    /**
     * Ghost-card write-back: add a confirmed identity link to the org's sameAs.
     * Writes to the SAME `org_socials` store the Settings social fields use, so the
     * Settings list, the sitewide JSON-LD and the /organization endpoint all update.
     */
    public static function entity_profile_link( $req ) {
        $body = $req->get_json_params() ?: [];
        $key  = isset( $body['key'] ) ? sanitize_key( $body['key'] ) : '';
        $url  = isset( $body['url'] ) ? esc_url_raw( trim( (string) $body['url'] ) ) : '';

        list( $ok, $message ) = Semantic_Entity_Profile::validate_link( $key, $url );
        if ( ! $ok ) {
            return new WP_Error( 'invalid_link', $message, [ 'status' => 400 ] );
        }

        // Append to org_socials, de-duplicating on the normalised URL.
        $socials = array_values( array_filter( (array) Semantic_Settings::org_socials(), 'is_string' ) );
        $norm    = untrailingslashit( strtolower( $url ) );
        $exists  = false;
        foreach ( $socials as $existing ) {
            if ( untrailingslashit( strtolower( (string) $existing ) ) === $norm ) { $exists = true; break; }
        }
        if ( ! $exists ) {
            $socials[] = $url;
            Semantic_Settings::set( [ 'org_socials' => $socials ] );
        }
        return rest_ensure_response( Semantic_Entity_Profile::build_profile() );
    }

    public static function clusters( $req ) {
        return rest_ensure_response( Semantic_Cohesion::cluster_graph() );
    }

    public static function registry_detail( $req ) {
        $detail = Semantic_Entity_Registry::get_detail( (int) $req['id'] );
        if ( ! $detail ) return new WP_Error( 'not_found', 'Entity not found', [ 'status' => 404 ] );
        return rest_ensure_response( $detail );
    }

    public static function registry( $req ) {
        $all = Semantic_Entity_Registry::get_all();
        return rest_ensure_response( array_map( function( $row ) {
            foreach ( [ 'same_as', 'synonyms', 'canonical_roles', 'typical_contexts' ] as $col ) {
                $row[ $col ] = json_decode( $row[ $col ] ?? '[]', true ) ?: [];
            }
            $row['role_frequency'] = json_decode( $row['role_frequency'] ?? '{}', true ) ?: [];
            return $row;
        }, $all ) );
    }

    public static function cohesion( $req ) {
        return rest_ensure_response( Semantic_Cohesion::latest() );
    }

    public static function recalculate_cohesion( $req ) {
        $calc     = new Semantic_Cohesion();
        $snapshot = $calc->calculate();
        return rest_ensure_response( $snapshot );
    }

    public static function get_settings( $req ) {
        $s = array_merge( [
            'endpoints_enabled'     => true,
            'llms_txt_enabled'      => true,
            'schema_output_enabled' => true,
            'markdown_enabled'      => true,
            'mcp_enabled'           => true,
            'faq_display_enabled'   => true,
            'auto_analyse'          => true,
            'schema_compat_mode'    => 'auto',
            'llms_txt_override'     => false,
            'post_types'            => [ 'post', 'page' ],
            'business_type'         => 'other',
            'onboarding_dismissed'  => false,
            'onboarding_features_confirmed' => false,
        ], Semantic_Settings::get() );
        // Surface detected SEO plugins + llms.txt ownership so the UI can show compat notices
        $s['detected_seo_plugins'] = array_values( Semantic_Compat::detect_seo_plugins() );
        $s['llms_txt_conflict']    = Semantic_Compat::llms_txt_owned_elsewhere() ?: '';
        // Pre-fill the logo from the theme (custom logo / site icon) when unset.
        if ( empty( $s['org_logo'] ) ) $s['org_logo'] = Semantic_Settings::default_logo();
        // Mask the license key — only indicate whether it's set
        $s['license_key_is_set'] = ! empty( $s['license_key'] );
        if ( ! empty( $s['license_key'] ) ) {
            $key = $s['license_key'];
            $s['license_key'] = substr( $key, 0, 4 ) . str_repeat( '*', max( 0, strlen( $key ) - 8 ) ) . substr( $key, -4 );
        }
        return rest_ensure_response( $s );
    }

    public static function save_settings( $req ) {
        $body = $req->get_json_params() ?: [];
        $data = [];

        // Per-field sanitisation (WordPress.org requires sanitising all input on
        // the way in, regardless of the manage_options gate).
        if ( array_key_exists( 'license_key', $body ) )     $data['license_key']     = sanitize_text_field( (string) $body['license_key'] );
        if ( array_key_exists( 'org_name', $body ) )        $data['org_name']        = sanitize_text_field( (string) $body['org_name'] );
        if ( array_key_exists( 'org_description', $body ) ) $data['org_description'] = sanitize_text_field( (string) $body['org_description'] );
        if ( array_key_exists( 'org_email', $body ) )       $data['org_email']       = sanitize_email( (string) $body['org_email'] );
        if ( array_key_exists( 'org_url', $body ) )         $data['org_url']         = esc_url_raw( (string) $body['org_url'] );
        if ( array_key_exists( 'org_logo', $body ) )        $data['org_logo']        = esc_url_raw( (string) $body['org_logo'] );
        if ( array_key_exists( 'domain_context', $body ) )  $data['domain_context']  = sanitize_textarea_field( (string) $body['domain_context'] );

        // Social links: array of URLs — scrub values and drop blanks.
        if ( array_key_exists( 'org_socials', $body ) && is_array( $body['org_socials'] ) ) {
            $data['org_socials'] = array_values( array_filter(
                array_map( function ( $u ) { return esc_url_raw( (string) $u ); }, $body['org_socials'] )
            ) );
        }

        // Tracked post types — only allow real, registered public types.
        if ( array_key_exists( 'post_types', $body ) && is_array( $body['post_types'] ) ) {
            $registered = get_post_types( [ 'public' => true ] );
            $data['post_types'] = array_values( array_filter(
                array_map( 'sanitize_key', $body['post_types'] ),
                function ( $t ) use ( $registered ) { return isset( $registered[ $t ] ); }
            ) );
        }

        // Schema compatibility mode — whitelist.
        if ( array_key_exists( 'schema_compat_mode', $body ) ) {
            $mode = sanitize_key( $body['schema_compat_mode'] );
            $data['schema_compat_mode'] = in_array( $mode, [ 'auto', 'full' ], true ) ? $mode : 'auto';
        }

        // Business type — drives Entity Profile eligibility. Whitelist.
        if ( array_key_exists( 'business_type', $body ) ) {
            $bt = sanitize_key( $body['business_type'] );
            $data['business_type'] = in_array( $bt, Semantic_Entity_Profile::TYPES, true ) ? $bt : 'other';
        }

        // Booleans.
        foreach ( [ 'endpoints_enabled', 'llms_txt_enabled', 'schema_output_enabled', 'markdown_enabled',
                    'mcp_enabled', 'faq_display_enabled', 'auto_analyse', 'llms_txt_override',
                    'onboarding_dismissed', 'onboarding_features_confirmed' ] as $bk ) {
            if ( array_key_exists( $bk, $body ) ) $data[ $bk ] = rest_sanitize_boolean( $body[ $bk ] );
        }

        // FAQ display options — shallow-sanitise scalar values (colours, sizes, labels).
        if ( array_key_exists( 'faq_display', $body ) && is_array( $body['faq_display'] ) ) {
            $fd = [];
            foreach ( $body['faq_display'] as $k => $v ) {
                $k = sanitize_key( $k );
                if ( is_bool( $v ) )        $fd[ $k ] = $v;
                elseif ( is_numeric( $v ) ) $fd[ $k ] = $v + 0;
                else                        $fd[ $k ] = sanitize_text_field( (string) $v );
            }
            $data['faq_display'] = $fd;
        }

        if ( ! empty( $data ) ) {
            Semantic_Settings::set( $data );
        }

        // A new/changed licence key invalidates the cached quota snapshot.
        if ( array_key_exists( 'license_key', $data ) ) {
            self::flush_quota_cache();
        }

        // Only flush rewrite rules when a route-affecting setting actually changed.
        if ( array_intersect( [ 'llms_txt_enabled', 'markdown_enabled', 'endpoints_enabled', 'post_types', 'llms_txt_override' ], array_keys( $data ) ) ) {
            flush_rewrite_rules();
        }

        return rest_ensure_response( [ 'success' => true ] );
    }
}