<?php
/**
 * Schema Detector Manager
 *
 * Verantwoordelijk voor de integratie van schema detectie met WordPress.
 * Beheert hooks, AJAX handlers en de koppeling tussen detectie en UI.
 *
 * @package TamRank
 * @subpackage Schema\Detector
 * @since 1.0.0
 */

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

/**
 * Klasse TAMRANK_Schema_Detector_Manager
 *
 * Hoofdklasse voor WordPress integratie van schema detectie
 */
class TAMRANK_Schema_Detector_Manager {

    /**
     * Detector instantie
     *
     * @var TAMRANK_Schema_Detector
     */
    private $detector;

    /**
     * Storage instantie
     *
     * @var TAMRANK_Schema_Storage
     */
    private $storage;

    /**
     * Templates instantie (schema-template store)
     *
     * @var TAMRANK_Schema_Templates|null
     */
    private $templates = null;

    /**
     * Singleton instantie
     *
     * @var TAMRANK_Schema_Detector_Manager|null
     */
    private static $instantie = null;

    /**
     * Post types waarvoor detectie is ingeschakeld
     *
     * @var array
     */
    private $ondersteunde_post_types = array( 'post', 'page', 'product' );

    /**
     * Constructor
     */
    private function __construct() {
        $this->detector = new TAMRANK_Schema_Detector();
        $this->storage  = new TAMRANK_Schema_Storage();

        $this->initialiseer_hooks();
    }

    /**
     * Schema-template store (lazy).
     *
     * Zelfde store als de Schema-tab en de meta-box gebruiken: de templates
     * staan in de optie tamrank_schema_templates en worden via
     * TAMRANK_Schema_Templates gelezen. Schema-templates zijn een FREE-feature
     * (FreemiumManager: 'schema_templates' => tier 'free'), dus deze klasse
     * mag er onvoorwaardelijk op leunen.
     *
     * @return TAMRANK_Schema_Templates
     */
    private function krijg_templates() {
        if ( null === $this->templates ) {
            if ( ! class_exists( 'TAMRANK_Schema_Templates' ) ) {
                require_once dirname( __DIR__ ) . '/class-schema-templates.php';
            }
            $this->templates = new TAMRANK_Schema_Templates();
        }
        return $this->templates;
    }

    /**
     * Schema-type van een opgeslagen template, of '' als de template niet bestaat.
     *
     * @param string $template_id Template ID uit de post meta of de request.
     * @return string
     */
    private function krijg_template_schema_type( $template_id ) {
        if ( '' === (string) $template_id ) {
            return '';
        }

        $template = $this->krijg_templates()->get_template( $template_id );

        return is_array( $template ) && isset( $template['schema_type'] )
            ? (string) $template['schema_type']
            : '';
    }

    /**
     * Verkrijg singleton instantie
     *
     * @return TAMRANK_Schema_Detector_Manager
     */
    public static function krijg_instantie() {
        if ( null === self::$instantie ) {
            self::$instantie = new self();
        }
        return self::$instantie;
    }

    /**
     * Initialiseer WordPress hooks
     */
    private function initialiseer_hooks() {
        // Detectie bij post opslaan
        add_action( 'save_post', array( $this, 'bij_post_opslaan' ), 20, 3 );

        // AJAX handlers
        add_action( 'wp_ajax_tamrank_detecteer_schema', array( $this, 'ajax_detecteer_schema' ) );
        add_action( 'wp_ajax_tamrank_accepteer_schema', array( $this, 'ajax_accepteer_schema' ) );
        add_action( 'wp_ajax_tamrank_sla_handmatig_schema_op', array( $this, 'ajax_sla_handmatig_op' ) );
        add_action( 'wp_ajax_tamrank_reset_schema_keuze', array( $this, 'ajax_reset_keuze' ) );
        add_action( 'wp_ajax_tamrank_sla_schema_bron_op', array( $this, 'ajax_sla_schema_bron_op' ) );
        add_action( 'wp_ajax_tamrank_sla_schema_template_op', array( $this, 'ajax_sla_schema_template_op' ) );

        // Filter voor ondersteunde post types
        add_filter( 'tamrank_schema_detectie_post_types', array( $this, 'filter_post_types' ) );
    }

