/**
 * AYSA Metabox JavaScript
 * Script pentru gestionarea metabox-urilor SEO în categorii, produse și pagini
 */

document.addEventListener('DOMContentLoaded', function() {
    const metaboxDebug = window.AYSA_DEBUG === true;
    const metaboxDebugLog = (...args) => {
        if (metaboxDebug) {
            console.log(...args);
        }
    };

    metaboxDebugLog('AYSA Metabox JS loaded');

    function getAysaApiBaseUrl() {
        if (window.AysaAPI && typeof window.AysaAPI.getConfig === 'function') {
            const cfg = window.AysaAPI.getConfig() || {};
            if (cfg.baseUrl) {
                return String(cfg.baseUrl).replace(/\/$/, '');
            }
        }

        if (typeof aysaParams !== 'undefined') {
            if (aysaParams.api_base_url) {
                return String(aysaParams.api_base_url).replace(/\/$/, '');
            }
            if (aysaParams.api_config && (aysaParams.api_config.baseUrl || aysaParams.api_config.base_url)) {
                return String(aysaParams.api_config.baseUrl || aysaParams.api_config.base_url).replace(/\/$/, '');
            }
        }

        return 'https://api.aysa.ai';
    }

    function isAssociationNotFoundError(error) {
        if (!error) {
            return false;
        }

        const message = typeof error === 'string' ? error : (error.message || '');
        return message.indexOf('API response status: 404') !== -1;
    }

    function resolveAjaxUrl() {
        if (typeof aysa_ajax !== 'undefined' && aysa_ajax.ajax_url) {
            return aysa_ajax.ajax_url;
        }
        if (typeof aysaParams !== 'undefined' && aysaParams.ajax_url) {
            return aysaParams.ajax_url;
        }
        return '/wp-admin/admin-ajax.php';
    }

    function resolveAjaxNonce() {
        if (typeof aysa_ajax !== 'undefined' && aysa_ajax.nonce) {
            return aysa_ajax.nonce;
        }
        if (typeof aysaParams !== 'undefined') {
            if (aysaParams.nonce) {
                return aysaParams.nonce;
            }
            if (aysaParams.ajax_nonce) {
                return aysaParams.ajax_nonce;
            }
            if (aysaParams.generic_nonce) {
                return aysaParams.generic_nonce;
            }
        }
        return '';
    }

    async function fetchLocalAssociations(entityId, entityType, projectId) {
        const response = await fetch(resolveAjaxUrl(), {
            method: 'POST',
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                'Accept': 'application/json'
            },
            body: new URLSearchParams({
                action: 'aysa_onpage_get_associations',
                nonce: resolveAjaxNonce(),
                project_id: String(projectId || '')
            }).toString(),
            credentials: 'same-origin'
        });

        if (!response.ok) {
            throw new Error('Local association response status: ' + response.status);
        }

        const payload = await response.json();
        const associations = payload && payload.success && payload.data && Array.isArray(payload.data.associations)
            ? payload.data.associations
            : [];

        const wantedId = parseInt(entityId, 10);
        const wantedType = String(entityType || '').toLowerCase();

        return associations.filter((assoc) => {
            const assocId = parseInt(
                assoc.idIntern ?? assoc.IdIntern ?? assoc.entity_id ?? assoc.id_intern ?? 0,
                10
            );
            const assocType = String(
                assoc.AssociatedOn ?? assoc.associatedOn ?? assoc.entity_type ?? assoc.EntityType ?? ''
            ).toLowerCase();

            return assocId === wantedId && assocType === wantedType;
        });
    }

    /**
     * Funcție globală pentru încărcarea datelor din API
     * Această funcție este apelată direct din scripturile PHP inline
     */
    window.loadDataFromAPI = function() {
        metaboxDebugLog('Global loadDataFromAPI function called');
        
        // Detectare context admin
        const isProductEdit = document.body.classList.contains('post-type-product');
        const isPageEdit = document.body.classList.contains('post-type-page');
        const isCategoryEdit = document.body.classList.contains('taxonomy-product_cat');
        
        metaboxDebugLog('Admin context detection:', { 
            isProductEdit, 
            isPageEdit, 
            isCategoryEdit,
            bodyClasses: document.body.className
        });
        
        // Obține ID-ul entității și tipul din diferite surse
        let entityId = 0;
        let entityType = 'Unknown';
        
        // 1. Prima sursă: aysaParams (setat de PHP)
        if (typeof aysaParams !== 'undefined') {
            metaboxDebugLog('Found aysaParams:', aysaParams);
            
            if (aysaParams.postId) {
                entityId = parseInt(aysaParams.postId);
                entityType = aysaParams.entityType || 'Product';
            } else if (aysaParams.termId) {
                entityId = parseInt(aysaParams.termId);
                entityType = 'Category';
            }
        }
        
        // 2. A doua sursă: URL parameters
        if (entityId === 0) {
            const urlParams = new URLSearchParams(window.location.search);
            if (urlParams.has('post')) {
                entityId = parseInt(urlParams.get('post'));
                entityType = isProductEdit ? 'Product' : 'Page';
            } else if (urlParams.has('tag_ID')) {
                entityId = parseInt(urlParams.get('tag_ID'));
                entityType = 'Category';
            }
        }
        
        // 3. A treia sursă: hidden input pentru ID
        if (entityId === 0) {
            const postIdInput = document.querySelector('input[name="post_ID"]');
            if (postIdInput) {
                entityId = parseInt(postIdInput.value);
                entityType = isProductEdit ? 'Product' : 'Page';
            }
        }
        
        metaboxDebugLog('Entity information:', { entityId, entityType });
        
        if (entityId === 0) {
            console.error('Could not determine entity ID');
            return;
        }
        
        // Obține ID-ul proiectului din localStorage
        const projectId = localStorage.getItem('aysa_project_id') || '';
        
        // Normalizează tipul entității pentru API
        let apiEntityType = entityType;
        if (entityType.toLowerCase() === 'term') {
            apiEntityType = 'Category';
        }
        
        // Construiește URL-ul API
        const apiUrl = `${getAysaApiBaseUrl()}/api/Association/GetAllByAssociatedOnAndIdIntern?associatedOn=${encodeURIComponent(apiEntityType)}&idIntern=${entityId}&projectId=${encodeURIComponent(projectId)}`;
        metaboxDebugLog('API URL:', apiUrl);
        
        // Elementele formularului
        const mainKeywordInput = document.getElementById('aysa-entity-keyword') || document.getElementById('aysa-primary-keyword');
        const secondKeywordInput = document.getElementById('aysa-entity-second-keyword');
        const metaTitleInput = document.getElementById('aysa-entity-meta-title');
        const metaDescriptionInput = document.getElementById('aysa-entity-meta-description');
        const metaKeywordsInput = document.getElementById('aysa-entity-meta-keywords');
        const keywordDropdown = document.getElementById('keyword-suggestions');
        
        metaboxDebugLog('Form elements found:', {
            mainKeywordInput: !!mainKeywordInput,
            secondKeywordInput: !!secondKeywordInput,
            metaTitleInput: !!metaTitleInput,
            metaDescriptionInput: !!metaDescriptionInput,
            metaKeywordsInput: !!metaKeywordsInput,
            keywordDropdown: !!keywordDropdown
        });
        
        if (!mainKeywordInput) {
            metaboxDebugLog('AYSA Metabox: skipping API preload because no compatible main keyword input exists in this editor context.');
            return;
        }
        
        // Curăță toate câmpurile înainte de încărcare
        function clearFormValues() {
            if (mainKeywordInput) mainKeywordInput.value = '';
            if (secondKeywordInput) secondKeywordInput.value = '';
            if (metaTitleInput) metaTitleInput.value = '';
            if (metaDescriptionInput) metaDescriptionInput.value = '';
            if (metaKeywordsInput) metaKeywordsInput.value = '';
            
            // Resetare dropdown cu keyword-uri secundare
            if (keywordDropdown) {
                while (keywordDropdown.options.length > 1) {
                    keywordDropdown.remove(1);
                }
            }
        }
        
        // Arată loading state
        const loadingButtons = document.querySelectorAll('.btn-accept.save');
        loadingButtons.forEach(button => {
            button.disabled = true;
            const spinner = button.nextElementSibling;
            if (spinner && spinner.classList.contains('spinner')) {
                spinner.classList.add('is-active');
            }
        });
        
        // Adaugă keywords de test pentru debugging și testare
        function resetSecondaryKeywordDropdown() {
            if (!keywordDropdown) return;

            while (keywordDropdown.options.length > 1) {
                keywordDropdown.remove(1);
            }

            keywordDropdown.value = '';
            keywordDropdown.disabled = true;
        }
        
        // Fetch data from API, then fall back to locally cached associations when the legacy endpoint is unavailable.
        fetch(apiUrl, {
            method: 'GET',
            headers: {
                'Accept': 'application/json',
                'Origin': window.location.origin
            },
            mode: 'cors'
        })
        .then(response => {
            metaboxDebugLog('API response status:', response.status);
            if (!response.ok) {
                throw new Error('API response status: ' + response.status);
            }
            return response.json();
        })
        .catch(async (error) => {
            if (!isAssociationNotFoundError(error)) {
                throw error;
            }

            metaboxDebugLog('Association endpoint unavailable, using local fallback.');
            return fetchLocalAssociations(entityId, apiEntityType, projectId);
        })
        .then(data => {
            metaboxDebugLog('Data loaded from API:', data);
            
            // Update form fields with loaded data
            if (data) {
                // Check if the response is an array (multiple associations)
                const associations = Array.isArray(data) ? data : [data];
                
                if (associations.length > 0) {
                    metaboxDebugLog('Processing', associations.length, 'associations');
                    
                    // Use the first association for primary keyword
                    const firstAssociation = associations[0];
                    
                    // Update keyword field with the first association's keyword
                    if (firstAssociation.keyword && mainKeywordInput) {
                        mainKeywordInput.value = firstAssociation.keyword;
                    }
                    
                    // Collect all other keywords from remaining associations
                    if (associations.length > 1 && secondKeywordInput) {
                        const secondaryKeywords = associations.slice(1)
                            .map(assoc => assoc.keyword)
                            .filter(keyword => keyword && keyword.trim() !== '')
                            .join(', ');
                        
                        metaboxDebugLog('Secondary keywords:', secondaryKeywords);
                        
                        secondKeywordInput.value = secondaryKeywords;
                        
                        // Populează dropdown-ul cu keywords secundare pentru funcția de replace
                        if (keywordDropdown) {
                            metaboxDebugLog('Populating keywords dropdown with secondary keywords');
                            
                            // Golește dropdown-ul
                            while (keywordDropdown.options.length > 1) {
                                keywordDropdown.remove(1);
                            }
                            
                            // Adaugă fiecare keyword secundar ca opțiune
                            associations.slice(1).forEach(assoc => {
                                if (assoc.keyword && assoc.keyword.trim() !== '') {
                                    const option = document.createElement('option');
                                    option.value = assoc.keyword.trim();
                                    option.text = assoc.keyword.trim();
                                    keywordDropdown.add(option);
                                }
                            });
                            
                            // Activează dropdown-ul dacă avem opțiuni
                            keywordDropdown.disabled = keywordDropdown.options.length <= 1;
                            
                            // Adaugă event listener pentru schimbarea dropdown-ului
                            if (!keywordDropdown.hasAttribute('data-listeners-added')) {
                                keywordDropdown.setAttribute('data-listeners-added', 'true');
                                
                                keywordDropdown.addEventListener('change', function() {
                                    const selectedKeyword = this.value;
                                    
                                    if (selectedKeyword) {
                                        metaboxDebugLog('Selected secondary keyword to replace main keyword:', selectedKeyword);
                                        
                                        // Confirmă înlocuirea
                                        if (confirm(`Doriți să înlocuiți keyword-ul principal "${mainKeywordInput.value}" cu "${selectedKeyword}"?`)) {
                                            // Efectuează apelul API pentru setmain
                                            const setMainUrl = `${getAysaApiBaseUrl()}/api/Association/setmain?keyword=${encodeURIComponent(selectedKeyword)}&associatedOn=${encodeURIComponent(apiEntityType)}&idIntern=${entityId}&projectId=${encodeURIComponent(projectId)}`;
                                            
                                            fetch(setMainUrl, {
                                                method: 'PUT',
                                                headers: {
                                                    'Accept': 'application/json',
                                                    'Origin': window.location.origin
                                                },
                                                mode: 'cors'
                                            })
                                            .then(response => {
                                                if (!response.ok) {
                                                    throw new Error('API response status: ' + response.status);
                                                }
                                                return response.json();
                                            })
                                            .then(data => {
                                                metaboxDebugLog('SetMain API response:', data);
                                                
                                                // Actualizează UI-ul
                                                const oldMainKeyword = mainKeywordInput.value;
                                                mainKeywordInput.value = selectedKeyword;
                                                
                                                // Actualizează lista de keywords secundare
                                                if (secondKeywordInput) {
                                                    let secondaries = secondKeywordInput.value.split(',').map(k => k.trim()).filter(k => k !== '');
                                                    secondaries = secondaries.filter(k => k !== selectedKeyword);
                                                    secondaries.push(oldMainKeyword);
                                                    secondKeywordInput.value = secondaries.join(', ');
                                                }
                                                
                                                // Reîncarcă datele din API pentru a actualiza dropdown-ul
                                                setTimeout(() => {
                                                    // Resetăm dropdown-ul înainte de reîncărcare
                                                    keywordDropdown.value = '';
                                                    window.loadDataFromAPI();
                                                }, 500);
                                                
                                                alert('Keyword-ul principal a fost actualizat cu succes!');
                                            })
                                            .catch(error => {
                                                console.error('Error setting main keyword:', error);
                                                alert('Eroare la actualizarea keyword-ului principal: ' + error.message);
                                            });
                                        } else {
                                            // Resetează selecția dropdown-ului dacă utilizatorul anulează
                                            this.value = '';
                                        }
                                    }
                                });
                            }
                        }
                    } else if (keywordDropdown) {
                        resetSecondaryKeywordDropdown();
                    }
                    
                    // Update other metadata fields
                    if (firstAssociation.metaTitle && metaTitleInput) {
                        metaTitleInput.value = firstAssociation.metaTitle;
                    }
                    
                    if (firstAssociation.metaDescription && metaDescriptionInput) {
                        metaDescriptionInput.value = firstAssociation.metaDescription;
                    }
                    
                    if (firstAssociation.metaKeywords && metaKeywordsInput) {
                        metaKeywordsInput.value = firstAssociation.metaKeywords;
                    }
                } else {
                    metaboxDebugLog('No associations found');
                    resetSecondaryKeywordDropdown();
                }
            }
        })
        .catch(error => {
            if (isAssociationNotFoundError(error)) {
                console.info('No AYSA associations found yet for this entity.');
                resetSecondaryKeywordDropdown();
                return;
            }

            console.error('Error loading data from API:', error);
            resetSecondaryKeywordDropdown();
        })
        .finally(() => {
            // Remove loading state
            loadingButtons.forEach(button => {
                button.disabled = false;
                const spinner = button.nextElementSibling;
                if (spinner && spinner.classList.contains('spinner')) {
                    spinner.classList.remove('is-active');
                }
            });
        });
    };

    // Inițializare dropdown și buton pentru keyworduri
    initKeywordDropdown();
    
    /**
     * Inițializează dropdown-ul și butonul de replace keyword
     */
    function initKeywordDropdown() {
        metaboxDebugLog('Initializing keyword dropdown');
        
        const keywordDropdown = document.getElementById('keyword-suggestions');
        const replaceKeywordBtn = document.getElementById('replace-keyword-btn');
        const mainKeywordInput = document.getElementById('aysa-entity-keyword');
        
        // Inițializează butonul de replace keyword
        if (replaceKeywordBtn && mainKeywordInput) {
            replaceKeywordBtn.addEventListener('click', function() {
                const currentKeyword = mainKeywordInput.value.trim();
                
                if (!currentKeyword) {
                    alert('Nu există un keyword principal pentru a fi înlocuit.');
                    return;
                }
                
                // Deschide un prompt pentru a introduce manual un nou keyword
                const newKeyword = prompt('Introduceți noul keyword principal:', currentKeyword);
                
                if (newKeyword && newKeyword.trim() !== '' && newKeyword !== currentKeyword) {
                    // Obține informații despre entitate
                    let entityId = 0;
                    let entityType = 'Unknown';
                    
                    // Încercăm să obținem din aysaParams
                    if (typeof aysaParams !== 'undefined') {
                        if (aysaParams.postId) {
                            entityId = parseInt(aysaParams.postId);
                            entityType = aysaParams.entityType || 'Product';
                        } else if (aysaParams.termId) {
                            entityId = parseInt(aysaParams.termId);
                            entityType = 'Category';
                        }
                    }
                    
                    // Normalizare tip entitate
                    if (entityType.toLowerCase() === 'term') {
                        entityType = 'Category';
                    }
                    
                    const projectId = localStorage.getItem('aysa_project_id') || '';
                    
                    // Efectuează apelul API pentru setmain
                    const setMainUrl = `${getAysaApiBaseUrl()}/api/Association/setmain?keyword=${encodeURIComponent(newKeyword)}&associatedOn=${encodeURIComponent(entityType)}&idIntern=${entityId}&projectId=${encodeURIComponent(projectId)}`;
                    
                    fetch(setMainUrl, {
                        method: 'PUT',
                        headers: {
                            'Accept': 'application/json',
                            'Origin': window.location.origin
                        },
                        mode: 'cors'
                    })
                    .then(response => {
                        if (!response.ok) {
                            throw new Error('API response status: ' + response.status);
                        }
                        return response.json();
                    })
                    .then(data => {
                        metaboxDebugLog('SetMain API response:', data);
                        
                        // Actualizează UI-ul
                        const oldMainKeyword = mainKeywordInput.value;
                        mainKeywordInput.value = newKeyword;
                        
                        // Actualizează lista de keywords secundare
                        const secondKeywordInput = document.getElementById('aysa-entity-second-keyword');
                        if (secondKeywordInput) {
                            let secondaries = secondKeywordInput.value.split(',').map(k => k.trim()).filter(k => k !== '');
                            // Adăugăm vechiul keyword principal ca secundar
                            if (oldMainKeyword) {
                                secondaries.push(oldMainKeyword);
                            }
                            secondKeywordInput.value = secondaries.join(', ');
                        }
                        
                        // Reîncărcăm datele din API pentru a actualiza dropdown-ul
                        setTimeout(() => {
                            window.loadDataFromAPI();
                        }, 500);
                        
                        alert('Keyword-ul principal a fost actualizat cu succes!');
                    })
                    .catch(error => {
                        console.error('Error setting main keyword:', error);
                        alert('Eroare la actualizarea keyword-ului principal: ' + error.message);
                    });
                }
            });
        }
    }
}); 
