/**
 * Jobs Safety Fix - Mercedes-Benz MYP Platform
 * Umfassende Lösung für "jobs undefined" Probleme
 * Version: 2.0.0 - Erweiterte Fehlerbehandlung
 */

(function() {
    'use strict';
    
    console.log('🛡️ Jobs Safety Fix v2.0.0 wird geladen...');
    
    /**
     * Globale Jobs-Variable sicher initialisieren
     */
    if (typeof window.jobsData === 'undefined') {
        window.jobsData = [];
        console.log('✅ window.jobsData initialisiert');
    }
    
    if (typeof window.filteredJobs === 'undefined') {
        window.filteredJobs = [];
        console.log('✅ window.filteredJobs initialisiert');
    }
    
    /**
     * Sichere Jobs-Funktionen
     */
    window.safeJobsOperations = {
        /**
         * Jobs sicher abrufen
         */
        getJobs: function() {
            try {
                if (window.jobManager && Array.isArray(window.jobManager.jobs)) {
                    return window.jobManager.jobs;
                }
                if (Array.isArray(window.jobsData)) {
                    return window.jobsData;
                }
                console.warn('⚠️ Keine gültigen Jobs gefunden, gebe leeres Array zurück');
                return [];
            } catch (error) {
                console.error('❌ Fehler beim Abrufen der Jobs:', error);
                return [];
            }
        },
        
        /**
         * Gefilterte Jobs sicher abrufen
         */
        getFilteredJobs: function() {
            try {
                if (Array.isArray(window.filteredJobs)) {
                    return window.filteredJobs;
                }
                return this.getJobs();
            } catch (error) {
                console.error('❌ Fehler beim Abrufen der gefilterten Jobs:', error);
                return [];
            }
        },
        
        /**
         * Jobs sicher setzen
         */
        setJobs: function(jobs) {
            try {
                if (!Array.isArray(jobs)) {
                    console.warn('⚠️ Jobs ist kein Array, konvertiere zu leerem Array:', typeof jobs);
                    jobs = [];
                }
                
                if (window.jobManager) {
                    window.jobManager.jobs = jobs;
                }
                window.jobsData = jobs;
                
                console.log(`✅ ${jobs.length} Jobs sicher gesetzt`);
                
                // Event für andere Komponenten
                window.dispatchEvent(new CustomEvent('jobsUpdated', { 
                    detail: { jobs: jobs, count: jobs.length }
                }));
                
            } catch (error) {
                console.error('❌ Fehler beim Setzen der Jobs:', error);
                window.jobsData = [];
                if (window.jobManager) {
                    window.jobManager.jobs = [];
                }
            }
        },
        
        /**
         * Job sicher finden
         */
        findJob: function(jobId) {
            try {
                const jobs = this.getJobs();
                const job = jobs.find(job => job && job.id && job.id.toString() === jobId.toString());
                if (!job) {
                    console.warn(`⚠️ Job mit ID ${jobId} nicht gefunden`);
                }
                return job || null;
            } catch (error) {
                console.error('❌ Fehler beim Suchen des Jobs:', error);
                return null;
            }
        },
        
        /**
         * Jobs sicher filtern
         */
        filterJobs: function(filterFn) {
            try {
                const jobs = this.getJobs();
                if (typeof filterFn !== 'function') {
                    console.warn('⚠️ Filter-Funktion ist nicht gültig');
                    return jobs;
                }
                
                return jobs.filter(job => {
                    if (!job || typeof job !== 'object') {
                        return false;
                    }
                    try {
                        return filterFn(job);
                    } catch (filterError) {
                        console.warn('⚠️ Fehler beim Filtern eines Jobs:', filterError);
                        return false;
                    }
                });
            } catch (error) {
                console.error('❌ Fehler beim Filtern der Jobs:', error);
                return this.getJobs();
            }
        },
        
        /**
         * Debug-Informationen ausgeben
         */
        debugInfo: function() {
            console.group('🔍 Jobs Debug Info');
            console.log('jobsData:', window.jobsData);
            console.log('filteredJobs:', window.filteredJobs);
            console.log('jobManager:', window.jobManager);
            console.log('jobManager.jobs:', window.jobManager?.jobs);
            console.groupEnd();
        }
    };
    
    /**
     * JobManager Sicherheitsprüfungen
     */
    function ensureJobManagerSafety() {
        try {
            if (typeof window.jobManager !== 'undefined' && window.jobManager) {
                // Sicherstellen, dass jobs ein Array ist
                if (!Array.isArray(window.jobManager.jobs)) {
                    console.warn('⚠️ JobManager.jobs ist kein Array, korrigiere...', typeof window.jobManager.jobs);
                    window.jobManager.jobs = [];
                }
                
                // Originale loadJobs Methode wrappen
                if (window.jobManager.loadJobs && typeof window.jobManager.loadJobs === 'function' && !window.jobManager._loadJobsWrapped) {
                    const originalLoadJobs = window.jobManager.loadJobs;
                    window.jobManager.loadJobs = async function(...args) {
                        try {
                            console.log('🔄 Lade Jobs sicher...');
                            await originalLoadJobs.apply(this, args);
                            // Nach dem Laden sicherstellen, dass jobs ein Array ist
                            if (!Array.isArray(this.jobs)) {
                                console.warn('⚠️ Jobs nach dem Laden kein Array, korrigiere...');
                                this.jobs = [];
                            }
                            console.log(`✅ ${this.jobs.length} Jobs erfolgreich geladen`);
                        } catch (error) {
                            console.error('❌ Fehler beim sicheren Laden der Jobs:', error);
                            this.jobs = [];
                            throw error;
                        }
                    };
                    window.jobManager._loadJobsWrapped = true;
                }
                
                // Originale renderJobs Methode wrappen
                if (window.jobManager.renderJobs && typeof window.jobManager.renderJobs === 'function' && !window.jobManager._renderJobsWrapped) {
                    const originalRenderJobs = window.jobManager.renderJobs;
                    window.jobManager.renderJobs = function(...args) {
                        try {
                            // Sicherstellen, dass jobs ein Array ist vor dem Rendern
                            if (!Array.isArray(this.jobs)) {
                                console.warn('⚠️ Jobs ist kein Array vor dem Rendern, korrigiere...');
                                this.jobs = [];
                            }
                            console.log(`🎨 Rendere ${this.jobs.length} Jobs...`);
                            return originalRenderJobs.apply(this, args);
                        } catch (error) {
                            console.error('❌ Fehler beim sicheren Rendern der Jobs:', error);
                            // Fallback-Rendering
                            const jobsList = document.getElementById('jobs-list');
                            if (jobsList) {
                                jobsList.innerHTML = `
                                    <div class="text-center py-12">
                                        <div class="text-red-400 dark:text-red-600 text-6xl mb-4">⚠️</div>
                                        <h3 class="text-lg font-medium text-gray-900 dark:text-white mb-2">Renderingfehler</h3>
                                        <p class="text-gray-500 dark:text-gray-400 mb-4">Jobs konnten nicht angezeigt werden</p>
                                        <button onclick="window.safeJobsOperations.debugInfo(); window.jobManager?.loadJobs?.()" 
                                                class="px-4 py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700">
                                            Erneut laden
                                        </button>
                                    </div>
                                `;
                            }
                        }
                    };
                    window.jobManager._renderJobsWrapped = true;
                }
            }
        } catch (error) {
            console.error('❌ Fehler bei JobManager-Sicherheitsprüfung:', error);
        }
    }
    
    /**
     * Globale Variablen-Überwachung
     */
    function setupGlobalVariableWatching() {
        try {
            // jobsData überwachen
            let _jobsData = window.jobsData || [];
            Object.defineProperty(window, 'jobsData', {
                get: function() {
                    return _jobsData;
                },
                set: function(value) {
                    if (!Array.isArray(value)) {
                        console.warn('⚠️ Versuche jobsData mit Non-Array zu setzen:', typeof value, value);
                        _jobsData = [];
                    } else {
                        _jobsData = value;
                        console.log(`✅ jobsData gesetzt: ${value.length} Jobs`);
                    }
                },
                enumerable: true,
                configurable: true
            });
            
            // filteredJobs überwachen
            let _filteredJobs = window.filteredJobs || [];
            Object.defineProperty(window, 'filteredJobs', {
                get: function() {
                    return _filteredJobs;
                },
                set: function(value) {
                    if (!Array.isArray(value)) {
                        console.warn('⚠️ Versuche filteredJobs mit Non-Array zu setzen:', typeof value, value);
                        _filteredJobs = [];
                    } else {
                        _filteredJobs = value;
                        console.log(`✅ filteredJobs gesetzt: ${value.length} Jobs`);
                    }
                },
                enumerable: true,
                configurable: true
            });
            
            console.log('✅ Globale Variablen-Überwachung eingerichtet');
        } catch (error) {
            console.error('❌ Fehler bei Variablen-Überwachung:', error);
        }
    }
    
    /**
     * API-Response Validator
     */
    window.validateJobsResponse = function(data) {
        try {
            if (!data || typeof data !== 'object') {
                console.warn('⚠️ Ungültige API-Response:', data);
                return { jobs: [], total: 0 };
            }
            
            let jobs = [];
            
            // Verschiedene Response-Formate unterstützen
            if (Array.isArray(data.jobs)) {
                jobs = data.jobs;
            } else if (Array.isArray(data.data)) {
                jobs = data.data;
            } else if (Array.isArray(data)) {
                jobs = data;
            } else if (data.success && Array.isArray(data.jobs)) {
                jobs = data.jobs;
            }
            
            // Jobs validieren
            const validJobs = jobs.filter(job => {
                if (!job || typeof job !== 'object') {
                    console.warn('⚠️ Ungültiges Job-Objekt gefiltert:', job);
                    return false;
                }
                if (!job.id) {
                    console.warn('⚠️ Job ohne ID gefiltert:', job);
                    return false;
                }
                return true;
            });
            
            console.log(`✅ ${validJobs.length} von ${jobs.length} Jobs validiert`);
            return {
                jobs: validJobs,
                total: validJobs.length,
                current_page: data.current_page || 1,
                total_pages: data.total_pages || 1
            };
        } catch (error) {
            console.error('❌ Fehler bei API-Response-Validierung:', error);
            return { jobs: [], total: 0 };
        }
    };
    
    /**
     * Fehlerbehandlung für undefined Jobs
     */
    window.addEventListener('error', function(e) {
        if (e.message && e.message.toLowerCase().includes('jobs') && e.message.toLowerCase().includes('undefined')) {
            console.log('🛡️ Jobs undefined Fehler abgefangen:', e.message);
            console.log('🛡️ Stack:', e.error?.stack);
            
            // Versuche Jobs zu reparieren
            window.safeJobsOperations.setJobs([]);
            
            // Debug-Info ausgeben
            window.safeJobsOperations.debugInfo();
            
            e.preventDefault();
            return false;
        }
    });
    
    /**
     * Promise rejection handler für Jobs
     */
    window.addEventListener('unhandledrejection', function(e) {
        if (e.reason && e.reason.message && e.reason.message.toLowerCase().includes('jobs')) {
            console.log('🛡️ Jobs Promise rejection abgefangen:', e.reason);
            
            // Versuche Jobs zu reparieren
            window.safeJobsOperations.setJobs([]);
            
            e.preventDefault();
        }
    });
    
    /**
     * DOM bereit - Setup starten
     */
    function initializeSafety() {
        try {
            setupGlobalVariableWatching();
            ensureJobManagerSafety();
            console.log('✅ Jobs Safety Fix erfolgreich initialisiert');
        } catch (error) {
            console.error('❌ Fehler bei Safety Fix Initialisierung:', error);
        }
    }
    
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', initializeSafety);
    } else {
        initializeSafety();
    }
    
    /**
     * Periodische Sicherheitsprüfung
     */
    setInterval(function() {
        try {
            ensureJobManagerSafety();
            
            // Prüfe ob globale Jobs-Variablen noch Arrays sind
            if (!Array.isArray(window.jobsData)) {
                console.warn('⚠️ jobsData ist kein Array mehr, repariere...', typeof window.jobsData);
                window.jobsData = [];
            }
            
            if (!Array.isArray(window.filteredJobs)) {
                console.warn('⚠️ filteredJobs ist kein Array mehr, repariere...', typeof window.filteredJobs);
                window.filteredJobs = [];
            }
        } catch (error) {
            console.error('❌ Fehler bei periodischer Sicherheitsprüfung:', error);
        }
    }, 15000); // Alle 15 Sekunden
    
    // Globale Debug-Funktion verfügbar machen
    window.debugJobs = function() {
        window.safeJobsOperations.debugInfo();
    };
    
    console.log('✅ Jobs Safety Fix v2.0.0 erfolgreich geladen');
    
})();