    /**
     * Filter ondersteunde post types
     *
     * @param array $post_types Post types
     * @return array
     */
    public function filter_post_types( $post_types ) {
        return apply_filters( 'tamrank_schema_ondersteunde_post_types', $this->ondersteunde_post_types );
    }

    /**
     * Controleer of post type wordt ondersteund
     *
     * @param string $post_type Post type
     * @return bool
     */
    public function is_post_type_ondersteund( $post_type ) {
        $ondersteund = apply_filters( 'tamrank_schema_detectie_post_types', $this->ondersteunde_post_types );
        return in_array( $post_type, $ondersteund, true );
    }

    /**
     * Handler voor post opslaan
     *
     * @param int     $post_id Post ID
     * @param WP_Post $post    Post object
     * @param bool    $update  Of dit een update is
     */
    public function bij_post_opslaan( $post_id, $post, $update ) {
        // Controleer autosave
        if ( defined( 'DOING_AUTOSAVE' ) && DOING_AUTOSAVE ) {
            return;
        }

        // Controleer revisies
        if ( wp_is_post_revision( $post_id ) ) {
            return;
        }

        // Controleer post type
        if ( ! $this->is_post_type_ondersteund( $post->post_type ) ) {
            return;
        }

        // Controleer rechten
        if ( ! current_user_can( 'edit_post', $post_id ) ) {
            return;
        }

        // Verifieer de nonce. De automatische detectie leest geen request-data
        // en mag altijd draaien; het verwerken van handmatige metabox-invoer
        // ($_POST) mag uitsluitend na een geldige nonce.
        $nonce_ok = isset( $_POST['tamrank_schema_nonce'] )
            && wp_verify_nonce( sanitize_key( wp_unslash( $_POST['tamrank_schema_nonce'] ) ), 'tamrank_schema_detectie' );

        // Voer detectie uit (leest geen $_POST)
        $this->voer_detectie_uit( $post );

        // Verwerk handmatige keuze alleen na een geverifieerde nonce
        if ( $nonce_ok ) {
            $this->verwerk_metabox_invoer( $post_id );
        }
    }

    /**
     * Voer schema detectie uit voor een post
     *
     * @param WP_Post $post Post object
     * @return TAMRANK_Schema_Detection_Result
     */
    public function voer_detectie_uit( $post ) {
        // Voer detectie uit
        $resultaat = $this->detector->detecteer( $post );


        // Sla resultaat op
        $this->storage->sla_detectie_resultaat_op( $post->ID, $resultaat );

        // Een bewerking kan het FAQ-blok van het theme toevoegen of weghalen, dus
        // laat de achtergrondcheck opnieuw naar de hele pagina kijken. Het vorige
        // antwoord blijft staan tot die klaar is: wissen zou de pagina tussendoor
        // weer een tweede FAQPage laten uitsturen. Queuen kost geen HTTP-verzoek.
        if ( in_array( 'FAQPage', $resultaat->krijg_extra_schemas(), true ) ) {
            tamrank_queue_external_faqpage_scan( $post->ID, true );
        }

        /**
         * Actie na schema detectie
         *
         * @param TAMRANK_Schema_Detection_Result $resultaat Detectie resultaat
         * @param WP_Post                         $post      Post object
         */
        do_action( 'tamrank_schema_gedetecteerd', $resultaat, $post );

        return $resultaat;
    }

    /**
     * Verwerk metabox invoer bij post opslaan
     *
     * @param int $post_id Post ID
     */
    private function verwerk_metabox_invoer( $post_id ) {
        // The nonce is verified by the sole caller bij_post_opslaan() before this
        // private method runs; PHPCS cannot trace that across functions.
        // phpcs:disable WordPress.Security.NonceVerification.Missing
        // Controleer of handmatig schema is ingediend
        if ( isset( $_POST['tamrank_handmatig_schema_type'] ) ) {
            $hoofd_type = sanitize_text_field( wp_unslash( $_POST['tamrank_handmatig_schema_type'] ) );

            $extra_types = array();
            if ( isset( $_POST['tamrank_handmatig_extra_schemas'] ) && is_array( $_POST['tamrank_handmatig_extra_schemas'] ) ) {
                $extra_types = array_map( 'sanitize_text_field', wp_unslash( $_POST['tamrank_handmatig_extra_schemas'] ) );
            }

            if ( ! empty( $hoofd_type ) ) {
                $this->storage->sla_handmatige_keuze_op( $post_id, $hoofd_type, $extra_types );
            }
        }

        // Controleer of handmatige keuze moet worden gewist
        if ( isset( $_POST['tamrank_gebruik_automatisch'] ) && '1' === sanitize_text_field( wp_unslash( $_POST['tamrank_gebruik_automatisch'] ) ) ) {
            $this->storage->wis_handmatige_keuze( $post_id );
        }
        // phpcs:enable WordPress.Security.NonceVerification.Missing
    }

