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

function easy_gpt_comments_page() {
    global $wpdb;
    $table_name = $wpdb->prefix . 'easy_gpt_moderation_log';

    // Verificar si la licencia es válida
    $license_status = get_option('easy_gpt_license_status');
    $license_expires = get_option('easy_gpt_license_expires');
    $is_license_valid = $license_status === 'valid' && new DateTime($license_expires) > new DateTime();

    echo '<div class="wrap">';
    echo '<h1>' . esc_html__('Comments Moderation & Replies', 'easy-gpt-for-wp') . '</h1>';

    if (!$is_license_valid) {
        echo '<div class="notice notice-error"><p><strong>' . esc_html__('⚠️ Your license is invalid or has expired. Comment moderation and auto-replies are disabled until you renew the license.', 'easy-gpt-for-wp') . '</strong></p></div>';
        //error_log("easy_gpt_comments_page: Invalid or expired license, displaying notice.");
    }

    $moderated_count = $wpdb->get_var("SELECT COUNT(*) FROM $table_name");
    $replied_count = $wpdb->get_var("SELECT COUNT(*) FROM $table_name WHERE reply_content IS NOT NULL");
    $last_moderation_date = $wpdb->get_var("SELECT MAX(date_moderated) FROM $table_name");
    $last_reply_date = $wpdb->get_var("SELECT MAX(date_moderated) FROM $table_name WHERE reply_content IS NOT NULL");

    echo '<h2>' . esc_html__('📊 Statistics', 'easy-gpt-for-wp') . '</h2>';
    echo '<div class="easy-gpt-stats">';

    $stats = [
        __('Total Comments Moderated', 'easy-gpt-for-wp') => $moderated_count,
        __('Total Auto-Replies', 'easy-gpt-for-wp') => $replied_count,
        __('Last Moderation Date', 'easy-gpt-for-wp') => $last_moderation_date ?? __('N/A', 'easy-gpt-for-wp'),
        __('Last Reply Date', 'easy-gpt-for-wp') => $last_reply_date ?? __('N/A', 'easy-gpt-for-wp')
    ];

    foreach ($stats as $label => $value) {
        echo '<div class="easy-gpt-stats-card">
            <h3>' . esc_html($label) . '</h3>
            <p>' . esc_html($value) . '</p>
        </div>';
    }

    echo '</div>';

    echo '<h2>' . esc_html__('📝 Recent Moderated/Responded Comments', 'easy-gpt-for-wp') . '</h2>';
    echo '<table class="widefat fixed striped easy-gpt-comments-table">
        <thead>
            <tr>
                <th>' . esc_html__('Date', 'easy-gpt-for-wp') . '</th>
                <th>' . esc_html__('Comment', 'easy-gpt-for-wp') . '</th>
                <th>' . esc_html__('Action Taken', 'easy-gpt-for-wp') . '</th>
                <th>' . esc_html__('Reply (if any)', 'easy-gpt-for-wp') . '</th>
                <th>' . esc_html__('Link', 'easy-gpt-for-wp') . '</th>
            </tr>
        </thead>
        <tbody>';

    $items_per_page = 10;
    $current_page = max(1, intval($_GET['paged'] ?? 1));
    $offset = ($current_page - 1) * $items_per_page;
    $total_items = $wpdb->get_var("SELECT COUNT(*) FROM $table_name");
    $total_pages = ceil($total_items / $items_per_page);

    $recent_comments = $wpdb->get_results(
        $wpdb->prepare("SELECT * FROM $table_name ORDER BY date_moderated DESC LIMIT %d OFFSET %d", $items_per_page, $offset)
    );

    if ($recent_comments) {
        foreach ($recent_comments as $comment) {
            $comment_link = ($comment->comment_id && get_comment($comment->comment_id)) 
                ? get_comment_link($comment->comment_id) 
                : esc_html__('Not available', 'easy-gpt-for-wp');
            echo '<tr>
                <td>' . esc_html($comment->date_moderated) . '</td>
                <td>' . esc_html($comment->comment_content) . '</td>
                <td>' . esc_html($comment->action_taken) . '</td>
                <td>' . esc_html($comment->reply_content ?? __('N/A', 'easy-gpt-for-wp')) . '</td>
                <td><a href="' . esc_url($comment_link) . '" target="_blank">' . esc_html__('View Comment', 'easy-gpt-for-wp') . '</a></td>
            </tr>';
        }
    } else {
        echo '<tr><td colspan="5">' . esc_html__('No moderated comments found.', 'easy-gpt-for-wp') . '</td></tr>';
    }

    echo '</tbody>
    </table>';

    echo '<div class="easy-gpt-pagination">';
    echo paginate_links([
        'base' => add_query_arg('paged', '%#%'),
        'format' => '',
        'current' => $current_page,
        'total' => $total_pages,
        'prev_text' => esc_html__('&laquo; Prev', 'easy-gpt-for-wp'),
        'next_text' => esc_html__('Next &raquo;', 'easy-gpt-for-wp'),
        'type' => 'plain',
        'before_page_number' => '<span>',
        'after_page_number' => '</span>',
    ]);
    echo '</div>';

    echo '</div>';
}
add_action('admin_enqueue_scripts', 'easy_gpt_comments_styles');

