curl -u username:application_password \
  https://yoursite.com/wp-json/bkpc/v1/backup/list

# Step 1: Get authorization code
https://yoursite.com/oauth/authorize?
  client_id=YOUR_CLIENT_ID&
  redirect_uri=https://app.example.com/callback&
  response_type=code&
  scope=backup:read backup:write

# Step 2: Exchange code for access token
curl -X POST https://yoursite.com/oauth/token \
  -d "grant_type=authorization_code" \
  -d "code=AUTHORIZATION_CODE" \
  -d "client_id=YOUR_CLIENT_ID" \
  -d "client_secret=YOUR_CLIENT_SECRET" \
  -d "redirect_uri=https://app.example.com/callback"

# Step 3: Use access token
curl -H "Authorization: Bearer ACCESS_TOKEN" \
  https://yoursite.com/wp-json/bkpc/v1/backup/list

POST /wp-json/bkpc/v1/backup/create

{
  "type": "full",
  "cloud_upload": true,
  "provider": "dropbox",
  "send_notification": true,
  "metadata": {
    "triggered_by": "CI/CD Pipeline",
    "build_number": "245"
  }
}

{
  "success": true,
  "data": {
    "uuid": "bkpc_20250124_093045_a8f3d2",
    "status": "in_progress",
    "type": "full",
    "created_at": "2025-01-24T09:30:45Z",
    "estimated_size": 1247652864,
    "progress_url": "/wp-json/bkpc/v1/backup/bkpc_20250124_093045_a8f3d2/status"
  }
}

curl -X POST https://yoursite.com/wp-json/bkpc/v1/backup/create \
  -u username:app_password \
  -H "Content-Type: application/json" \
  -d '{"type":"full","cloud_upload":true}'

GET /wp-json/bkpc/v1/backup/list

{
  "success": true,
  "data": {
    "backups": [
      {
        "uuid": "bkpc_20250124_093045_a8f3d2",
        "type": "full",
        "status": "completed",
        "created_at": "2025-01-24T09:30:45Z",
        "completed_at": "2025-01-24T09:35:12Z",
        "size": 1247652864,
        "cloud_provider": "dropbox",
        "cloud_uploaded": true,
        "download_url": "/wp-json/bkpc/v1/backup/bkpc_20250124_093045_a8f3d2/download"
      }
    ],
    "pagination": {
      "current_page": 1,
      "per_page": 20,
      "total_items": 87,
      "total_pages": 5
    }
  }
}

GET /wp-json/bkpc/v1/backup/{uuid}

{
  "success": true,
  "data": {
    "uuid": "bkpc_20250124_093045_a8f3d2",
    "type": "full",
    "status": "completed",
    "created_at": "2025-01-24T09:30:45Z",
    "completed_at": "2025-01-24T09:35:12Z",
    "size": 1247652864,
    "cloud_provider": "dropbox",
    "cloud_uploaded": true,
    "cloud_path": "/backups/bkpc_20250124_093045_a8f3d2.zip",
    "metadata": {
      "wordpress_version": "6.4.2",
      "php_version": "8.2.0",
      "mysql_version": "8.0.35",
      "table_count": 47,
      "file_count": 12847,
      "triggered_by": "CI/CD Pipeline"
    },
    "includes": {
      "database": true,
      "plugins": true,
      "themes": true,
      "uploads": true,
      "wordpress_core": false
    }
  }
}

POST /wp-json/bkpc/v1/backup/{uuid}/download

{
  "success": true,
  "data": {
    "download_url": "https://yoursite.com/wp-content/backup-copilot-pro/downloads/bkpc_20250124_093045_a8f3d2.zip?token=abc123",
    "expires_at": "2025-01-24T10:30:45Z",
    "size": 1247652864
  }
}

DELETE /wp-json/bkpc/v1/backup/{uuid}

{
  "success": true,
  "message": "Backup deleted successfully"
}

POST /wp-json/bkpc/v1/backup/{uuid}/restore

{
  "restore_database": true,
  "restore_files": true,
  "restore_plugins": true,
  "restore_themes": true,
  "restore_uploads": true
}

{
  "success": true,
  "data": {
    "restore_id": "restore_20250124_103045",
    "status": "in_progress",
    "started_at": "2025-01-24T10:30:45Z",
    "progress_url": "/wp-json/bkpc/v1/restore/restore_20250124_103045/status"
  }
}