    /**
     * AJAX handler: Detecteer schema
     */
    public function ajax_detecteer_schema() {
        // Controleer nonce
        check_ajax_referer( 'tamrank_schema_detectie', 'nonce' );

        // Haal post ID op
        $post_id = isset( $_POST['post_id'] ) ? absint( $_POST['post_id'] ) : 0;
        if ( ! $post_id ) {
            wp_send_json_error( array( 'message' => tamrank__('error_missing_post_id', 'No post ID provided.'), 'code' => 'missing_parameter' ) );
        }

        // Controleer rechten
        if ( ! current_user_can( 'edit_post', $post_id ) ) {
            wp_send_json_error( array( 'message' => tamrank__('error_permission_denied', 'You do not have permission for this action.'), 'code' => 'permission_denied' ) );
        }

        // Haal post op
        $post = get_post( $post_id );
        if ( ! $post ) {
            wp_send_json_error( array( 'message' => tamrank__('error_invalid_post', 'This post could not be found.'), 'code' => 'not_found' ) );
        }

        // BELANGRIJK: Bij herdetectie altijd terug naar automatisch modus
        // Dit voorkomt dat oude handmatige keuzes de preview blokkeren
        update_post_meta( $post_id, 'tamrank_schema_bron', 'automatisch' );
        $this->storage->wis_handmatige_keuze( $post_id );

        // Wis eventuele schema cache transients
        delete_transient( 'tamrank_schema_' . $post_id );
        tamrank_delete_rendered_source( $post_id );

        // Voer detectie uit
        $resultaat = $this->voer_detectie_uit( $post );

        // Filter de extra-schema's op wat de renderer ECHT bouwt, zodat de chips die
        // de JS na herdetectie toont nooit een type beloven dat zonder content uit de
        // JSON-LD valt (HowTo zonder stappen, FAQ zonder Q&A, VideoObject zonder
        // embed). Zelfde bron-van-waarheid als de PHP-chips en de JSON-LD preview.
        $extra_schemas = $resultaat->krijg_extra_schemas();
        $schema_manager = function_exists( 'tamrank_get_schema_manager' ) ? tamrank_get_schema_manager() : null;
        if ( $schema_manager && method_exists( $schema_manager, 'get_renderer' ) ) {
            $renderer = $schema_manager->get_renderer();
            if ( $renderer && method_exists( $renderer, 'get_renderable_types' ) ) {
                $renderbare_types = $renderer->get_renderable_types( $post, 'automatisch' );
                if ( ! empty( $renderbare_types ) ) {
                    $extra_schemas = array_values( array_intersect( $extra_schemas, $renderbare_types ) );
                }
            }
        }

        // Stuur resultaat terug
        wp_send_json_success( array(
            'resultaat'       => $resultaat->naar_array(),
            'hoofd_schema'    => $resultaat->krijg_hoofd_schema(),
            'extra_schemas'   => $extra_schemas,
            'betrouwbaarheid' => $resultaat->krijg_betrouwbaarheid(),
            'label'           => $resultaat->krijg_betrouwbaarheid_label(),
            'is_geldig'       => $resultaat->is_geldig(),
        ) );
    }