function easy_gpt_comments_styles($hook) {
    if ($hook != 'easy-gpt_page_easy-gpt-comments') {
        return;
    }

    wp_enqueue_style(
        'easy-gpt-comments-style',
        plugin_dir_url(__FILE__) . '../styles/comments-style.css',
        [],
        '1.0',
        'all'
    );
}

// Programar Cron Job al activar el plugin
register_activation_hook(__FILE__, 'easy_gpt_schedule_moderation_cron');
function easy_gpt_schedule_moderation_cron() {
    if (!wp_next_scheduled('easy_gpt_moderation_cron')) {
        wp_schedule_event(time(), 'hourly', 'easy_gpt_moderation_cron');
        //error_log("easy_gpt_schedule_moderation_cron: Cron job programado para moderación cada hora.");
    } else {
        //error_log("easy_gpt_schedule_moderation_cron: Cron job ya estaba programado.");
    }
}

// Limpiar Cron Job al desactivar el plugin
register_deactivation_hook(__FILE__, 'easy_gpt_clear_moderation_cron');
function easy_gpt_clear_moderation_cron() {
    wp_clear_scheduled_hook('easy_gpt_moderation_cron');
    //error_log("easy_gpt_clear_moderation_cron: Cron job limpiado al desactivar el plugin.");
}

register_activation_hook(__FILE__, 'easy_gpt_create_moderation_log_table');
function easy_gpt_create_moderation_log_table() {
    global $wpdb;
    $table_name = $wpdb->prefix . 'easy_gpt_moderation_log';

    $charset_collate = $wpdb->get_charset_collate();

    $sql = "CREATE TABLE IF NOT EXISTS $table_name (
        id mediumint(9) NOT NULL AUTO_INCREMENT,
        comment_id bigint(20) NOT NULL,
        comment_content text NOT NULL,
        action_taken varchar(20) NOT NULL,
        reply_content text DEFAULT NULL,
        date_moderated datetime DEFAULT CURRENT_TIMESTAMP NOT NULL,
        PRIMARY KEY  (id)
    ) $charset_collate;";

    require_once(ABSPATH . 'wp-admin/includes/upgrade.php');
    dbDelta($sql);
    //error_log("easy_gpt_create_moderation_log_table: Tabla '$table_name' creada o verificada.");
}

// Hook para el Cron Job
add_action('easy_gpt_moderation_cron', 'easy_gpt_moderate_old_comments');