GET /wp-json/bkpc/v1/backup/{uuid}/status

{
  "success": true,
  "data": {
    "status": "in_progress",
    "progress": {
      "percentage": 67,
      "current_step": "Uploading to cloud",
      "steps_completed": 4,
      "steps_total": 6,
      "files_processed": 8472,
      "files_total": 12847,
      "bytes_processed": 835891230,
      "bytes_total": 1247652864
    },
    "estimated_time_remaining": 135
  }
}

GET /wp-json/bkpc/v1/schedule/list

{
  "success": true,
  "data": {
    "schedules": [
      {
        "id": 42,
        "name": "Daily Full Backup",
        "enabled": true,
        "frequency": "daily",
        "time": "02:00:00",
        "backup_type": "full",
        "cloud_upload": true,
        "cloud_provider": "dropbox",
        "retention_days": 30,
        "next_run": "2025-01-25T02:00:00Z",
        "last_run": "2025-01-24T02:00:00Z",
        "last_run_status": "completed"
      }
    ]
  }
}

POST /wp-json/bkpc/v1/schedule/create

{
  "name": "Hourly Database Backup",
  "enabled": true,
  "frequency": "hourly",
  "backup_type": "database",
  "cloud_upload": true,
  "cloud_provider": "google_drive",
  "retention_days": 7,
  "send_notification": false
}

{
  "success": true,
  "data": {
    "id": 43,
    "name": "Hourly Database Backup",
    "next_run": "2025-01-24T11:00:00Z"
  }
}

POST /wp-json/bkpc/v1/webhooks/create

{
  "url": "https://monitoring.example.com/webhook/backup-events",
  "events": ["backup.completed", "backup.failed", "restore.completed"],
  "secret": "your_webhook_secret_for_signature_validation"
}

{
  "event": "backup.completed",
  "timestamp": "2025-01-24T09:35:12Z",
  "site_url": "https://yoursite.com",
  "data": {
    "uuid": "bkpc_20250124_093045_a8f3d2",
    "type": "full",
    "size": 1247652864,
    "duration_seconds": 267,
    "cloud_uploaded": true,
    "cloud_provider": "dropbox"
  }
}