    /**
     * AJAX handler: Accepteer gedetecteerd schema
     */
    public function ajax_accepteer_schema() {
        // Controleer nonce
        check_ajax_referer( 'tamrank_schema_detectie', 'nonce' );

        // Haal post ID op
        $post_id = isset( $_POST['post_id'] ) ? absint( $_POST['post_id'] ) : 0;
        if ( ! $post_id ) {
            wp_send_json_error( array( 'message' => tamrank__('error_missing_post_id', 'No post ID provided.'), 'code' => 'missing_parameter' ) );
        }

        // Controleer rechten
        if ( ! current_user_can( 'edit_post', $post_id ) ) {
            wp_send_json_error( array( 'message' => tamrank__('error_permission_denied', 'You do not have permission for this action.'), 'code' => 'permission_denied' ) );
        }

        // Haal gedetecteerd schema op
        $detectie = $this->storage->krijg_detectie_resultaat( $post_id );
        if ( ! $detectie || ! $detectie->is_geldig() ) {
            wp_send_json_error( array( 'message' => tamrank__('error_no_schema', 'No valid detected schema found.'), 'code' => 'not_found' ) );
        }

        // Sla gedetecteerd schema op als handmatige keuze
        $this->storage->sla_handmatige_keuze_op(
            $post_id,
            $detectie->krijg_hoofd_schema(),
            $detectie->krijg_extra_schemas()
        );

        wp_send_json_success( array(
            'message'      => tamrank__('schema_accepted', 'Schema accepted.'),
            'hoofd_schema' => $detectie->krijg_hoofd_schema(),
            'extra_schemas' => $detectie->krijg_extra_schemas(),
        ) );
    }

    /**
     * AJAX handler: Sla handmatig schema op
     */
    public function ajax_sla_handmatig_op() {
        // Controleer nonce
        check_ajax_referer( 'tamrank_schema_detectie', 'nonce' );

        // Haal post ID op
        $post_id = isset( $_POST['post_id'] ) ? absint( $_POST['post_id'] ) : 0;
        if ( ! $post_id ) {
            wp_send_json_error( array( 'message' => tamrank__('error_missing_post_id', 'No post ID provided.'), 'code' => 'missing_parameter' ) );
        }

        // Controleer rechten
        if ( ! current_user_can( 'edit_post', $post_id ) ) {
            wp_send_json_error( array( 'message' => tamrank__('error_permission_denied', 'You do not have permission for this action.'), 'code' => 'permission_denied' ) );
        }

        // Haal schema type op
        $hoofd_type = isset( $_POST['hoofd_type'] ) ? sanitize_text_field( wp_unslash( $_POST['hoofd_type'] ) ) : '';
        if ( empty( $hoofd_type ) ) {
            wp_send_json_error( array( 'message' => tamrank__('error_missing_parameter', 'A required parameter is missing.'), 'code' => 'missing_parameter' ) );
        }

        // Haal extra types op
        $extra_types = array();
        if ( isset( $_POST['extra_types'] ) && is_array( $_POST['extra_types'] ) ) {
            $extra_types = array_map( 'sanitize_text_field', wp_unslash( $_POST['extra_types'] ) );
        }

        // Sla op
        $this->storage->sla_handmatige_keuze_op( $post_id, $hoofd_type, $extra_types );

        wp_send_json_success( array(
            'message'       => tamrank__('schema_saved', 'Schema saved.'),
            'hoofd_schema'  => $hoofd_type,
            'extra_schemas' => $extra_types,
        ) );
    }

    /**
     * AJAX handler: Reset schema keuze naar automatisch
     */
    public function ajax_reset_keuze() {
        // Controleer nonce
        check_ajax_referer( 'tamrank_schema_detectie', 'nonce' );

        // Haal post ID op
        $post_id = isset( $_POST['post_id'] ) ? absint( $_POST['post_id'] ) : 0;
        if ( ! $post_id ) {
            wp_send_json_error( array( 'message' => tamrank__('error_missing_post_id', 'No post ID provided.'), 'code' => 'missing_parameter' ) );
        }

        // Controleer rechten
        if ( ! current_user_can( 'edit_post', $post_id ) ) {
            wp_send_json_error( array( 'message' => tamrank__('error_permission_denied', 'You do not have permission for this action.'), 'code' => 'permission_denied' ) );
        }

        // Verwijder handmatige keuze (terug naar automatisch)
        $this->storage->verwijder_handmatige_keuze( $post_id );

        // Haal effectief schema op
        $effectief = $this->storage->krijg_effectief_schema( $post_id );

        // Bouw response veilig op met getter methods
        $response_data = array(
            'message' => tamrank__('schema_reset', 'Reset to automatic detection.'),
        );

        if ( $effectief ) {
            $response_data['hoofd_schema']  = $effectief->get_main_type();
            $response_data['extra_schemas'] = $effectief->get_extra_types();
            $response_data['bron']          = $effectief->krijg_bron();
        } else {
            $response_data['hoofd_schema']  = null;
            $response_data['extra_schemas'] = array();
            $response_data['bron']          = 'automatisch';
        }

        wp_send_json_success( $response_data );
    }