// Función para moderar comentarios antiguos
function easy_gpt_moderate_old_comments() {
    $options = get_option('easy_gpt_options');

    // Verificar si la licencia es válida antes de proceder
    $license_status = get_option('easy_gpt_license_status');
    $license_expires = get_option('easy_gpt_license_expires');
    $is_license_valid = $license_status === 'valid' && new DateTime($license_expires) > new DateTime();

    if (!$is_license_valid) {
        //error_log("easy_gpt_moderate_old_comments: Licencia inválida o expirada, saliendo.");
        return;
    }
	
    if (empty($options['easy_gpt_enable_moderation'])) {
        //error_log("easy_gpt_moderate_old_comments: Moderación deshabilitada en opciones, saliendo.");
        return;
    }
    
    global $wpdb;
    $table_name = $wpdb->prefix . 'easy_gpt_moderation_log';

    //error_log("easy_gpt_moderate_old_comments: Iniciando moderación de comentarios antiguos.");

    $args = [
        'status' => 'hold',
        'number' => 10,
    ];

	$comments = array_filter(get_comments($args), function($comment) {
		$post_type = get_post_type($comment->comment_post_ID);
		return $post_type === 'post' || $post_type === 'page';
	});
    //error_log("easy_gpt_moderate_old_comments: Encontrados " . count($comments) . " comentarios en espera.");

    foreach ($comments as $comment) {
        //error_log("easy_gpt_moderate_old_comments: Moderando comentario ID " . $comment->comment_ID);
        
        // Para comentarios antiguos, incluir información adicional
        $full_content = "Nombre: " . ($comment->comment_author ?? '') . "\n";
        $full_content .= "Email: " . ($comment->comment_author_email ?? '') . "\n";
        $full_content .= "Sitio Web: " . ($comment->comment_author_url ?? '') . "\n";
        $full_content .= "Comentario: " . $comment->comment_content;

        $result = easy_gpt_moderate_comment($comment->comment_ID, $full_content);

        // Actualizar el estado en la tabla nativa
        if ($result === true) {
            wp_set_comment_status($comment->comment_ID, 'approve');
            //error_log("easy_gpt_moderate_old_comments: Comentario ID " . $comment->comment_ID . " aprobado.");
        } elseif ($result === 'spam') {
            wp_spam_comment($comment->comment_ID);
            //error_log("easy_gpt_moderate_old_comments: Comentario ID " . $comment->comment_ID . " marcado como spam.");
        } elseif ($result === 'pending') {
            //error_log("easy_gpt_moderate_old_comments: Comentario ID " . $comment->comment_ID . " dejado en pendiente.");
        }

        $inserted = $wpdb->insert(
            $table_name,
            [
                'comment_id'      => $comment->comment_ID,
                'comment_content' => $comment->comment_content,
                'action_taken'    => ($result === true) ? 'approve' : $result,
                'date_moderated'  => current_time('mysql')
            ]
        );
        if ($inserted === false) {
            //error_log("easy_gpt_moderate_old_comments: Error al insertar log para comentario ID " . $comment->comment_ID);
        } else {
            //error_log("easy_gpt_moderate_old_comments: Log insertado para comentario ID " . $comment->comment_ID);
        }
    }
}



// Hook para moderar comentarios nuevos inmediatamente
add_filter('pre_comment_approved', 'easy_gpt_auto_moderate_new_comment', 10, 2);

function easy_gpt_auto_moderate_new_comment($approved, $commentdata) {
    $options = get_option('easy_gpt_options');

    // Verificar si la licencia es válida antes de proceder
    $license_status = get_option('easy_gpt_license_status');
    $license_expires = get_option('easy_gpt_license_expires');
    $is_license_valid = $license_status === 'valid' && new DateTime($license_expires) > new DateTime();

    if (!$is_license_valid) {
        //error_log("easy_gpt_moderate_old_comments: Licencia inválida o expirada, saliendo.");
        return $approved;
    }
	
    // Si la moderación está activada, dejamos el comentario en pendiente para que el cron lo procese
    if (!empty($options['easy_gpt_enable_moderation'])) {
        //error_log("easy_gpt_auto_moderate_new_comment: Moderación activada. Comentario nuevo recibido; dejándolo en pendiente para moderación posterior.");
        return 0;
    }
    // Si la moderación no está activada, devolvemos el valor original para que WordPress lo maneje normalmente
    return $approved;
}