# GitHub Actions example
- name: Create Pre-Deployment Backup
  run: |
    RESPONSE=$(curl -s -X POST https://yoursite.com/wp-json/bkpc/v1/backup/create \
      -u ${{ secrets.WP_USERNAME }}:${{ secrets.WP_APP_PASSWORD }} \
      -H "Content-Type: application/json" \
      -d '{"type":"full","cloud_upload":true,"metadata":{"build":"${{ github.run_number }}"}}'')

    BACKUP_UUID=$(echo $RESPONSE | jq -r '.data.uuid')

    # Wait for backup completion
    while true; do
      STATUS=$(curl -s https://yoursite.com/wp-json/bkpc/v1/backup/$BACKUP_UUID/status \
        -u ${{ secrets.WP_USERNAME }}:${{ secrets.WP_APP_PASSWORD }} | jq -r '.data.status')

      if [ "$STATUS" = "completed" ]; then
        echo "Backup completed successfully"
        break
      elif [ "$STATUS" = "failed" ]; then
        echo "Backup failed"
        exit 1
      fi

      sleep 10
    done

import requests
from requests.auth import HTTPBasicAuth

class BackupMonitor:
    def __init__(self, site_url, username, app_password):
        self.site_url = site_url
        self.auth = HTTPBasicAuth(username, app_password)
        self.api_base = f"{site_url}/wp-json/bkpc/v1"

    def list_backups(self, status=None):
        url = f"{self.api_base}/backup/list"
        params = {'status': status} if status else {}

        response = requests.get(url, auth=self.auth, params=params)
        response.raise_for_status()
        return response.json()['data']['backups']

    def create_backup(self, backup_type='full', cloud_upload=True):
        url = f"{self.api_base}/backup/create"
        data = {
            'type': backup_type,
            'cloud_upload': cloud_upload
        }

        response = requests.post(url, auth=self.auth, json=data)
        response.raise_for_status()
        return response.json()['data']

    def monitor_backup(self, uuid):
        url = f"{self.api_base}/backup/{uuid}/status"

        while True:
            response = requests.get(url, auth=self.auth)
            data = response.json()['data']

            status = data['status']
            progress = data.get('progress', {}).get('percentage', 0)

            print(f"Status: {status} - Progress: {progress}%")

            if status in ['completed', 'failed']:
                return status

            time.sleep(10)

# Usage
monitor = BackupMonitor(
    'https://yoursite.com',
    'admin',
    'your-application-password'
)

backup = monitor.create_backup()
status = monitor.monitor_backup(backup['uuid'])
print(f"Final status: {status}")

class BackupDashboard {
    constructor(siteUrl, username, appPassword) {
        this.apiBase = `${siteUrl}/wp-json/bkpc/v1`;
        this.auth = btoa(`${username}:${appPassword}`);
    }

    async listBackups() {
        const response = await fetch(`${this.apiBase}/backup/list`, {
            headers: {
                'Authorization': `Basic ${this.auth}`
            }
        });

        return await response.json();
    }

    async createBackup(type = 'full') {
        const response = await fetch(`${this.apiBase}/backup/create`, {
            method: 'POST',
            headers: {
                'Authorization': `Basic ${this.auth}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                type: type,
                cloud_upload: true
            })
        });

        return await response.json();
    }

    async deleteBackup(uuid) {
        const response = await fetch(`${this.apiBase}/backup/${uuid}`, {
            method: 'DELETE',
            headers: {
                'Authorization': `Basic ${this.auth}`
            }
        });

        return await response.json();
    }
}

// Usage
const dashboard = new BackupDashboard(
    'https://yoursite.com',
    'admin',
    'your-application-password'
);

// Create backup button handler
document.getElementById('create-backup').addEventListener('click', async () => {
    const result = await dashboard.createBackup('full');
    console.log('Backup created:', result.data.uuid);
});

{
  "success": false,
  "error": {
    "code": "invalid_backup_type",
    "message": "Backup type must be 'full', 'database', or 'files'",
    "data": {
      "provided_value": "partial"
    }
  }
}

X-RateLimit-Limit: 500
X-RateLimit-Remaining: 487
X-RateLimit-Reset: 1706097600

$payload = file_get_contents('php://input');
$signature = hash_hmac('sha256', $payload, 'your_webhook_secret');

if (!hash_equals($signature, $_SERVER['HTTP_X_BKPC_SIGNATURE'])) {
    http_response_code(401);
    exit;
}

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
}

abstract class BKPC_Cloud_Provider {
    abstract public function authenticate($credentials);
    abstract public function upload($local_file, $remote_path, $options);
    abstract public function download($remote_path, $local_file);
    abstract public function delete($remote_path);
    abstract public function list_files($remote_dir);
    abstract public function get_storage_info();
}

class BKPC_Cloud_Provider_S3_Compatible extends BKPC_Cloud_Provider {

    private $endpoint;
    private $bucket;
    private $access_key;
    private $secret_key;
    private $client;

    public function __construct() {
        $this->endpoint = get_option('bkpc_s3_endpoint');
        $this->bucket = get_option('bkpc_s3_bucket');
        $this->access_key = get_option('bkpc_s3_access_key');
        $this->secret_key = $this->decrypt(get_option('bkpc_s3_secret_key'));
    }

    public function authenticate($credentials) {
        require_once 'aws-sdk/aws-autoloader.php';

        try {
            $this->client = new Aws\S3\S3Client([
                'version' => 'latest',
                'region' => 'us-east-1',
                'endpoint' => $credentials['endpoint'],
                'credentials' => [
                    'key' => $credentials['access_key'],
                    'secret' => $credentials['secret_key']
                ],
                'use_path_style_endpoint' => true
            ]);

            // Test connection by listing buckets
            $this->client->headBucket(['Bucket' => $credentials['bucket']]);

            return true;
        } catch (Exception $e) {
            throw new Exception('S3 Authentication failed: ' . $e->getMessage());
        }
    }

    public function upload($local_file, $remote_path, $options = []) {
        $file_size = filesize($local_file);

        // Use multipart upload for files > 100MB
        if ($file_size > 100 * 1024 * 1024) {
            return $this->multipart_upload($local_file, $remote_path, $options);
        }

        try {
            $result = $this->client->putObject([
                'Bucket' => $this->bucket,
                'Key' => $remote_path,
                'SourceFile' => $local_file,
                'ServerSideEncryption' => 'AES256'
            ]);

            if (isset($options['progress_callback'])) {
                call_user_func($options['progress_callback'], $file_size, $file_size);
            }

            return $result['ObjectURL'];
        } catch (Exception $e) {
            throw new Exception('Upload failed: ' . $e->getMessage());
        }
    }

    private function multipart_upload($local_file, $remote_path, $options) {
        $uploader = new Aws\S3\MultipartUploader($this->client, $local_file, [
            'bucket' => $this->bucket,
            'key' => $remote_path,
            'before_initiate' => function () use ($options) {
                // Store upload ID for resume capability
            },
            'before_upload' => function ($command) use ($options) {
                if (isset($options['progress_callback'])) {
                    // Update progress
                }
            }
        ]);

        try {
            $result = $uploader->upload();
            return $result['ObjectURL'];
        } catch (Aws\S3\Exception\S3MultipartUploadException $e) {
            // Resume failed upload
            $uploader = new Aws\S3\MultipartUploader($this->client, $local_file, [
                'bucket' => $this->bucket,
                'key' => $remote_path,
                'state' => $e->getState()
            ]);
            $result = $uploader->upload();
            return $result['ObjectURL'];
        }
    }

    public function download($remote_path, $local_file) {
        try {
            $this->client->getObject([
                'Bucket' => $this->bucket,
                'Key' => $remote_path,
                'SaveAs' => $local_file
            ]);
            return true;
        } catch (Exception $e) {
            throw new Exception('Download failed: ' . $e->getMessage());
        }
    }

    public function delete($remote_path) {
        try {
            $this->client->deleteObject([
                'Bucket' => $this->bucket,
                'Key' => $remote_path
            ]);
            return true;
        } catch (Exception $e) {
            throw new Exception('Delete failed: ' . $e->getMessage());
        }
    }

    public function list_files($remote_dir) {
        try {
            $results = $this->client->listObjects([
                'Bucket' => $this->bucket,
                'Prefix' => $remote_dir
            ]);

            $files = [];
            foreach ($results['Contents'] as $object) {
                $files[] = [
                    'path' => $object['Key'],
                    'size' => $object['Size'],
                    'modified' => $object['LastModified']
                ];
            }
            return $files;
        } catch (Exception $e) {
            throw new Exception('List files failed: ' . $e->getMessage());
        }
    }

    public function get_storage_info() {
        // S3 doesn't provide quota info via API
        return [
            'used' => 0,
            'total' => -1, // Unlimited
            'available' => -1
        ];
    }
}

class BKPC_Cloud_Provider_SFTP extends BKPC_Cloud_Provider {

    private $connection;
    private $sftp;

    public function authenticate($credentials) {
        if (!function_exists('ssh2_connect')) {
            throw new Exception('PHP SSH2 extension required');
        }

        $this->connection = ssh2_connect(
            $credentials['host'],
            $credentials['port'] ?? 22
        );

        if (!$this->connection) {
            throw new Exception('Cannot connect to SFTP server');
        }

        if ($credentials['auth_type'] === 'password') {
            $auth = ssh2_auth_password(
                $this->connection,
                $credentials['username'],
                $credentials['password']
            );
        } else {
            $auth = ssh2_auth_pubkey_file(
                $this->connection,
                $credentials['username'],
                $credentials['public_key'],
                $credentials['private_key'],
                $credentials['passphrase']
            );
        }

        if (!$auth) {
            throw new Exception('SFTP authentication failed');
        }

        $this->sftp = ssh2_sftp($this->connection);
        return true;
    }

    public function upload($local_file, $remote_path, $options = []) {
        $remote_stream = fopen("ssh2.sftp://{$this->sftp}{$remote_path}", 'w');
        $local_stream = fopen($local_file, 'r');

        $file_size = filesize($local_file);
        $uploaded = 0;

        while (!feof($local_stream)) {
            $buffer = fread($local_stream, 8192);
            fwrite($remote_stream, $buffer);
            $uploaded += strlen($buffer);

            if (isset($options['progress_callback'])) {
                call_user_func($options['progress_callback'], $uploaded, $file_size);
            }
        }

        fclose($local_stream);
        fclose($remote_stream);

        return "sftp://{$credentials['host']}{$remote_path}";
    }

    public function download($remote_path, $local_file) {
        return ssh2_scp_recv($this->connection, $remote_path, $local_file);
    }

    public function delete($remote_path) {
        return ssh2_sftp_unlink($this->sftp, $remote_path);
    }

    public function list_files($remote_dir) {
        $handle = opendir("ssh2.sftp://{$this->sftp}{$remote_dir}");
        $files = [];

        while (false !== ($file = readdir($handle))) {
            if ($file !== '.' && $file !== '..') {
                $path = $remote_dir . '/' . $file;
                $stat = ssh2_sftp_stat($this->sftp, $path);
                $files[] = [
                    'path' => $path,
                    'size' => $stat['size'],
                    'modified' => $stat['mtime']
                ];
            }
        }

        closedir($handle);
        return $files;
    }

    public function get_storage_info() {
        // Execute df command via SSH
        $stream = ssh2_exec($this->connection, 'df -k .');
        stream_set_blocking($stream, true);
        $output = stream_get_contents($stream);

        // Parse df output to get storage info
        // Implementation depends on server OS

        return ['used' => 0, 'total' => 0, 'available' => 0];
    }
}

add_filter('bkpc_cloud_providers', 'register_custom_providers');

function register_custom_providers($providers) {
    $providers['s3_compatible'] = [
        'name' => 'S3-Compatible Storage',
        'class' => 'BKPC_Cloud_Provider_S3_Compatible',
        'icon' => 'dashicons-cloud',
        'settings_fields' => [
            'endpoint' => ['type' => 'text', 'label' => 'Endpoint URL'],
            'bucket' => ['type' => 'text', 'label' => 'Bucket Name'],
            'access_key' => ['type' => 'text', 'label' => 'Access Key'],
            'secret_key' => ['type' => 'password', 'label' => 'Secret Key']
        ]
    ];

    $providers['sftp'] = [
        'name' => 'SFTP',
        'class' => 'BKPC_Cloud_Provider_SFTP',
        'icon' => 'dashicons-admin-site',
        'settings_fields' => [
            'host' => ['type' => 'text', 'label' => 'Host'],
            'port' => ['type' => 'number', 'label' => 'Port', 'default' => 22],
            'username' => ['type' => 'text', 'label' => 'Username'],
            'password' => ['type' => 'password', 'label' => 'Password']
        ]
    ];

    return $providers;
}

public function authenticate($credentials) {
    // Step 1: Redirect to OAuth consent screen
    if (!isset($credentials['code'])) {
        $auth_url = 'https://provider.com/oauth/authorize?' . http_build_query([
            'client_id' => $credentials['client_id'],
            'redirect_uri' => admin_url('admin.php?page=bkpc-oauth-callback'),
            'response_type' => 'code',
            'scope' => 'file.read file.write'
        ]);
        wp_redirect($auth_url);
        exit;
    }

    // Step 2: Exchange code for access token
    $response = wp_remote_post('https://provider.com/oauth/token', [
        'body' => [
            'code' => $credentials['code'],
            'client_id' => $credentials['client_id'],
            'client_secret' => $credentials['client_secret'],
            'redirect_uri' => admin_url('admin.php?page=bkpc-oauth-callback'),
            'grant_type' => 'authorization_code'
        ]
    ]);

    $body = json_decode(wp_remote_retrieve_body($response), true);

    // Store tokens securely
    update_option('bkpc_provider_access_token', $this->encrypt($body['access_token']));
    update_option('bkpc_provider_refresh_token', $this->encrypt($body['refresh_token']));
    update_option('bkpc_provider_token_expires', time() + $body['expires_in']);

    return true;
}

private function get_access_token() {
    $expires = get_option('bkpc_provider_token_expires');

    // Refresh token if expired
    if (time() >= $expires) {
        $this->refresh_access_token();
    }

    return $this->decrypt(get_option('bkpc_provider_access_token'));
}

private function refresh_access_token() {
    $refresh_token = $this->decrypt(get_option('bkpc_provider_refresh_token'));

    $response = wp_remote_post('https://provider.com/oauth/token', [
        'body' => [
            'refresh_token' => $refresh_token,
            'client_id' => get_option('bkpc_provider_client_id'),
            'client_secret' => $this->decrypt(get_option('bkpc_provider_client_secret')),
            'grant_type' => 'refresh_token'
        ]
    ]);

    $body = json_decode(wp_remote_retrieve_body($response), true);
    update_option('bkpc_provider_access_token', $this->encrypt($body['access_token']));
    update_option('bkpc_provider_token_expires', time() + $body['expires_in']);
}

public function upload_with_retry($local_file, $remote_path, $options = []) {
    $max_retries = 3;
    $retry_delay = 5; // seconds

    for ($attempt = 1; $attempt <= $max_retries; $attempt++) {
        try {
            return $this->upload($local_file, $remote_path, $options);
        } catch (Exception $e) {
            if ($attempt === $max_retries) {
                throw $e;
            }

            // Log retry attempt
            error_log("Upload attempt {$attempt} failed: {$e->getMessage()}. Retrying in {$retry_delay}s");

            sleep($retry_delay);
            $retry_delay *= 2; // Exponential backoff
        }
    }
}

private function encrypt($value) {
    if (!defined('BKPC_ENCRYPTION_KEY')) {
        throw new Exception('Encryption key not defined');
    }
    return openssl_encrypt($value, 'AES-256-CBC', BKPC_ENCRYPTION_KEY, 0, substr(BKPC_ENCRYPTION_KEY, 0, 16));
}

private function decrypt($value) {
    if (!defined('BKPC_ENCRYPTION_KEY')) {
        throw new Exception('Encryption key not defined');
    }
    return openssl_decrypt($value, 'AES-256-CBC', BKPC_ENCRYPTION_KEY, 0, substr(BKPC_ENCRYPTION_KEY, 0, 16));
}

public function authenticate($credentials) {
    $required = ['endpoint', 'bucket', 'access_key', 'secret_key'];
    foreach ($required as $field) {
        if (empty($credentials[$field])) {
            throw new Exception("Missing required field: {$field}");
        }
    }

    // Validate endpoint is proper URL
    if (!filter_var($credentials['endpoint'], FILTER_VALIDATE_URL)) {
        throw new Exception('Invalid endpoint URL');
    }

    // Continue authentication...
}

class BKPC_Cloud_Provider_Tests {

    public static function test_provider($provider_class, $credentials) {
        $provider = new $provider_class();
        $results = [];

        // Test authentication
        try {
            $provider->authenticate($credentials);
            $results['auth'] = 'PASS';
        } catch (Exception $e) {
            $results['auth'] = 'FAIL: ' . $e->getMessage();
            return $results; // Can't continue without auth
        }

        // Test upload
        $test_file = tempnam(sys_get_temp_dir(), 'bkpc_test_');
        file_put_contents($test_file, 'Test backup content');

        try {
            $provider->upload($test_file, '/test-backup.txt');
            $results['upload'] = 'PASS';
        } catch (Exception $e) {
            $results['upload'] = 'FAIL: ' . $e->getMessage();
        }

        // Test list files
        try {
            $files = $provider->list_files('/');
            $results['list'] = count($files) > 0 ? 'PASS' : 'FAIL: No files found';
        } catch (Exception $e) {
            $results['list'] = 'FAIL: ' . $e->getMessage();
        }

        // Test download
        $download_file = tempnam(sys_get_temp_dir(), 'bkpc_download_');
        try {
            $provider->download('/test-backup.txt', $download_file);
            $results['download'] = file_get_contents($download_file) === 'Test backup content' ? 'PASS' : 'FAIL: Content mismatch';
        } catch (Exception $e) {
            $results['download'] = 'FAIL: ' . $e->getMessage();
        }

        // Test delete
        try {
            $provider->delete('/test-backup.txt');
            $results['delete'] = 'PASS';
        } catch (Exception $e) {
            $results['delete'] = 'FAIL: ' . $e->getMessage();
        }

        // Cleanup
        unlink($test_file);
        unlink($download_file);

        return $results;
    }
}

public function upload($local_file, $remote_path, $options = []) {
    // Compress if not already compressed
    if (!preg_match('/\.(zip|gz|bz2)$/i', $local_file)) {
        $compressed = $local_file . '.gz';
        $this->compress_file($local_file, $compressed);
        $local_file = $compressed;
        $remote_path .= '.gz';
    }

    // Upload compressed file
    return $this->do_upload($local_file, $remote_path, $options);
}