    /**
     * Haal effectief schema op voor een post
     *
     * @param int $post_id Post ID
     * @return TAMRANK_Schema_Effective_Choice
     */
    public function krijg_effectief_schema( $post_id ) {
        return $this->storage->krijg_effectief_schema( $post_id );
    }

    /**
     * Haal detectie resultaat op voor een post
     *
     * @param int $post_id Post ID
     * @return TAMRANK_Schema_Detection_Result|null
     */
    public function krijg_detectie_resultaat( $post_id ) {
        return $this->storage->krijg_detectie_resultaat( $post_id );
    }

    /**
     * Haal handmatige keuze op voor een post
     *
     * @param int $post_id Post ID
     * @return array|null
     */
    public function krijg_handmatige_keuze( $post_id ) {
        return $this->storage->krijg_handmatige_keuze( $post_id );
    }

    /**
     * Controleer of er een handmatige keuze is
     *
     * @param int $post_id Post ID
     * @return bool
     */
    public function heeft_handmatige_keuze( $post_id ) {
        return $this->storage->heeft_handmatige_keuze( $post_id );
    }

    /**
     * Genereer data voor metabox weergave
     *
     * @param int $post_id Post ID
     * @return array
     */
    public function krijg_metabox_data( $post_id ) {
        $effectief = $this->storage->krijg_effectief_schema( $post_id );
        $detectie  = $this->storage->krijg_detectie_resultaat( $post_id );
        $handmatig_raw = $this->storage->krijg_handmatige_keuze( $post_id );

        // Converteer handmatige keuze naar verwacht formaat
        $handmatig = null;
        if ( $handmatig_raw ) {
            $handmatig = array(
                'hoofd_type'  => isset( $handmatig_raw['type'] ) ? $handmatig_raw['type'] : '',
                'extra_types' => isset( $handmatig_raw['extras'] ) ? $handmatig_raw['extras'] : array(),
            );
        }

        // Bouw effectief array veilig op
        $effectief_array = null;
        if ( $effectief ) {
            $effectief_array = array(
                'hoofd_type'  => $effectief->get_main_type(),
                'extra_types' => $effectief->get_extra_types(),
                'bron'        => $effectief->krijg_bron(),
            );
        }

        return array(
            'post_id'              => $post_id,
            'effectief'            => $effectief_array,
            'detectie'             => $detectie ? array(
                'hoofd_schema'    => $detectie->krijg_hoofd_schema(),
                'extra_schemas'   => $detectie->krijg_extra_schemas(),
                'betrouwbaarheid' => $detectie->krijg_betrouwbaarheid(),
                'label'           => $detectie->krijg_betrouwbaarheid_label(),
                'scores'          => $detectie->krijg_alle_scores(),
                'is_geldig'       => $detectie->is_geldig(),
            ) : null,
            'handmatig'            => $handmatig,
            'heeft_handmatig'      => null !== $handmatig,
            'beschikbare_types'    => TAMRANK_Schema_Detection_Result::SCHEMA_TYPES,
            'extra_schema_types'   => TAMRANK_Schema_Detection_Result::EXTRA_SCHEMA_TYPES,
            'nonce'                => wp_create_nonce( 'tamrank_schema_detectie' ),
        );
    }

