add_action('bkpc_before_backup_create', 'log_backup_start', 10, 2);

function log_backup_start($backup_type, $options) {
    error_log(sprintf(
        '[Backup] Starting %s backup at %s',
        $backup_type,
        current_time('mysql')
    ));

    // Notify monitoring system
    wp_remote_post('https://monitoring.example.com/backup-started', [
        'body' => [
            'site' => get_site_url(),
            'type' => $backup_type,
            'timestamp' => time()
        ]
    ]);
}

add_action('bkpc_after_backup_create', 'notify_slack_backup_complete', 10, 2);

function notify_slack_backup_complete($backup_uuid, $backup_data) {
    $webhook_url = 'https://hooks.slack.com/services/YOUR/WEBHOOK/URL';

    $message = sprintf(
        ':white_check_mark: Backup completed for %s\n' .
        'Type: %s | Size: %s | Duration: %s seconds',
        get_bloginfo('name'),
        $backup_data['type'],
        size_format($backup_data['size']),
        $backup_data['duration']
    );

    wp_remote_post($webhook_url, [
        'body' => json_encode(['text' => $message]),
        'headers' => ['Content-Type' => 'application/json']
    ]);
}

add_action('bkpc_backup_failed', 'alert_backup_failure', 10, 3);

function alert_backup_failure($backup_uuid, $error_message, $error_data) {
    // Send critical alert to monitoring system
    wp_remote_post('https://monitoring.example.com/alert', [
        'body' => json_encode([
            'severity' => 'critical',
            'service' => 'wordpress_backup',
            'message' => $error_message,
            'site' => get_site_url(),
            'backup_id' => $backup_uuid,
            'context' => $error_data
        ]),
        'headers' => ['Content-Type' => 'application/json']
    ]);

    // Email site administrator
    wp_mail(
        get_option('admin_email'),
        '[CRITICAL] Backup Failed: ' . get_bloginfo('name'),
        sprintf(
            "Backup %s failed with error:\n\n%s\n\nTime: %s",
            $backup_uuid,
            $error_message,
            current_time('mysql')
        )
    );
}

add_action('bkpc_before_restore', 'create_pre_restore_backup', 10, 2);

function create_pre_restore_backup($backup_uuid, $restore_options) {
    // Create safety backup before restore
    if (function_exists('bkpc_create_backup')) {
        $safety_backup = bkpc_create_backup([
            'type' => 'full',
            'metadata' => [
                'purpose' => 'pre_restore_safety',
                'restoring_backup' => $backup_uuid
            ]
        ]);

        error_log('[Backup] Created pre-restore safety backup: ' . $safety_backup['uuid']);
    }
}

add_action('bkpc_after_restore', 'clear_caches_after_restore', 10, 2);

function clear_caches_after_restore($backup_uuid, $restore_summary) {
    // Clear WordPress object cache
    wp_cache_flush();

    // Clear WP Rocket cache if active
    if (function_exists('rocket_clean_domain')) {
        rocket_clean_domain();
    }

    // Clear W3 Total Cache if active
    if (function_exists('w3tc_flush_all')) {
        w3tc_flush_all();
    }

    // Clear Cloudflare cache if configured
    $cf_zone_id = get_option('cloudflare_zone_id');
    $cf_api_key = get_option('cloudflare_api_key');

    if ($cf_zone_id && $cf_api_key) {
        wp_remote_post("https://api.cloudflare.com/client/v4/zones/{$cf_zone_id}/purge_cache", [
            'headers' => [
                'Authorization' => 'Bearer ' . $cf_api_key,
                'Content-Type' => 'application/json'
            ],
            'body' => json_encode(['purge_everything' => true])
        ]);
    }
}

add_action('bkpc_before_cloud_upload', 'scan_backup_before_upload', 10, 3);

function scan_backup_before_upload($backup_uuid, $provider, $local_path) {
    // Scan with ClamAV before uploading
    $output = [];
    $return_var = 0;

    exec("clamscan --no-summary {$local_path}", $output, $return_var);

    if ($return_var !== 0) {
        // Virus detected - abort upload
        error_log('[Security] Virus detected in backup ' . $backup_uuid);
        throw new Exception('Backup failed virus scan');
    }
}

add_action('bkpc_after_cloud_upload', 'log_upload_to_external_db', 10, 4);