// Función principal de moderación
function easy_gpt_moderate_comment($comment_id, $comment_content) {
    //error_log("easy_gpt_moderate_comment: Iniciando moderación para comentario ID " . ($comment_id ? $comment_id : 'nuevo'));
    $options = get_option('easy_gpt_options');

    if (empty($options['easy_gpt_enable_moderation'])) {
        //error_log("easy_gpt_moderate_comment: Moderación deshabilitada en opciones.");
        return true;
    }

    $prohibited_words = array_map('trim', explode(',', $options['easy_gpt_prohibited_words']));
    $prompt = $options['easy_gpt_moderation_prompt'] ?? '';

    foreach ($prohibited_words as $word) {
        if (stripos($comment_content, $word) !== false) {
            //error_log("easy_gpt_moderate_comment: Palabra prohibida encontrada: $word en comentario ID " . ($comment_id ? $comment_id : 'nuevo'));
            if ($comment_id) {
                wp_spam_comment($comment_id);
            }
            return 'spam';
        }
    }

    $response = easy_gpt_moderate_with_ai($comment_content, $prompt);
    //error_log("easy_gpt_moderate_comment: Respuesta de AI: $response");

    if ($response === 'spam' && $comment_id) {
        wp_spam_comment($comment_id);
        return 'spam';
    } elseif ($response === 'pending') {
        return 'pending';
    }

    return true;
}

// Función para moderar usando la API de AI
function easy_gpt_moderate_with_ai($content, $custom_prompt = '') {
    //error_log("easy_gpt_moderate_with_ai: Enviando contenido a la API para moderación usando easy_gpt_call_openai_api.");
    $options = get_option('easy_gpt_options');

	$model = $options['easy_gpt_moderation_model'] ?? 'gpt-4o';

	// Elegir API key en función del modelo
	if (strpos($model, 'gpt-') === 0 || strpos($model, 'text-') === 0) {
		$api_key = $options['easy_gpt_api_key'] ?? '';
	} elseif (strpos($model, 'gemini-') === 0) {
		$api_key = $options['easy_gpt_google_api_key'] ?? '';
	} elseif (strpos($model, 'deepseek-') === 0) {
		$api_key = $options['easy_gpt_deepseek_api_key'] ?? '';
	} else {
		$api_key = $options['easy_gpt_api_key'] ?? '';
	}

    $temperature = 0; // O el valor que consideres apropiado

    // Prompt para moderación
    $prompt = $custom_prompt ?: "Evalúa el siguiente comentario y sus datos asociados (nombre, email y sitio web) para determinar si es spam, ofensivo o inapropiado. Si es un comentario con enlace sería spam. Si alguno de estos campos sugiere spam o contiene lenguaje ofensivo/inapropiado, responde con 'spam'. De lo contrario, responde con 'approve': \"$content\". Do not add explanations, comments, preambles, markdown syntax, triple backticks, or any extra notes.";


    try {
        // Llamamos a la función que ya maneja el endpoint adecuado según el modelo
        $result = easy_gpt_call_openai_api($prompt, $model, $temperature, $api_key, 0);
        $text_response = $result['text'];
        //error_log("easy_gpt_moderate_with_ai: Respuesta de AI recibida: $text_response");

        // Devolvemos 'spam' si se detecta la palabra, o 'approve' en caso contrario
        return (strpos(strtolower($text_response), 'spam') !== false) ? 'spam' : 'approve';
    } catch (Exception $e) {
        //error_log("easy_gpt_moderate_with_ai: Error al llamar a la API: " . $e->getMessage());
        return 'pending';
    }
}


register_activation_hook(__FILE__, 'easy_gpt_schedule_auto_reply_cron');
function easy_gpt_schedule_auto_reply_cron() {
    if ( ! wp_next_scheduled( 'easy_gpt_auto_reply_cron' ) ) {
        wp_schedule_event( time(), 'hourly', 'easy_gpt_auto_reply_cron' );
        //error_log("easy_gpt_schedule_auto_reply_cron: Cron job programado para respuestas automáticas cada hora.");
    } else {
        //error_log("easy_gpt_schedule_auto_reply_cron: Cron job ya estaba programado.");
    }
}

