// Implementación de Exponential Backoff
async function fetchWithRetry(url, options, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await fetch(url, options);
      
      if (response.status === 429) {
        const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s
        console.log(`Rate limit. Esperando ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
      
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }
      
      return await response.json();
    } catch (error) {
      if (i === maxRetries - 1) throw error;
    }
  }
}

async function createBackupSystem(accessToken) {
  // 1. Crear carpeta de backup
  const folderMetadata = {
    name: `Backup_${new Date().toISOString().split('T')[0]}`,
    mimeType: 'application/vnd.google-apps.folder'
  };
  
  const folderResponse = await fetch('https://www.googleapis.com/drive/v3/files', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(folderMetadata)
  });
  
  const folder = await folderResponse.json();
  console.log('Carpeta creada:', folder.id);
  
  // 2. Subir archivos a la carpeta
  async function uploadFile(fileName, fileContent) {
    const metadata = {
      name: fileName,
      parents: [folder.id]
    };
    
    const form = new FormData();
    form.append('metadata', new Blob([JSON.stringify(metadata)], { type: 'application/json' }));
    form.append('file', new Blob([fileContent]));
    
    const response = await fetch(
      'https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart',
      {
        method: 'POST',
        headers: { 'Authorization': `Bearer ${accessToken}` },
        body: form
      }
    );
    
    return await response.json();
  }
  
  // Subir archivos
  const files = ['config.json', 'database.sql', 'logs.txt'];
  for (const file of files) {
    const result = await uploadFile(file, `Contenido de ${file}`);
    console.log(`${file} subido: ${result.id}`);
  }
  
  return folder.id;
}

async function advancedSearch(accessToken, criteria) {
  const queries = [];
  
  // Filtro por nombre
  if (criteria.name) {
    queries.push(`name contains '${criteria.name}'`);
  }
  
  // Filtro por tipo MIME
  if (criteria.mimeType) {
    queries.push(`mimeType='${criteria.mimeType}'`);
  }
  
  // Filtro por fecha de modificación
  if (criteria.modifiedAfter) {
    queries.push(`modifiedTime > '${criteria.modifiedAfter}'`);
  }
  
  // Excluir archivos en papelera
  queries.push('trashed=false');
  
  const query = queries.join(' and ');
  
  const response = await fetch(
    `https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&orderBy=modifiedTime desc`,
    { headers: { 'Authorization': `Bearer ${accessToken}` }}
  );
  
  const data = await response.json();
  return data.files;
}

// Uso
const results = await advancedSearch(accessToken, {
  name: 'reporte',
  mimeType: 'application/pdf',
  modifiedAfter: '2024-01-01T00:00:00'
});

console.log(`Encontrados ${results.length} archivos`);

async function shareWithMultipleUsers(accessToken, fileId, users) {
  const results = [];
  
  for (const user of users) {
    const permission = {
      type: 'user',
      role: user.role || 'reader',
      emailAddress: user.email
    };
    
    try {
      const response = await fetch(
        `https://www.googleapis.com/drive/v3/files/${fileId}/permissions?sendNotificationEmail=true`,
        {
          method: 'POST',
          headers: {
            'Authorization': `Bearer ${accessToken}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify(permission)
        }
      );
      
      const result = await response.json();
      results.push({ email: user.email, success: true, permissionId: result.id });
    } catch (error) {
      results.push({ email: user.email, success: false, error: error.message });
    }
  }
  
  return results;
}

// Uso
const users = [
  { email: 'usuario1@example.com', role: 'writer' },
  { email: 'usuario2@example.com', role: 'reader' },
  { email: 'usuario3@example.com', role: 'commenter' }
];

const shareResults = await shareWithMultipleUsers(accessToken, fileId, users);
shareResults.forEach(r => {
  console.log(`${r.email}: ${r.success ? '✓ Compartido' : '✗ Error'}`);
});

class DriveChangeMonitor {
  constructor(accessToken) {
    this.accessToken = accessToken;
    this.pageToken = null;
  }
  
  async initialize() {
    const response = await fetch(
      'https://www.googleapis.com/drive/v3/changes/startPageToken',
      { headers: { 'Authorization': `Bearer ${this.accessToken}` }}
    );
    const data = await response.json();
    this.pageToken = data.startPageToken;
    console.log('Monitor inicializado con token:', this.pageToken);
  }
  
  async checkForChanges() {
    if (!this.pageToken) {
      await this.initialize();
    }
    
    const response = await fetch(
      `https://www.googleapis.com/drive/v3/changes?pageToken=${this.pageToken}&includeRemoved=true`,
      { headers: { 'Authorization': `Bearer ${this.accessToken}` }}
    );
    
    const data = await response.json();
    
    if (data.changes && data.changes.length > 0) {
      console.log(`Detectados ${data.changes.length} cambios:`);
      data.changes.forEach(change => {
        if (change.removed) {
          console.log(`❌ Archivo eliminado: ${change.fileId}`);
        } else if (change.file) {
          console.log(`📝 Archivo modificado: ${change.file.name}`);
        }
      });
    }
    
    // Actualizar el token para la próxima verificación
    this.pageToken = data.newStartPageToken || data.nextPageToken;
    
    return data.changes || [];
  }
  
  async startMonitoring(intervalMs = 30000) {
    console.log('Iniciando monitoreo de cambios...');
    await this.initialize();
    
    setInterval(async () => {
      await this.checkForChanges();
    }, intervalMs);
  }
}

// Uso
const monitor = new DriveChangeMonitor(accessToken);
await monitor.startMonitoring(30000); // Verificar cada 30 segundos

async function createFolderStructure(accessToken, structure, parentId = null) {
  const results = {};
  
  for (const [folderName, subfolders] of Object.entries(structure)) {
    // Crear carpeta
    const metadata = {
      name: folderName,
      mimeType: 'application/vnd.google-apps.folder'
    };
    
    if (parentId) {
      metadata.parents = [parentId];
    }
    
    const response = await fetch(
      'https://www.googleapis.com/drive/v3/files',
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${accessToken}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(metadata)
      }
    );
    
    const folder = await response.json();
    results[folderName] = folder.id;
    console.log(`✓ Carpeta creada: ${folderName}`);
    
    // Crear subcarpetas recursivamente
    if (subfolders && typeof subfolders === 'object') {
      const subResults = await createFolderStructure(accessToken, subfolders, folder.id);
      results[folderName] = { id: folder.id, children: subResults };
    }
  }
  
  return results;
}

// Uso: Crear estructura de proyecto
const projectStructure = {
  'Mi Proyecto': {
    'Documentación': {
      'API': {},
      'Guías': {}
    },
    'Código': {
      'Frontend': {},
      'Backend': {}
    },
    'Recursos': {
      'Imágenes': {},
      'Videos': {}
    }
  }
};

const folderIds = await createFolderStructure(accessToken, projectStructure);
console.log('Estructura creada:', folderIds);