    /**
     * Registreer scripts en styles voor metabox
     *
     * @param string $hook Admin pagina hook
     */
    public function registreer_admin_assets( $hook ) {
        if ( ! in_array( $hook, array( 'post.php', 'post-new.php' ), true ) ) {
            return;
        }

        global $post;
        if ( ! $post || ! $this->is_post_type_ondersteund( $post->post_type ) ) {
            return;
        }

        // Gebruik TAM_RANK_PLUGIN_URL constante
        $plugin_url = TAM_RANK_PLUGIN_URL;

        // Bepaal versie voor cache-busting - gebruik de plugin-versieconstante.
        // (Was 'TAMRANK_VERSION' — bestaat niet; de juiste naam is TAM_RANK_VERSION.
        // Daardoor bleef de enqueue op ?ver=1.0.0 hangen en serveerde de browser
        // oude, gecachete JS na elke update.)
        $version = defined( 'TAM_RANK_VERSION' ) ? TAM_RANK_VERSION : '1.0.0';

        wp_enqueue_script(
            'tamrank-schema-detector',
            $plugin_url . 'assets/js/schema-detector.js',
            array( 'jquery' ),
            $version,
            true
        );

        wp_localize_script( 'tamrank-schema-detector', 'tamrankSchemaDetector', array(
            'ajaxUrl'      => admin_url( 'admin-ajax.php' ),
            'nonce'        => wp_create_nonce( 'tamrank_schema_detectie' ),
            'previewNonce' => wp_create_nonce( 'tamrank_schema_preview' ),
            'postId'       => $post->ID,
            'teksten'      => array(
                'detecteren'         => tamrank__( 'schema_detecting', 'Detecting schema...' ),
                'opslaan'            => tamrank__( 'saving', 'Saving...' ),
                'fout'               => tamrank__( 'schema_error_occurred', 'An error occurred.' ),
                'geenSchema'         => tamrank__( 'schema_none_detected', 'No schema detected.' ),
                'geaccepteerd'       => tamrank__( 'schema_accepted', 'Schema accepted!' ),
                'opgeslagen'         => tamrank__( 'schema_saved', 'Schema saved!' ),
                'gereset'            => tamrank__( 'schema_reset_automatic', 'Reset to automatic.' ),
                'active_schema'      => tamrank__( 'schema_active_source', 'Active schema:' ),
                'change'             => tamrank__( 'change', 'Change' ),
                'back_to_automatic'  => tamrank__( 'back_to_automatic', 'Back to Automatic' ),
                'schema_recommendation' => tamrank__( 'schema_recommendation', 'Schema Recommendation' ),
                'accept_recommendation' => tamrank__( 'schema_accept_recommendation', 'Accept Recommendation' ),
                'choose_manual'      => tamrank__( 'schema_choose_manual', 'Choose Manually' ),
                'detect_again'       => tamrank__( 'schema_detect_again', 'Detect Again' ),
                'manually_chosen'    => tamrank__( 'schema_manually_chosen', 'Manually chosen:' ),
                'select_main_type'   => tamrank__( 'schema_select_main_type', 'Select a main schema type.' ),
                'busy'               => tamrank__( 'processing', 'Processing...' ),
                'advice_applied'     => tamrank__( 'schema_advice_applied', 'Schema advice applied!' ),
                'active'             => tamrank__( 'active', 'Active' ),
                'schema_disabled'    => tamrank__( 'schema_disabled_label', 'Schema is disabled' ),
                'no_schema_data'     => tamrank__( 'schema_no_data', 'No schema data available' ),
                'preview_error'      => tamrank__( 'schema_preview_error', 'Error loading preview' ),
                'no_schema_selected' => tamrank__( 'schema_none_selected', 'No schema selected' ),
                'source_automatic'   => tamrank__( 'source_automatic', 'Automatic (TamRank)' ),
                'source_template'    => tamrank__( 'schema_template_label_short', 'Schema Template' ),
                'source_manual'      => tamrank__( 'source_manual_selected', 'Manually selected' ),
                'source_disabled'    => tamrank__( 'schema_source_disabled', 'Schema disabled' ),
                'deviates'           => tamrank__( 'deviates', 'Deviates' ),
                'take_advice'        => tamrank__( 'schema_take_advice', 'Apply advice' ),
                'schema_extra_found' => tamrank__( 'schema_extra_found', 'Extra schemas found:' ),
                'schemas_detected'   => tamrank__( 'schemas_detected', 'Schemas detected:' ),
                'reset_keuze_titel'  => tamrank__( 'schema_reset_choice_title', 'Reset schema choice?' ),
                'reset_keuze_bericht'=> tamrank__( 'schema_reset_choice_message', 'The manual choice will be removed and automatic detection will be used again.' ),
                'resetten'           => tamrank__( 'reset', 'Reset' ),
                'show_jsonld'        => tamrank__( 'show_jsonld', 'Show JSON-LD' ),
                'hide_jsonld'        => tamrank__( 'hide_jsonld', 'Hide JSON-LD' ),
            ),
        ) );

    }



