if (function_exists('str_getcsv')) {
            $result = str_getcsv($line, $delimiter, '"', "\\");
        } else {
            // Fallback für ältere PHP-Versionen
            $result = array();
            $current = "";
            $in_quotes = false;
            
            // Vereinfachter Parser - weniger fehleranfällig
            for ($i = 0; $i < strlen($line); $i++) {
                $char = $line[$i];
                
                if ($char == '"') {
                    if ($in_quotes && $i + 1 < strlen($line) && $line[$i + 1] == '"') {
                        // Escaped quote inside quotes
                        $current .= '"';
                        $i++;
                    } else {
                        // Toggle quotes mode
                        $in_quotes = !$in_quotes;
                    }
                } elseif ($char == $delimiter && !$in_quotes) {
                    // Field delimiter found outside quotes - push value and reset
                    $result[] = $current;
                    $current = "";
                } else {
                    // Regular character
                    $current .= $char;
                }
            }
            
            // Letztes Feld hinzufügen
            $result[] = $current;
        }
        
        // Nachbearbeitung: Bereinige URLs in der Ergebniszeile
        foreach ($result as $key => $value) {
            // Prüfe, ob der Wert eine Bild-URL sein könnte
            if (preg_match('~^https?://.*\.(jpg|jpeg|png|gif|webp)~i', $value)) {
                $cleaned_url = $this->clean_image_url($value);
                if ($cleaned_url) {
                    $result[$key] = $cleaned_url;
                }
            }
        }
        
        return $result;
    }
    
    /**
     * Elementor-Daten richtig verarbeiten und Platzhalter ersetzen
     */
    private function process_elementor_data($template_id, $post_id, $placeholders, $debug_mode, &$log) {
        // Template-Daten holen
        $template_data = get_post_meta($template_id, '_elementor_data', true);
        $template_type = get_post_meta($template_id, '_elementor_template_type', true);
        
        if (empty($template_data)) {
            if ($debug_mode) {
                $log[] = "DEBUG: Keine Elementor-Daten im Template gefunden!";
            }
            return false;
        }
        
        // 1. Versuche als JSON zu parsen
        $template_array = json_decode($template_data, true);
        
        // Prüfen ob das Decoding funktioniert hat
        if (json_last_error() !== JSON_ERROR_NONE) {
            if ($debug_mode) {
                $log[] = "DEBUG: Elementor-Daten sind kein gültiges JSON. Versuche Deserialisierung...";
                $log[] = "DEBUG: JSON-Fehler: " . json_last_error_msg();
            }
            
            // Als Fallback versuchen, serialisierte Daten zu verarbeiten
            $template_array = maybe_unserialize($template_data);
            
            // Wenn es immer noch kein Array ist, String-Ersetzung als letzten Ausweg verwenden
            if (!is_array($template_array)) {
                if ($debug_mode) {
                    $log[] = "DEBUG: Fallback auf String-Ersetzung für Elementor-Daten";
                }
                
                // FIXIERTE VERSION: Nur einfache String-Ersetzung ohne json_encode
                $modified_data = $template_data;
                foreach ($placeholders as $key => $value) {
                    // Nur diese Zeile behalten, kein json_encode mehr verwenden
                    $modified_data = str_replace('{{' . $key . '}}', $value, $modified_data);
                }
                
                update_post_meta($post_id, '_elementor_data', wp_slash($modified_data));
                
                // Kopiere wichtige Elementor-Metadaten
                $this->copy_elementor_template_meta($template_id, $post_id);
                
                return true;
            }
        }
        
        if ($debug_mode) {
            $log[] = "DEBUG: Elementor-Daten erfolgreich als JSON-Array geparst";
        }
        
        // 2. Platzhalter im Array ersetzen (rekursiv)
        $modified_array = $this->replace_placeholders_in_array($template_array, $placeholders, $debug_mode, $log);
        
        // 3. Zurück zu JSON konvertieren und speichern
        $modified_data = wp_json_encode($modified_array);
        
        if (json_last_error() !== JSON_ERROR_NONE) {
            $log[] = "FEHLER: Konnte Elementor-Daten nicht zurück zu JSON konvertieren: " . json_last_error_msg();
            return false;
        }
        
        if ($debug_mode) {
            $log[] = "DEBUG: Elementor-Daten mit ersetzten Platzhaltern werden gespeichert";
        }
        
        // 4. In die Datenbank schreiben - mit wp_slash, um korrekte Escaping für die DB zu gewährleisten
        update_post_meta($post_id, '_elementor_data', wp_slash($modified_data));
        
        // 5. Kopiere wichtige Elementor-Metadaten
        $this->copy_elementor_template_meta($template_id, $post_id);
        
        // 6. Elementor-Cache leeren
        $this->clear_elementor_cache($post_id, $debug_mode, $log);
        
        return true;
    }
    
    /**
     * Kopiert wichtige Elementor-Metadaten vom Template zum Ziel-Post
     */
    private function copy_elementor_template_meta($template_id, $post_id) {
        // Kopiere den Template-Typ
        $template_type = get_post_meta($template_id, '_elementor_template_type', true);
        if (!empty($template_type)) {
            update_post_meta($post_id, '_elementor_template_type', $template_type);
        }
        
        // Kopiere Elementor-Version
        $elementor_version = get_post_meta($template_id, '_elementor_version', true);
        if (!empty($elementor_version)) {
            update_post_meta($post_id, '_elementor_version', $elementor_version);
        }
        
        // Setze wichtige Elementor-Flags
        update_post_meta($post_id, '_elementor_edit_mode', 'builder');
        
        // Kopiere Page Settings falls vorhanden
        $page_settings = get_post_meta($template_id, '_elementor_page_settings', true);
        if (!empty($page_settings)) {
            update_post_meta($post_id, '_elementor_page_settings', $page_settings);
        }
    }
    
    /**
     * Leert den Elementor-Cache für den angegebenen Post
     */
    private function clear_elementor_cache($post_id, $debug_mode, &$log) {
        if (class_exists('\Elementor\Plugin')) {
            try {
                // Sicherstellen, dass die Plugin-Instanz existiert
                $elementor = \Elementor\Plugin::instance();
                
                if ($elementor) {
                    // Cache für diesen Post leeren
                    if (method_exists($elementor, 'files_manager') && is_object($elementor->files_manager)) {
                        $elementor->files_manager->clear_cache();
                    }
                    
                    if (method_exists($elementor, 'posts_css_manager') && is_object($elementor->posts_css_manager)) {
                        $method = 'delete_post_css';
                        if (method_exists($elementor->posts_css_manager, $method)) {
                            $elementor->posts_css_manager->$method($post_id);
                        } elseif (method_exists($elementor->posts_css_manager, 'clear_cache')) {
                            $elementor->posts_css_manager->clear_cache($post_id);
                        }
                    }
                    
                    // Löschen Sie den CSS-Datei-Cache, falls vorhanden
                    $css_file_key = "_elementor_css";
                    delete_post_meta($post_id, $css_file_key);
                    delete_post_meta($post_id, "_elementor_inline_css");
                    
                    // CSS neu generieren
                    if (class_exists('\Elementor\Core\Files\CSS\Post')) {
                        $css_file = new \Elementor\Core\Files\CSS\Post($post_id);
                        $css_file->update();
                    }
                    
                    if ($debug_mode) {
                        $log[] = "DEBUG: Elementor-Cache für Post ID $post_id geleert";
                    }
                } else {
                    if ($debug_mode) {
                        $log[] = "DEBUG: Elementor Plugin-Instanz nicht gefunden";
                    }
                }
            } catch (Exception $e) {
                if ($debug_mode) {
                    $log[] = "DEBUG: Fehler beim Leeren des Elementor-Cache: " . $e->getMessage();
                }
            }
        } else {
            if ($debug_mode) {
                $log[] = "DEBUG: Elementor Plugin-Klasse nicht gefunden";
            }
        }
    }
    
    /**
     * Ersetzt Platzhalter in einem Array rekursiv
     */
    private function replace_placeholders_in_array($array, $placeholders, $debug_mode, &$log) {
        foreach ($array as $key => $value) {
            if (is_array($value)) {
                // Rekursiv für verschachtelte Arrays
                $array[$key] = $this->replace_placeholders_in_array($value, $placeholders, $debug_mode, $log);
            } elseif (is_string($value)) {
                // Ersetze Platzhalter in String-Werten
                foreach ($placeholders as $placeholder_key => $placeholder_value) {
                    // Suche nach {{placeholder}} in String
                    if (strpos($value, '{{' . $placeholder_key . '}}') !== false) {
                        // Ersetze den Platzhalter mit dem Wert
                        $array[$key] = str_replace('{{' . $placeholder_key . '}}', $placeholder_value, $value);
                        
                        if ($debug_mode) {
                            $log[] = "DEBUG: Platzhalter '{{" . $placeholder_key . "}}' in einem Elementor-Element ersetzt";
                        }
                    }
                }
            }
        }
        
        return $array;
    }
    
    /**
     * Übertrage alle Elementor-Metadaten von einem Template zu einer importierten Seite
     */
    private function transfer_elementor_meta($template_id, $post_id, $debug_mode, &$log) {
        // Liste der Elementor-Metadaten, die übertragen werden sollen
        $meta_keys = array(
            '_elementor_css',
            '_elementor_controls_usage',
            '_elementor_version',
            '_elementor_page_assets',
            '_elementor_page_settings',
            '_elementor_template_type',
            '_elementor_element_order',
            '_elementor_generative_settings',
        );
        
        foreach ($meta_keys as $meta_key) {
            $meta_value = get_post_meta($template_id, $meta_key, true);
            if (!empty($meta_value)) {
                update_post_meta($post_id, $meta_key, $meta_value);
                if ($debug_mode) {
                    $log[] = "DEBUG: Template-Meta übertragen: $meta_key";
                }
            }
        }
        
        // Template-spezifische Daten anpassen
        $elements_data = get_post_meta($post_id, '_elementor_data', true);
        if (!empty($elements_data) && is_string($elements_data)) {
            // Elementor-Element-IDs aktualisieren
            $elements_data = preg_replace_callback('/"id":"[^"]*"/', function($matches) {
                return '"id":"' . uniqid() . '"';
            }, $elements_data);
            
            update_post_meta($post_id, '_elementor_data', $elements_data);
            if ($debug_mode) {
                $log[] = "DEBUG: Elementor-Element-IDs aktualisiert";
            }
        }
        
        return true;
    }
    
    // Verarbeitet Bilder im Content und importiert sie
    private function process_content_images($content, $post_id, $debug_mode = false, &$log = array()) {
        // Suche nach allen Bildern im Content mit robusteren Regex
        preg_match_all('/<img[^>]+src=(["\'])([^"\']+)\\1[^>]*>/i', $content, $matches);
        
        if (empty($matches[2])) {
            return $content;
        }
        
        $image_urls = array_unique($matches[2]);
        
        foreach ($image_urls as $key => $image_url) {
            // Bereinige und validiere die URL
            $cleaned_url = $this->clean_image_url($image_url);
            
            if (!$cleaned_url) {
                if ($debug_mode) {
                    $log[] = "DEBUG: Ungültige Bild-URL übersprungen: " . substr($image_url, 0, 100);
                }
                continue;
            }
            
            // Ignoriere Data-URLs oder lokale Bilder, die bereits auf der Seite vorhanden sind
            if (strpos($cleaned_url, 'data:') === 0 || strpos($cleaned_url, site_url()) === 0) {
                continue;
            }
            
            $attachment_id = $this->get_attachment_id_from_url($cleaned_url);
            
            if (!$attachment_id) {
                // Bild herunterladen
                $attachment_id = $this->download_image($cleaned_url, $post_id);
                if ($debug_mode && $attachment_id) {
                    $log[] = "DEBUG: Bild aus dem Content heruntergeladen: " . $cleaned_url;
                    $log[] = "DEBUG: Originale URL war: " . $image_url;
                }
            }
            
            if ($attachment_id) {
                // Hole URL des importierten Bildes
                $new_image_url = wp_get_attachment_url($attachment_id);
                
                // Ersetze die URL im Content - mit Anführungszeichen, um falsche Treffer zu vermeiden
                $content = str_replace('src="' . $image_url . '"', 'src="' . $new_image_url . '"', $content);
                $content = str_replace("src='" . $image_url . "'", "src='" . $new_image_url . "'", $content);
            }
        }
        
        return $content;
    }
    
    // Holt alle verfügbaren Elementor-Templates
    private function get_elementor_templates() {
        $templates = array();
        
        $args = array(
            'post_type' => 'elementor_library',
            'posts_per_page' => -1,
            'post_status' => 'publish'
        );
        
        $query = new WP_Query($args);
        
        if ($query->have_posts()) {
            while ($query->have_posts()) {
                $query->the_post();
                $template_id = get_the_ID();
                $template_type = get_post_meta($template_id, '_elementor_template_type', true);
                
                $templates[] = array(
                    'id' => $template_id,
                    'title' => get_the_title(),
                    'type' => $template_type
                );
            }
            wp_reset_postdata();
        }
        
        return $templates;
    }
    
    // Bereitet den Content für JSON-Einbettung vor
    private function prepare_content_for_json($content) {
        // Entferne unsichere oder problematische Zeichen für JSON
        $content = preg_replace('/[\x00-\x1F\x7F]/u', '', $content);
        
        // WordPress-Funktionen für Content-Formatierung
        $content = wpautop($content);
        
        // Anführungszeichen für JSON escapen - aber mit Vorsicht
        $content = addslashes($content);
        
        return $content;
    }
    
    // Setzt das Featured Image
    private function set_featured_image($post_id, $image_url) {
        // URL validieren
        if (!filter_var($image_url, FILTER_VALIDATE_URL)) {
            return false;
        }
        
        // Prüfe, ob das Bild bereits in der Mediathek ist
        $attachment_id = $this->get_attachment_id_from_url($image_url);
        
        if (!$attachment_id) {
            // Bild herunterladen
            $attachment_id = $this->download_image($image_url, $post_id);
        }
        
        if ($attachment_id) {
            set_post_thumbnail($post_id, $attachment_id);
            return true;
        }
        
        return false;
    }
    
    // Findet ein Attachment anhand der URL
    private function get_attachment_id_from_url($url) {
        global $wpdb;
        
        // Prüfe auf leere URL
        if (empty($url)) {
            return 0;
        }
        
        // Bereinige URL
        $url = preg_replace('/\?.*/', '', $url);
        
        // Versuche direkte URL-Übereinstimmung - mit korrektem Platzhalter %s
        $attachment = $wpdb->get_col($wpdb->prepare("SELECT ID FROM $wpdb->posts WHERE guid = %s", $url));
        
        if (!empty($attachment)) {
            return $attachment[0];
        }
        
        // Versuche anhand des Dateinamens - mit korrektem LIKE-Platzhalter
        $filename = basename(parse_url($url, PHP_URL_PATH));
        $sql = $wpdb->prepare("SELECT post_id FROM $wpdb->postmeta WHERE meta_key='_wp_attached_file' AND meta_value LIKE %s", '%' . $wpdb->esc_like($filename));
        $attachment = $wpdb->get_col($sql);
        
        if (!empty($attachment)) {
            return $attachment[0];
        }
        
        return 0;
    }
    
    // Lädt ein Bild herunter und erstellt ein Attachment
    private function download_image($url, $post_id) {
        // Prüfen der URL
        if (empty($url)) {
            return 0;
        }
        
        // Lade die benötigten WordPress-Funktionen
        require_once(ABSPATH . 'wp-admin/includes/file.php');
        require_once(ABSPATH . 'wp-admin/includes/media.php');
        require_once(ABSPATH . 'wp-admin/includes/image.php');
        
        // Lade Datei herunter
        $temp_file = download_url($url);
        
        if (is_wp_error($temp_file)) {
            return 0;
        }
        
        // Bereite das Datei-Array vor
        $file_array = array(
            'name' => basename($url),
            'tmp_name' => $temp_file
        );
        
        // Erstelle Anhang
        $attachment_id = media_handle_sideload($file_array, $post_id);
        
        // Lösche temp-Datei
        if (is_file($temp_file)) {
            @unlink($temp_file);
        }
        
        if (is_wp_error($attachment_id)) {
            return 0;
        }
        
        return $attachment_id;
    }
    
    // Setzt SEO-Daten (Yoast oder Rank Math)
    private function set_seo_data($post_id, $data) {
        // Yoast SEO
        if (defined('WPSEO_VERSION')) {
            if (isset($data['Meta Title'])) {
                update_post_meta($post_id, '_yoast_wpseo_title', $data['Meta Title']);
            }
            if (isset($data['Meta Description'])) {
                update_post_meta($post_id, '_yoast_wpseo_metadesc', $data['Meta Description']);
            }
            if (isset($data['Meta Keywords'])) {
                update_post_meta($post_id, '_yoast_wpseo_focuskw', $data['Meta Keywords']);
            }
        } 
        // Rank Math
        elseif (defined('RANK_MATH_VERSION')) {
            if (isset($data['Meta Title'])) {
                update_post_meta($post_id, 'rank_math_title', $data['Meta Title']);
            }
            if (isset($data['Meta Description'])) {
                update_post_meta($post_id, 'rank_math_description', $data['Meta Description']);
            }
            if (isset($data['Meta Keywords'])) {
                update_post_meta($post_id, 'rank_math_focus_keyword', $data['Meta Keywords']);
            }
        }
    }
}

// Plugin initialisieren
add_action('plugins_loaded', function() {
    new Enhanced_Template_Importer();
});