// Limpiar Cron Job al desactivar el plugin
register_deactivation_hook(__FILE__, 'easy_gpt_clear_auto_reply_cron');
function easy_gpt_clear_auto_reply_cron() {
    wp_clear_scheduled_hook( 'easy_gpt_auto_reply_cron' );
    //error_log("easy_gpt_clear_auto_reply_cron: Cron job limpiado al desactivar el plugin.");
}

add_action('easy_gpt_auto_reply_cron', 'easy_gpt_auto_reply_comments');

function easy_gpt_auto_reply_comments() {
    global $wpdb;
    $options = get_option('easy_gpt_options');

	// Verificar si la licencia es válida antes de proceder
    $license_status = get_option('easy_gpt_license_status');
    $license_expires = get_option('easy_gpt_license_expires');
    $is_license_valid = $license_status === 'valid' && new DateTime($license_expires) > new DateTime();

    if (!$is_license_valid) {
        //error_log("easy_gpt_auto_reply_comments: Licencia inválida o expirada, saliendo.");
        return;
    }
    
    // Verificar si las respuestas automáticas están habilitadas
    if ( empty($options['easy_gpt_enable_replies']) ) {
        //error_log("easy_gpt_auto_reply_comments: Respuestas automáticas deshabilitadas, saliendo.");
        return;
    }
    
    // Configuración: Daily Reply Limit y Reply Delay (minutes)
    $daily_limit = isset($options['easy_gpt_daily_reply_limit']) ? intval($options['easy_gpt_daily_reply_limit']) : 0;
    $reply_delay = isset($options['easy_gpt_reply_delay']) ? intval($options['easy_gpt_reply_delay']) : 10; // Por defecto, 10 minutos

    // Configuración: Límite de tiempo (en días) para procesar comentarios (tiempo máximo que puede tener un comentario)
    $time_limit_days = isset($options['easy_gpt_reply_time_limit']) ? intval($options['easy_gpt_reply_time_limit']) : 7; // Por defecto, 7 días
    $min_date = date('Y-m-d H:i:s', strtotime("-{$time_limit_days} days"));

    // Si se ha configurado un límite diario, contar las respuestas generadas hoy (en la tabla de comentarios)
    if ($daily_limit > 0) {
        $today = date('Y-m-d');
        $default_author_id = !empty($options['easy_gpt_reply_default_author']) ? intval($options['easy_gpt_reply_default_author']) : 0;
        $replies_today = $wpdb->get_var(
			$wpdb->prepare(
				"SELECT COUNT(*) FROM {$wpdb->prefix}easy_gpt_moderation_log WHERE reply_content IS NOT NULL AND date_moderated >= %s",
				$today . ' 00:00:00'
			)
		);
        //error_log("easy_gpt_auto_reply_comments: Respuestas hoy: $replies_today, Límite: $daily_limit");
        if ($replies_today >= $daily_limit) {
            //error_log("easy_gpt_auto_reply_comments: Límite diario de respuestas alcanzado ($replies_today/$daily_limit), saliendo.");
            return;
        }
    }
    
    // Consulta: comentarios aprobados publicados desde $min_date,
    // que NO fueron escritos por el autor predeterminado y que no tienen respuesta automática.
    $default_author_id = !empty($options['easy_gpt_reply_default_author']) ? intval($options['easy_gpt_reply_default_author']) : 0;
    $query = $wpdb->prepare(
        "SELECT c.*
         FROM {$wpdb->prefix}comments AS c
         LEFT JOIN {$wpdb->prefix}comments AS r 
            ON r.comment_parent = c.comment_ID AND r.user_id = %d
         WHERE c.comment_approved = 1 
           AND c.comment_date >= %s
           AND c.user_id <> %d
           AND r.comment_ID IS NULL",
        $default_author_id,
        $min_date,
        $default_author_id
    );
    $comments = $wpdb->get_results($query);

	$comments = array_filter($comments, function($comment) {
		return get_post_type($comment->comment_post_ID) === 'post';
	});
    //error_log("easy_gpt_auto_reply_comments: Se encontraron " . count($comments) . " comentarios sin respuesta desde $min_date.");
    
    foreach ($comments as $comment) {
        //error_log("Procesando comentario ID: {$comment->comment_ID} (Fecha: {$comment->comment_date})");
        
        // Verificar si se cumplió el delay desde la fecha del comentario
        $comment_time = strtotime($comment->comment_date);
        $current_time = current_time('timestamp');
        if (($comment_time + ($reply_delay * 60)) > $current_time) {
            //error_log("easy_gpt_auto_reply_comments: Comentario ID {$comment->comment_ID} no ha cumplido el delay de {$reply_delay} minutos.");
            continue;
        }
        
        // Construir el prompt para la respuesta
		$reply_prompt = "Genera una respuesta natural a un comentario realizado por " . $comment->comment_author . ". ";

		// Incluir instrucciones personalizadas si están definidas
		if (!empty($options['easy_gpt_reply_prompt'])) {
			$reply_prompt .= "Ten en cuenta lo siguiente: " . $options['easy_gpt_reply_prompt'] . ". ";
		}

		


		// Instrucción para evitar firmas o menciones de 'tu nombre'
		$reply_prompt .= "No incluyas firma. No uses **, si tiense que usarlo, por ejemplo en una enumeración usa etiquetas HTML como <b>. Solo devuelve la respuesta al comentario. Do not add explanations, comments, preambles, markdown syntax, triple backticks, or any extra notes.";
		

        
        // Incluir la instrucción de idioma según la opción configurada
        if (!empty($options['easy_gpt_reply_in_comment_language']) && $options['easy_gpt_reply_in_comment_language'] == '1') {
            $reply_prompt .= "\nResponde en el idioma del comentario.";
        } else {
            $reply_language = !empty($options['easy_gpt_reply_language']) ? $options['easy_gpt_reply_language'] : 'es';
            $reply_prompt .= "\nResponde en el siguiente idioma: " . $reply_language;
        }
        
        // Incluir instrucciones de tono y estilo si están configuradas
        if (!empty($options['easy_gpt_reply_tone'])) {
            $reply_prompt .= "\nTone: " . $options['easy_gpt_reply_tone'];
        }
        if (!empty($options['easy_gpt_reply_style'])) {
            $reply_prompt .= "\nStyle: " . $options['easy_gpt_reply_style'];
        }
		
		// Incluir el comentario original
		
		$reply_prompt .= "El comentario a responder es: " . $comment->comment_content . ". ";
        
        //error_log("easy_gpt_auto_reply_comments: Prompt para comentario ID {$comment->comment_ID}: $reply_prompt");
        
        // Determinar el modelo y la temperatura para la respuesta
        $reply_model = !empty($options['easy_gpt_reply_model']) ? $options['easy_gpt_reply_model'] : $options['easy_gpt_moderation_model'];
        $reply_temperature = isset($options['easy_gpt_reply_temperature']) ? floatval($options['easy_gpt_reply_temperature']) : 0.7;
        
        try {
			$model = $options['easy_gpt_reply_model'] ?? 'gpt-4o';

			// Elegir API key en función del modelo
			if (strpos($model, 'gpt-') === 0 || strpos($model, 'text-') === 0) {
				$api_key = $options['easy_gpt_api_key'] ?? '';
			} elseif (strpos($model, 'gemini-') === 0) {
				$api_key = $options['easy_gpt_google_api_key'] ?? '';
			} elseif (strpos($model, 'deepseek-') === 0) {
				$api_key = $options['easy_gpt_deepseek_api_key'] ?? '';
			} else {
				$api_key = $options['easy_gpt_api_key'] ?? '';
			}
			
            $result = easy_gpt_call_openai_api($reply_prompt, $reply_model, $reply_temperature, $api_key, $comment->comment_ID);
            $reply_text = trim($result['text']);
            //error_log("easy_gpt_auto_reply_comments: Respuesta de IA para comentario ID {$comment->comment_ID}: $reply_text");
            
            // Actualizar o insertar el log en la tabla easy_gpt_moderation_log
            $table_name = $wpdb->prefix . 'easy_gpt_moderation_log';
            $existing_log_id = $wpdb->get_var($wpdb->prepare("SELECT id FROM $table_name WHERE comment_id = %d", $comment->comment_ID));
            if ($existing_log_id) {
                $update_result = $wpdb->update(
                    $table_name,
                    [
                        'reply_content' => $reply_text,
                        'date_moderated' => current_time('mysql')
                    ],
                    ['comment_id' => $comment->comment_ID]
                );
                if ($update_result === false) {
                    //error_log("easy_gpt_auto_reply_comments: Error al actualizar log para comentario ID {$comment->comment_ID}");
                } else {
                    //error_log("easy_gpt_auto_reply_comments: Log actualizado para comentario ID {$comment->comment_ID}");
                }
            } else {
                $log_data = array(
                    'comment_id'      => $comment->comment_ID,
                    'comment_content' => $comment->comment_content,
                    'action_taken'    => 'approve',
                    'reply_content'   => $reply_text,
                    'date_moderated'  => current_time('mysql')
                );
                $wpdb->insert($table_name, $log_data);
                if ($wpdb->insert_id) {
                    //error_log("easy_gpt_auto_reply_comments: Log insertado para comentario ID {$comment->comment_ID}");
                } else {
                    //error_log("easy_gpt_auto_reply_comments: Error al insertar log para comentario ID {$comment->comment_ID}");
                }
            }
            
            // Insertar la respuesta como un comentario hijo en WordPress
            if ($comment->comment_ID > 0) {
                if ($default_author_id > 0) {
                    $user_info = get_userdata($default_author_id);
                    $reply_author       = $user_info ? $user_info->display_name : 'Auto Reply';
                    $reply_author_email = $user_info ? $user_info->user_email   : 'noreply@example.com';
                    $reply_user_id      = $default_author_id;
                } else {
                    // Si no se ha definido un autor por defecto, usar el primer administrador encontrado
                    $admins = get_users(array(
                        'role'   => 'Administrator',
                        'number' => 1,
                        'fields' => array('ID', 'display_name', 'user_email')
                    ));
                    if (!empty($admins)) {
                        $admin = $admins[0];
                        $reply_author       = $admin->display_name;
                        $reply_author_email = $admin->user_email;
                        $reply_user_id      = $admin->ID;
                    } else {
                        $reply_author       = 'Auto Reply';
                        $reply_author_email = 'noreply@example.com';
                        $reply_user_id      = 0;
                    }
                }
                
                $reply_data = array(
                    'comment_post_ID'      => $comment->comment_post_ID,
                    'comment_parent'       => $comment->comment_ID,
                    'comment_author'       => $reply_author,
                    'comment_author_email' => $reply_author_email,
                    'comment_content'      => $reply_text,
                    'user_id'              => $reply_user_id,
                    'comment_approved'     => 1,
                );
                $insert_id = wp_insert_comment($reply_data);
                if ($insert_id) {
                    //error_log("easy_gpt_auto_reply_comments: Comentario respuesta insertado con ID $insert_id para comentario ID {$comment->comment_ID}");
                } else {
                    //error_log("easy_gpt_auto_reply_comments: Error al insertar comentario respuesta para comentario ID {$comment->comment_ID}");
                }
            } else {
                //error_log("easy_gpt_auto_reply_comments: Comentario ID {$comment->comment_ID} no tiene ID válido.");
            }
        } catch (Exception $e) {
            //error_log("easy_gpt_auto_reply_comments: Error al generar respuesta para comentario ID {$comment->comment_ID}: " . $e->getMessage());
        }
        
        // Si se tiene un límite diario, recontar las respuestas y detener el procesamiento si se alcanza
        if ($daily_limit > 0) {
            $today = date('Y-m-d');
            $replies_today = $wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->prefix}comments WHERE comment_approved = 1 AND comment_date >= '$today 00:00:00' AND user_id = {$default_author_id}");
            if ($replies_today >= $daily_limit) {
                //error_log("easy_gpt_auto_reply_comments: Límite diario de respuestas alcanzado durante el procesamiento ($replies_today/$daily_limit), deteniendo.");
                break;
            }
        }
    }
}