// 检测设备内存
if ('deviceMemory' in navigator) {
  const memoryGB = navigator.deviceMemory;
  console.log(`该设备大约有 ${memoryGB} GB 内存`);
  
  // 根据内存容量调整应用行为
  if (memoryGB < 2) {
    // 低内存设备的优化策略
    loadLightweightAssets();
    disableMemoryIntensiveFeatures();
  } else if (memoryGB >= 4) {
    // 高内存设备的高级功能
    enableAdvancedVisualizations();
    preloadAdditionalContent();
  }
} else {
  console.log('设备内存 API 不被支持');
}

function getOptimalImageQuality() {
  if (!('deviceMemory' in navigator)) {
    return 'medium'; // 默认中等质量
  }
  
  const memory = navigator.deviceMemory;
  
  if (memory < 2) return 'low';
  if (memory < 4) return 'medium';
  return 'high';
}

// 根据设备内存加载适当质量的图像
const imageQuality = getOptimalImageQuality();
const imageUrl = `https://example.com/image-${imageQuality}.jpg`;

class FeatureManager {
  constructor() {
    this.supportedFeatures = new Set(['core']);
    
    if ('deviceMemory' in navigator) {
      const memory = navigator.deviceMemory;
      
      if (memory >= 2) {
        this.supportedFeatures.add('animations');
        this.supportedFeatures.add('analytics');
      }
      
      if (memory >= 4) {
        this.supportedFeatures.add('realtime-updates');
        this.supportedFeatures.add('background-sync');
      }
      
      if (memory >= 8) {
        this.supportedFeatures.add('webgl-effects');
        this.supportedFeatures.add('predictive-preloading');
      }
    }
  }
  
  shouldLoadFeature(featureName) {
    return this.supportedFeatures.has(featureName);
  }
}

class MemoryAwareTaskScheduler {
  constructor() {
    this.maxConcurrentTasks = this.calculateMaxConcurrentTasks();
    this.activeTasks = 0;
    this.taskQueue = [];
  }
  
  calculateMaxConcurrentTasks() {
    if (!('deviceMemory' in navigator)) {
      return 3; // 保守默认值
    }
    
    const memory = navigator.deviceMemory;
    
    if (memory < 1) return 1;
    if (memory < 2) return 2;
    if (memory < 4) return 4;
    return 8;
  }
  
  scheduleTask(task) {
    if (this.activeTasks < this.maxConcurrentTasks) {
      this.executeTask(task);
    } else {
      this.taskQueue.push(task);
    }
  }
  
  executeTask(task) {
    this.activeTasks++;
    task().finally(() => {
      this.activeTasks--;
      this.processQueue();
    });
  }
  
  processQueue() {
    while (this.activeTasks < this.maxConcurrentTasks && this.taskQueue.length > 0) {
      const nextTask = this.taskQueue.shift();
      this.executeTask(nextTask);
    }
  }
}

function isDeviceMemorySupported() {
  return 'deviceMemory' in navigator && 
         typeof navigator.deviceMemory === 'number' &&
         navigator.deviceMemory > 0;
}

function getDeviceCapabilityLevel() {
  // 尝试使用设备内存 API
  if ('deviceMemory' in navigator) {
    const memory = navigator.deviceMemory;
    if (memory < 2) return 'low';
    if (memory < 4) return 'medium';
    return 'high';
  }
  
  // 降级：使用其他指标推测
  if ('hardwareConcurrency' in navigator) {
    const cores = navigator.hardwareConcurrency;
    if (cores <= 2) return 'low';
    if (cores <= 4) return 'medium';
    return 'high';
  }
  
  // 最终降级：用户代理检测（不推荐，仅作最后手段）
  const userAgent = navigator.userAgent.toLowerCase();
  if (/mobile|android|iphone|ipad|ipod/.test(userAgent)) {
    return 'low'; // 假设移动设备能力较低
  }
  
  return 'medium'; // 默认中等能力
}

async function getDeviceProfile() {
  const profile = {
    memory: null,
    cores: null,
    connection: null,
    storage: null
  };
  
  // 设备内存
  if ('deviceMemory' in navigator) {
    profile.memory = navigator.deviceMemory;
  }
  
  // CPU核心数
  if ('hardwareConcurrency' in navigator) {
    profile.cores = navigator.hardwareConcurrency;
  }
  
  // 网络连接
  if ('connection' in navigator) {
    profile.connection = {
      effectiveType: navigator.connection.effectiveType,
      downlink: navigator.connection.downlink,
      saveData: navigator.connection.saveData
    };
  }
  
  // 存储容量估算
  if ('storage' in navigator && 'estimate' in navigator.storage) {
    try {
      const estimate = await navigator.storage.estimate();
      profile.storage = {
        quota: estimate.quota,
        usage: estimate.usage
      };
    } catch (error) {
      console.warn('无法获取存储信息:', error);
    }
  }
  
  return profile;
}

// 使用设备配置文件优化应用
getDeviceProfile().then(profile => {
  console.log('设备配置文件:', profile);
  configureApplication(profile);
});