function log_upload_to_external_db($backup_uuid, $provider, $remote_path, $upload_duration) {
    global $wpdb;

    // Log to external monitoring database
    $wpdb->insert('backup_audit_log', [
        'site_id' => get_current_blog_id(),
        'site_url' => get_site_url(),
        'backup_id' => $backup_uuid,
        'provider' => $provider,
        'remote_path' => $remote_path,
        'upload_duration' => $upload_duration,
        'timestamp' => current_time('mysql')
    ]);
}

add_filter('bkpc_backup_excluded_files', 'exclude_custom_directories');

function exclude_custom_directories($excluded) {
    // Add custom exclusions
    $custom_exclusions = [
        '/wp-content/cache',
        '/wp-content/temp',
        '/wp-content/uploads/backups',
        '/wp-content/ai-training-data',  // Large AI model files
        '/node_modules',  // Development dependencies
        '/.git'  // Version control
    ];

    return array_merge($excluded, $custom_exclusions);
}

add_filter('bkpc_backup_excluded_tables', 'exclude_temp_tables', 10, 2);

function exclude_temp_tables($excluded_tables, $backup_type) {
    global $wpdb;

    // Exclude analytics tables (can be regenerated)
    $analytics_tables = [
        $wpdb->prefix . 'analytics_cache',
        $wpdb->prefix . 'statistics_temp',
        $wpdb->prefix . 'search_log'
    ];

    return array_merge($excluded_tables, $analytics_tables);
}

add_filter('bkpc_backup_metadata', 'add_custom_backup_metadata');

function add_custom_backup_metadata($metadata) {
    // Add environment information
    $metadata['environment'] = wp_get_environment_type();  // production, staging, development

    // Add theme/plugin versions
    $metadata['active_theme'] = wp_get_theme()->get('Name') . ' ' . wp_get_theme()->get('Version');

    $active_plugins = [];
    foreach (get_option('active_plugins') as $plugin) {
        $plugin_data = get_plugin_data(WP_PLUGIN_DIR . '/' . $plugin);
        $active_plugins[] = $plugin_data['Name'] . ' ' . $plugin_data['Version'];
    }
    $metadata['active_plugins'] = $active_plugins;

    // Add WooCommerce order count if active
    if (class_exists('WooCommerce')) {
        $order_count = wp_count_posts('shop_order');
        $metadata['woocommerce_orders'] = $order_count->publish;
    }

    return $metadata;
}

add_filter('bkpc_schedule_options', 'enforce_backup_policies', 10, 2);

function enforce_backup_policies($options, $schedule_id) {
    // Enforce minimum retention for production
    if (wp_get_environment_type() === 'production') {
        if ($options['retention_days'] < 30) {
            $options['retention_days'] = 30;
            error_log('[Backup] Enforced minimum 30-day retention for production');
        }

        // Require cloud upload for production
        $options['cloud_upload'] = true;
    }

    // Limit backup frequency to prevent server overload
    if ($options['frequency'] === 'hourly' && $options['backup_type'] === 'full') {
        $options['frequency'] = 'every_6_hours';
        error_log('[Backup] Reduced full backup frequency to prevent overload');
    }

    return $options;
}

add_filter('bkpc_notification_email_content', 'customize_backup_email', 10, 2);

function customize_backup_email($content, $backup_data) {
    $content['subject'] = sprintf(
        '[%s] %s Backup %s',
        get_bloginfo('name'),
        ucfirst($backup_data['type']),
        $backup_data['status'] === 'completed' ? 'Completed' : 'Failed'
    );

    $content['message'] = sprintf(
        "Backup Report for %s\n" .
        "================================\n\n" .
        "Status: %s\n" .
        "Type: %s\n" .
        "Size: %s\n" .
        "Duration: %d seconds\n" .
        "Cloud Upload: %s\n" .
        "Timestamp: %s\n\n" .
        "View backup details: %s\n",
        get_bloginfo('name'),
        strtoupper($backup_data['status']),
        $backup_data['type'],
        size_format($backup_data['size']),
        $backup_data['duration'],
        $backup_data['cloud_uploaded'] ? 'Yes' : 'No',
        $backup_data['completed_at'],
        admin_url('admin.php?page=backup-copilot-pro&backup=' . $backup_data['uuid'])
    );

    // Add HTML version
    $content['headers'][] = 'Content-Type: text/html';

    return $content;
}