    /**
     * AJAX handler: Schema bron opslaan
     */
    public function ajax_sla_schema_bron_op() {
        // Controleer nonce
        if ( ! check_ajax_referer( 'tamrank_schema_detectie', 'nonce', false ) ) {
            wp_send_json_error( array( 'message' => tamrank__('error_nonce_invalid', 'Invalid security token. Please refresh the page.'), 'code' => 'nonce_invalid' ) );
        }

        $post_id = isset( $_POST['post_id'] ) ? intval( $_POST['post_id'] ) : 0;
        $bron    = isset( $_POST['bron'] ) ? sanitize_text_field(wp_unslash($_POST['bron'])) : '';

        if ( ! $post_id ) {
            wp_send_json_error( array( 'message' => tamrank__('error_missing_post_id', 'No post ID provided.'), 'code' => 'missing_parameter' ) );
        }

        // Controleer rechten
        if ( ! current_user_can( 'edit_post', $post_id ) ) {
            wp_send_json_error( array( 'message' => tamrank__('error_permission_denied', 'You do not have permission for this action.'), 'code' => 'permission_denied' ) );
        }

        // Valideer bron
        $geldige_bronnen = array( 'automatisch', 'template', 'handmatig', 'geen' );
        if ( ! in_array( $bron, $geldige_bronnen, true ) ) {
            wp_send_json_error( array( 'message' => tamrank__('error_missing_parameter', 'A required parameter is missing.'), 'code' => 'missing_parameter' ) );
        }

        // Sla bron op in post meta
        update_post_meta( $post_id, 'tamrank_schema_bron', $bron );

        // Als bron "automatisch" is, wis de handmatige keuze zodat automatische detectie wordt gebruikt
        if ( $bron === 'automatisch' ) {
            $this->storage->wis_handmatige_keuze( $post_id );
        }

        // Bepaal het schema type op basis van bron
        $schema_type = '';
        if ( $bron === 'automatisch' ) {
            $detectie = $this->storage->krijg_detectie_resultaat( $post_id );
            if ( $detectie ) {
                $schema_type = $detectie->get_main_type();
            }
        } elseif ( $bron === 'template' ) {
            $template_id = get_post_meta( $post_id, 'tamrank_schema_template_id', true );
            $schema_type = $this->krijg_template_schema_type( $template_id );
        } elseif ( $bron === 'handmatig' ) {
            $handmatig = $this->storage->krijg_handmatige_keuze( $post_id );
            if ( $handmatig ) {
                $schema_type = $handmatig['type'] ?? '';
            }
        }

        wp_send_json_success( array(
            'message'     => tamrank__('schema_source_saved', 'Source saved.'),
            'bron'        => $bron,
            'schema_type' => $schema_type,
        ) );
    }

    /**
     * AJAX handler: Schema template opslaan
     */
    public function ajax_sla_schema_template_op() {
        // Controleer nonce
        if ( ! check_ajax_referer( 'tamrank_schema_detectie', 'nonce', false ) ) {
            wp_send_json_error( array( 'message' => tamrank__('error_nonce_invalid', 'Invalid security token. Please refresh the page.'), 'code' => 'nonce_invalid' ) );
        }

        $post_id     = isset( $_POST['post_id'] ) ? intval( $_POST['post_id'] ) : 0;
        $template_id = isset( $_POST['template_id'] ) ? sanitize_text_field(wp_unslash($_POST['template_id'])) : '';

        if ( ! $post_id ) {
            wp_send_json_error( array( 'message' => tamrank__('error_missing_post_id', 'No post ID provided.'), 'code' => 'missing_parameter' ) );
        }

        // Controleer rechten
        if ( ! current_user_can( 'edit_post', $post_id ) ) {
            wp_send_json_error( array( 'message' => tamrank__('error_permission_denied', 'You do not have permission for this action.'), 'code' => 'permission_denied' ) );
        }

        // Sla template op in post meta
        update_post_meta( $post_id, 'tamrank_schema_template_id', $template_id );

        // Bepaal het schema type van de template
        $schema_type = $this->krijg_template_schema_type( $template_id );

        wp_send_json_success( array(
            'message'     => tamrank__('schema_template_saved', 'Template saved.'),
            'template_id' => $template_id,
            'schema_type' => $schema_type,
        ) );
    }
}