add_filter('bkpc_cloud_upload_chunk_size', 'optimize_chunk_size', 10, 2);

function optimize_chunk_size($chunk_size, $provider) {
    // Different providers have different optimal chunk sizes
    $optimal_sizes = [
        'dropbox' => 10 * 1024 * 1024,      // 10MB for Dropbox
        'google_drive' => 5 * 1024 * 1024,   // 5MB for Google Drive
        'amazon_s3' => 15 * 1024 * 1024,     // 15MB for S3
        'backblaze' => 100 * 1024 * 1024     // 100MB for Backblaze B2
    ];

    return isset($optimal_sizes[$provider]) ? $optimal_sizes[$provider] : $chunk_size;
}

add_filter('bkpc_retention_policy', 'custom_retention_logic', 10, 2);

function custom_retention_logic($should_delete, $backup_data) {
    // Keep all backups from the first of each month indefinitely
    $backup_date = new DateTime($backup_data['created_at']);
    if ($backup_date->format('d') === '01') {
        return false;  // Don't delete monthly backups
    }

    // Keep backups tagged as "before_major_update" for 1 year
    if (isset($backup_data['metadata']['tag']) &&
        $backup_data['metadata']['tag'] === 'before_major_update') {
        $age_days = (time() - strtotime($backup_data['created_at'])) / DAY_IN_SECONDS;
        return $age_days > 365;  // Delete after 1 year
    }

    // Default retention logic
    return $should_delete;
}

add_filter('bkpc_database_export_query', 'optimize_export_query', 10, 2);

function optimize_export_query($query, $table) {
    // Skip certain columns from large tables
    $optimizations = [
        'wp_posts' => 'SELECT ID, post_author, post_date, post_content, post_title, post_status FROM',
        'wp_comments' => 'SELECT * FROM'  // Exclude spam comments
    ];

    foreach ($optimizations as $table_name => $select) {
        if (strpos($table, $table_name) !== false) {
            // Modify query for this table
            if ($table_name === 'wp_comments') {
                $query .= " WHERE comment_approved != 'spam'";
            }
        }
    }

    return $query;
}

add_action('bkpc_after_cloud_upload', 'verify_backup_externally', 10, 4);

function verify_backup_externally($backup_uuid, $provider, $remote_path, $duration) {
    // Send to external backup verification service
    $verification_service = 'https://backup-verify.example.com/api/verify';

    $backup_info = bkpc_get_backup($backup_uuid);

    wp_remote_post($verification_service, [
        'body' => json_encode([
            'site_id' => get_option('site_verification_id'),
            'backup_id' => $backup_uuid,
            'provider' => $provider,
            'remote_path' => $remote_path,
            'size' => $backup_info['size'],
            'checksum' => $backup_info['checksum'],
            'timestamp' => time()
        ]),
        'headers' => [
            'Content-Type' => 'application/json',
            'Authorization' => 'Bearer ' . get_option('verification_api_key')
        ]
    ]);
}

add_action('bkpc_before_backup_create', 'log_backup_initiator', 10, 2);

function log_backup_initiator($backup_type, $options) {
    if (!current_user_can('manage_options')) {
        return;  // Only log for administrators
    }

    // Log who initiated backup
}

add_action('bkpc_after_backup_create', 'defer_slow_operation', 10, 2);

function defer_slow_operation($backup_uuid, $backup_data) {
    // Schedule slow operation for later rather than blocking
    wp_schedule_single_event(time() + 60, 'process_backup_analytics', [$backup_uuid]);
}

wp_remote_post($url, [
    'blocking' => false,  // Don't wait for response
    'timeout' => 5,
    'body' => $data
]);

add_action('bkpc_before_backup_create', 'debug_backup_hooks', 10, 2);

function debug_backup_hooks($backup_type, $options) {
    if (defined('WP_DEBUG') && WP_DEBUG) {
        error_log('=== Backup Hook Debug ===');
        error_log('Type: ' . $backup_type);
        error_log('Options: ' . print_r($options, true));
        error_log('Current user: ' . wp_get_current_user()->user_login);
        error_log('Memory usage: ' . size_format(memory_get_usage(true)));
        error_log('========================');
    }
}

if (function_exists('bkpc_create_backup')) {
    // Safe to call
}