// 国内主流 OSS 服务
const ossProviders = {
  aliyun: {
    name: '阿里云 OSS',
    endpoint: 'oss-cn-hangzhou.aliyuncs.com',
    features: ['稳定性高', '国内访问快', '生态完善']
  },
  tencent: {
    name: '腾讯云 COS',
    endpoint: 'cos.ap-guangzhou.myqcloud.com',
    features: ['价格优惠', '与微信生态集成', 'CDN 加速']
  },
  qiniu: {
    name: '七牛云 Kodo',
    endpoint: 'qiniu.com',
    features: ['免费额度大', '图片处理强', '适合小团队']
  },
  huawei: {
    name: '华为云 OBS',
    endpoint: 'obs.cn-north-4.myhuaweicloud.com',
    features: ['企业级服务', '安全性高', '政企首选']
  }
};

// 国际主流 OSS 服务
const internationalProviders = {
  aws: {
    name: 'AWS S3',
    endpoint: 's3.amazonaws.com',
    features: ['全球领先', '功能最全', '生态最强']
  },
  azure: {
    name: 'Azure Blob Storage',
    endpoint: 'blob.core.windows.net',
    features: ['微软生态', '企业级', '混合云']
  },
  gcp: {
    name: 'Google Cloud Storage',
    endpoint: 'storage.googleapis.com',
    features: ['AI/ML 集成', '全球网络', '性能优秀']
  }
};

// OSS 的基本概念模型
const ossStructure = {
  // 1. Bucket（存储桶）- 存储空间的容器
  bucket: {
    name: 'my-frontend-app',
    region: 'cn-hangzhou',
    acl: 'public-read',  // 访问权限
    description: '类似于顶级目录，全局唯一'
  },

  // 2. Object（对象）- 存储的基本单元
  object: {
    key: 'static/js/app.js',  // 对象的唯一标识
    value: '<文件内容>',       // 对象的数据
    metadata: {               // 对象的元数据
      'Content-Type': 'application/javascript',
      'Cache-Control': 'max-age=31536000',
      'ETag': '"abc123..."'
    },
    url: 'https://my-frontend-app.oss-cn-hangzhou.aliyuncs.com/static/js/app.js'
  },

  // 3. Region（地域）- 数据中心的物理位置
  region: {
    code: 'cn-hangzhou',
    location: '杭州',
    description: '选择离用户最近的地域可以降低延迟'
  },

  // 4. Endpoint（访问域名）- OSS 服务的访问入口
  endpoint: {
    internal: 'oss-cn-hangzhou-internal.aliyuncs.com',  // 内网访问
    public: 'oss-cn-hangzhou.aliyuncs.com',             // 公网访问
    custom: 'cdn.myapp.com'                              // 自定义域名
  }
};

// 传统部署：单点故障
const traditionalDeployment = {
  servers: ['server1.example.com'],
  availability: '99.9%',  // 单机可用性
  failover: 'manual',     // 手动故障转移
  risk: '服务器宕机 = 服务不可用'
};

// OSS + CDN：分布式架构
const ossCdnDeployment = {
  ossNodes: ['多个数据中心', '自动备份', '跨区域冗余'],
  cdnNodes: ['全球数百个节点', '自动故障转移'],
  availability: '99.99%',  // 更高的可用性
  failover: 'automatic',   // 自动故障转移
  risk: '单个节点故障不影响服务'
};

// 阿里云 OSS 的高可用保障
const aliyunOssHA = {
  // 数据持久性
  durability: '99.9999999999%',  // 12 个 9

  // 服务可用性
  availability: '99.995%',

  // 数据冗余
  redundancy: {
    local: '同一数据中心 3 副本',
    crossRegion: '跨区域备份（可选）',
    autoRepair: '自动检测和修复数据'
  },

  // 故障恢复
  recovery: {
    rto: '< 5 分钟',  // 恢复时间目标
    rpo: '0',         // 恢复点目标（无数据丢失）
  }
};

// CDN 加速原理
const cdnAcceleration = {
  // 1. 就近访问
  edgeNode: {
    description: '用户访问最近的 CDN 节点',
    benefit: '减少网络延迟',
    example: {
      traditional: '北京用户访问深圳服务器 = 50ms',
      cdn: '北京用户访问北京 CDN 节点 = 5ms'
    }
  },

  // 2. 缓存加速
  cache: {
    description: 'CDN 节点缓存静态资源',
    benefit: '减少回源请求',
    hitRate: '95%+',  // 缓存命中率
    example: {
      firstVisit: 'CDN 节点 → OSS 源站 → 返回资源',
      cachedVisit: 'CDN 节点 → 直接返回（无需回源）'
    }
  },

  // 3. 协议优化
  protocol: {
    http2: '多路复用、头部压缩',
    http3: 'QUIC 协议、0-RTT',
    tls13: '更快的握手'
  },

  // 4. 智能路由
  routing: {
    description: '根据网络状况选择最优路径',
    factors: ['延迟', '丢包率', '带宽', '负载']
  }
};

// 实际测试数据（以 1MB 的 JS 文件为例）
const performanceComparison = {
  traditional: {
    location: '单一服务器（深圳）',
    beijing: { latency: '50ms', downloadTime: '800ms' },
    shanghai: { latency: '30ms', downloadTime: '600ms' },
    shenzhen: { latency: '5ms', downloadTime: '200ms' },
    average: '533ms'
  },

  ossCdn: {
    location: 'CDN 全球节点',
    beijing: { latency: '5ms', downloadTime: '150ms' },
    shanghai: { latency: '5ms', downloadTime: '150ms' },
    shenzhen: { latency: '5ms', downloadTime: '150ms' },
    average: '150ms',
    improvement: '72% 提升'
  }
};

// 成本对比分析
const costComparison = {
  // 传统服务器部署
  traditional: {
    server: {
      type: '4核8G 云服务器',
      cost: '300元/月',
      bandwidth: '5Mbps（固定带宽）',
      storage: '100GB SSD'
    },
    cdn: {
      cost: '另外购买 CDN 服务',
      price: '0.25元/GB'
    },
    ssl: {
      cost: '证书费用',
      price: '免费 - 1000元/年'
    },
    ops: {
      cost: '运维人力成本',
      time: '每月 2-4 小时'
    },
    total: '约 500-800元/月（不含人力）'
  },

  // OSS + CDN 部署
  ossCdn: {
    oss: {
      storage: '0.12元/GB/月',
      example: '10GB 静态资源 = 1.2元/月'
    },
    cdn: {
      traffic: '0.24元/GB',
      example: '100GB 流量 = 24元/月'
    },
    request: {
      cost: '0.01元/万次',
      example: '100万次请求 = 1元/月'
    },
    ssl: {
      cost: '免费 HTTPS 证书',
      price: '0元'
    },
    ops: {
      cost: '自动化部署',
      time: '几乎为 0'
    },
    total: '约 26.2元/月（10GB 存储 + 100GB 流量）',
    saving: '节省 95% 成本'
  }
};

// 中小型网站的成本对比
const realWorldExample = {
  scenario: {
    storage: '5GB 静态资源',
    traffic: '50GB/月',
    requests: '500万次/月',
    users: '日均 5000 UV'
  },

  traditionalCost: {
    server: 300,      // 服务器
    bandwidth: 200,   // 额外带宽
    backup: 50,       // 备份
    total: 550,
    unit: '元/月'
  },

  ossCdnCost: {
    storage: 0.6,     // 5GB × 0.12
    traffic: 12,      // 50GB × 0.24
    requests: 0.5,    // 500万 × 0.01/万
    total: 13.1,
    unit: '元/月',
    saving: '97.6%'
  }
};

// 扩展性对比
const scalability = {
  // 传统部署扩展
  traditional: {
    storage: {
      limit: '受限于服务器磁盘',
      expansion: '需要购买更大磁盘或添加服务器',
      downtime: '可能需要停机迁移'
    },
    bandwidth: {
      limit: '受限于服务器带宽',
      expansion: '需要升级带宽套餐',
      cost: '固定成本，即使不用也要付费'
    },
    traffic: {
      limit: '单机处理能力有限',
      expansion: '需要负载均衡 + 多台服务器',
      complexity: '架构复杂度大幅增加'
    }
  },

  // OSS + CDN 扩展
  ossCdn: {
    storage: {
      limit: '理论上无限',
      expansion: '自动扩展，无需人工干预',
      downtime: '0 停机时间'
    },
    bandwidth: {
      limit: '无限制',
      expansion: '自动扩展',
      cost: '按实际使用付费'
    },
    traffic: {
      limit: 'CDN 自动负载均衡',
      expansion: '流量再大也能自动应对',
      complexity: '架构简单，无需关心'
    }
  }
};

// 安全特性对比
const security = {
  // OSS + CDN 的安全特性
  features: {
    // 1. DDoS 防护
    ddos: {
      protection: 'CDN 自带 DDoS 防护',
      capacity: '可防御 TB 级攻击',
      cost: '包含在服务中'
    },

    // 2. HTTPS 加密
    https: {
      certificate: '免费 SSL 证书',
      autoRenewal: '自动续期',
      protocol: 'TLS 1.3'
    },

    // 3. 访问控制
    accessControl: {
      referer: '防盗链',
      ip: 'IP 黑白名单',
      auth: 'URL 签名认证',
      cors: 'CORS 跨域配置'
    },

    // 4. 数据安全
    dataSecurity: {
      encryption: '服务端加密（SSE）',
      backup: '自动备份和版本控制',
      compliance: '等保三级认证'
    }
  }
};

// 前端资源特征分析
const frontendAssets = {
  // 静态资源占比大
  staticFiles: {
    types: ['HTML', 'CSS', 'JavaScript', '图片', '字体', '视频'],
    characteristics: '内容不经常变化，适合缓存',
    size: '通常占应用总大小的 80%+'
  },

  // 访问频率高
  accessPattern: {
    frequency: '每个用户访问都需要加载',
    concurrent: '高并发场景常见',
    global: '用户分布在不同地域'
  },

  // 对性能敏感
  performance: {
    firstLoad: '首次加载影响用户体验',
    caching: '缓存策略至关重要',
    bandwidth: '带宽消耗大'
  }
};

// OSS 解决前端痛点
const ossForFrontend = {
  // 痛点 1: 静态资源存储
  storage: {
    problem: '服务器磁盘空间有限且昂贵',
    solution: 'OSS 提供海量低成本存储',
    benefit: '无需担心存储空间，按需付费'
  },

  // 痛点 2: 全球访问速度
  speed: {
    problem: '用户分布全球，单一服务器延迟高',
    solution: 'OSS + CDN 全球加速',
    benefit: '任何地方的用户都能快速访问'
  },

  // 痛点 3: 高并发处理
  concurrency: {
    problem: '服务器并发能力有限',
    solution: 'CDN 分布式架构自动负载均衡',
    benefit: '轻松应对流量高峰'
  },

  // 痛点 4: 运维复杂度
  ops: {
    problem: '需要维护服务器、配置 Nginx、管理证书',
    solution: 'OSS 托管服务，零运维',
    benefit: '专注业务开发，无需关心基础设施'
  }
};

// 前端使用 OSS 的场景
const useCases = {
  // 1. SPA 应用部署
  spa: {
    description: 'React/Vue/Angular 单页应用',
    files: ['index.html', 'static/js/*.js', 'static/css/*.css'],
    benefit: '快速部署，全球加速'
  },

  // 2. 静态网站托管
  staticSite: {
    description: '博客、文档站、营销页面',
    tools: ['VitePress', 'Docusaurus', 'Gatsby', 'Next.js SSG'],
    benefit: '零服务器成本，极致性能'
  },

  // 3. 图片/视频资源
  media: {
    description: '用户上传的图片、视频等',
    features: ['图片处理', '视频转码', '缩略图生成'],
    benefit: '专业的媒体处理能力'
  },

  // 4. 大文件下载
  download: {
    description: 'APP 安装包、软件更新包',
    features: ['断点续传', '分片上传', '秒传'],
    benefit: '稳定可靠的下载体验'
  }
};

// 以阿里云 OSS 为例
const bucketConfig = {
  name: 'my-frontend-app',           // Bucket 名称（全局唯一）
  region: 'oss-cn-hangzhou',         // 地域
  acl: 'public-read',                // 访问权限（公共读）
  storageClass: 'Standard',          // 存储类型
  versioning: 'Enabled'              // 版本控制（可选）
};

// 通过控制台创建步骤：
// 1. 登录阿里云控制台
// 2. 进入 OSS 产品页
// 3. 创建 Bucket
// 4. 配置访问权限为"公共读"
// 5. 开启静态网站托管（可选）

// 静态网站托管配置
const staticWebsiteConfig = {
  // 默认首页
  indexDocument: 'index.html',

  // 错误页面
  errorDocument: '404.html',

  // 子目录首页
  supportSubDir: true,

  // 示例访问路径
  examples: {
    root: 'https://my-bucket.oss-cn-hangzhou.aliyuncs.com/',
    subDir: 'https://my-bucket.oss-cn-hangzhou.aliyuncs.com/docs/',
    file: 'https://my-bucket.oss-cn-hangzhou.aliyuncs.com/static/app.js'
  }
};

// deploy.js
const OSS = require('ali-oss');
const fs = require('fs');
const path = require('path');
const glob = require('glob');

// 配置 OSS 客户端
const client = new OSS({
  region: 'oss-cn-hangzhou',
  accessKeyId: process.env.OSS_ACCESS_KEY_ID,
  accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET,
  bucket: 'my-frontend-app'
});

// 获取文件的 Content-Type
function getContentType(filePath) {
  const ext = path.extname(filePath).toLowerCase();
  const types = {
    '.html': 'text/html',
    '.css': 'text/css',
    '.js': 'application/javascript',
    '.json': 'application/json',
    '.png': 'image/png',
    '.jpg': 'image/jpeg',
    '.svg': 'image/svg+xml',
    '.woff': 'font/woff',
    '.woff2': 'font/woff2'
  };
  return types[ext] || 'application/octet-stream';
}

// 获取缓存策略
function getCacheControl(filePath) {
  const ext = path.extname(filePath).toLowerCase();

  // HTML 文件不缓存
  if (ext === '.html') {
    return 'no-cache';
  }

  // 带 hash 的文件长期缓存
  if (/\.[a-f0-9]{8,}\.(js|css)$/.test(filePath)) {
    return 'max-age=31536000, immutable';
  }

  // 其他静态资源短期缓存
  return 'max-age=86400';
}

// 上传单个文件
async function uploadFile(localPath, remotePath) {
  try {
    const result = await client.put(remotePath, localPath, {
      headers: {
        'Content-Type': getContentType(localPath),
        'Cache-Control': getCacheControl(localPath)
      }
    });
    console.log(`✓ ${remotePath}`);
    return result;
  } catch (error) {
    console.error(`✗ ${remotePath}:`, error.message);
    throw error;
  }
}

// 上传目录
async function uploadDirectory(distDir) {
  const files = glob.sync('**/*', {
    cwd: distDir,
    nodir: true
  });

  console.log(`找到 ${files.length} 个文件，开始上传...\n`);

  for (const file of files) {
    const localPath = path.join(distDir, file);
    const remotePath = file.replace(/\\/g, '/');
    await uploadFile(localPath, remotePath);
  }

  console.log(`\n上传完成！共 ${files.length} 个文件`);
}

// 删除旧文件（可选）
async function cleanOldFiles() {
  console.log('清理旧文件...');

  let marker = null;
  let count = 0;

  do {
    const result = await client.list({
      marker,
      'max-keys': 1000
    });

    for (const obj of result.objects || []) {
      await client.delete(obj.name);
      count++;
    }

    marker = result.nextMarker;
  } while (marker);

  console.log(`已删除 ${count} 个旧文件\n`);
}

// 主函数
async function deploy() {
  try {
    console.log('开始部署到 OSS...\n');

    // 可选：清理旧文件
    // await cleanOldFiles();

    // 上传新文件
    await uploadDirectory('./dist');

    console.log('\n部署成功！');
    console.log('访问地址: https://my-frontend-app.oss-cn-hangzhou.aliyuncs.com/');

  } catch (error) {
    console.error('部署失败:', error);
    process.exit(1);
  }
}

// 执行部署
deploy();

// CDN 配置步骤
const cdnSetup = {
  step1: {
    title: '添加 CDN 域名',
    actions: [
      '进入 CDN 控制台',
      '添加域名',
      '选择源站类型：OSS 域名',
      '选择对应的 OSS Bucket'
    ]
  },

  step2: {
    title: '配置 CNAME',
    actions: [
      '获取 CDN 分配的 CNAME 域名',
      '在域名服务商处添加 CNAME 记录',
      '等待 DNS 生效（通常 10 分钟内）'
    ],
    example: {
      type: 'CNAME',
      host: 'cdn',
      value: 'cdn.myapp.com.w.kunlunsl.com'
    }
  },

  step3: {
    title: '配置 HTTPS',
    actions: [
      '上传 SSL 证书或使用免费证书',
      '开启 HTTPS',
      '配置 HTTP 强制跳转 HTTPS'
    ]
  }
};

// 缓存规则配置
const cacheRules = [
  {
    path: '/',
    type: 'directory',
    cacheTime: 0,
    description: '根目录下的 HTML 文件不缓存'
  },
  {
    path: '/static/js/',
    type: 'directory',
    cacheTime: 31536000,  // 1 年
    description: 'JS 文件长期缓存'
  },
  {
    path: '/static/css/',
    type: 'directory',
    cacheTime: 31536000,  // 1 年
    description: 'CSS 文件长期缓存'
  },
  {
    path: '/static/img/',
    type: 'directory',
    cacheTime: 2592000,   // 30 天
    description: '图片文件中期缓存'
  },
  {
    path: '*.html',
    type: 'suffix',
    cacheTime: 0,
    description: '所有 HTML 文件不缓存'
  }
];

// CDN 优化配置
const cdnOptimization = {
  // 1. 开启 Gzip 压缩
  gzip: {
    enabled: true,
    minSize: 1024,  // 大于 1KB 的文件才压缩
    types: ['text/html', 'text/css', 'application/javascript', 'application/json']
  },

  // 2. 开启 Brotli 压缩（更高压缩率）
  brotli: {
    enabled: true,
    priority: 'higher than gzip'
  },

  // 3. 开启 HTTP/2
  http2: {
    enabled: true,
    benefits: ['多路复用', '头部压缩', '服务器推送']
  },

  // 4. 开启 QUIC（HTTP/3）
  quic: {
    enabled: true,
    benefits: ['0-RTT', '更快的连接建立', '更好的弱网表现']
  },

  // 5. 智能压缩
  smartCompression: {
    enabled: true,
    description: '自动选择最优压缩算法'
  },

  // 6. 图片优化
  imageOptimization: {
    webp: true,        // 自动转换为 WebP
    avif: true,        // 支持 AVIF 格式
    resize: true,      // 自动调整尺寸
    quality: 85        // 压缩质量
  }
};

// 完善的缓存策略
const cacheStrategy = {
  // HTML 文件：不缓存或短期缓存
  html: {
    cacheControl: 'no-cache',
    reason: 'HTML 是入口文件，需要及时更新',
    alternative: 'max-age=300',  // 或 5 分钟短期缓存
    etag: true  // 使用 ETag 进行协商缓存
  },

  // 带 hash 的静态资源：长期缓存
  hashedAssets: {
    pattern: /\.[a-f0-9]{8,}\.(js|css|png|jpg|woff2)$/,
    cacheControl: 'max-age=31536000, immutable',
    reason: '文件名包含内容 hash，内容变化时文件名会变',
    benefit: '完美的缓存策略，永不过期'
  },

  // 不带 hash 的静态资源：中期缓存
  staticAssets: {
    pattern: /\.(js|css|png|jpg)$/,
    cacheControl: 'max-age=86400',  // 1 天
    reason: '文件可能更新，需要定期检查',
    etag: true
  },

  // API 数据：不缓存
  api: {
    cacheControl: 'no-store',
    reason: '动态数据，不应缓存'
  }
};

// Vite 配置 - 生成带 hash 的文件名
// vite.config.js
export default {
  build: {
    rollupOptions: {
      output: {
        // JS 文件名包含 hash
        entryFileNames: 'static/js/[name].[hash].js',
        chunkFileNames: 'static/js/[name].[hash].js',
        // CSS 文件名包含 hash
        assetFileNames: (assetInfo) => {
          if (assetInfo.name.endsWith('.css')) {
            return 'static/css/[name].[hash].css';
          }
          return 'static/assets/[name].[hash].[ext]';
        }
      }
    }
  }
};

// 版本化部署脚本
// deploy-versioned.js
const OSS = require('ali-oss');
const path = require('path');
const fs = require('fs');

const client = new OSS({
  region: 'oss-cn-hangzhou',
  accessKeyId: process.env.OSS_ACCESS_KEY_ID,
  accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET,
  bucket: 'my-frontend-app'
});

// 生成版本号
function getVersion() {
  const now = new Date();
  return `v${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${String(now.getDate()).padStart(2, '0')}_${String(now.getHours()).padStart(2, '0')}${String(now.getMinutes()).padStart(2, '0')}`;
}

// 部署到版本目录
async function deployVersion() {
  const version = getVersion();
  const versionPath = `versions/${version}/`;

  console.log(`部署版本: ${version}`);

  // 上传文件到版本目录
  const files = glob.sync('dist/**/*', { nodir: true });

  for (const file of files) {
    const relativePath = path.relative('dist', file);
    const remotePath = versionPath + relativePath;
    await client.put(remotePath, file);
    console.log(`✓ ${remotePath}`);
  }

  // 更新当前版本指针
  await updateCurrentVersion(version);

  // 保存版本信息
  await saveVersionInfo(version);

  console.log(`\n✅ 版本 ${version} 部署成功！`);
}

// 更新当前版本
async function updateCurrentVersion(version) {
  const versionPath = `versions/${version}/`;

  // 复制版本文件到根目录
  const result = await client.list({
    prefix: versionPath,
    'max-keys': 1000
  });

  for (const obj of result.objects) {
    const targetPath = obj.name.replace(versionPath, '');
    await client.copy(targetPath, obj.name);
  }

  console.log('✓ 已更新当前版本');
}

// 保存版本信息
async function saveVersionInfo(version) {
  const versionInfo = {
    version,
    timestamp: new Date().toISOString(),
    commit: process.env.GITHUB_SHA || 'local',
    branch: process.env.GITHUB_REF || 'local'
  };

  await client.put('version.json', Buffer.from(JSON.stringify(versionInfo, null, 2)));
  console.log('✓ 已保存版本信息');
}

// 回滚到指定版本
async function rollback(targetVersion) {
  console.log(`回滚到版本: ${targetVersion}`);

  const versionPath = `versions/${targetVersion}/`;

  // 检查版本是否存在
  const exists = await client.list({
    prefix: versionPath,
    'max-keys': 1
  });

  if (!exists.objects || exists.objects.length === 0) {
    throw new Error(`版本 ${targetVersion} 不存在`);
  }

  // 更新当前版本
  await updateCurrentVersion(targetVersion);

  console.log(`✅ 已回滚到版本 ${targetVersion}`);
}

// 列出所有版本
async function listVersions() {
  const result = await client.list({
    prefix: 'versions/',
    delimiter: '/'
  });

  const versions = result.prefixes
    .map(prefix => prefix.replace('versions/', '').replace('/', ''))
    .sort()
    .reverse();

  console.log('可用版本：');
  versions.forEach((v, i) => {
    console.log(`${i + 1}. ${v}`);
  });

  return versions;
}

// 命令行参数处理
const command = process.argv[2];

if (command === 'deploy') {
  deployVersion();
} else if (command === 'rollback') {
  const version = process.argv[3];
  if (!version) {
    console.error('请指定要回滚的版本');
    process.exit(1);
  }
  rollback(version);
} else if (command === 'list') {
  listVersions();
} else {
  console.log('用法:');
  console.log('  node deploy-versioned.js deploy          # 部署新版本');
  console.log('  node deploy-versioned.js rollback <版本>  # 回滚到指定版本');
  console.log('  node deploy-versioned.js list            # 列出所有版本');
}

// OSS 安全配置最佳实践
const securityConfig = {
  // 1. 防盗链配置
  referer: {
    enabled: true,
    allowEmpty: false,  // 不允许空 Referer
    whitelist: [
      'https://myapp.com',
      'https://*.myapp.com',
      'https://localhost:*'  // 开发环境
    ],
    example: {
      valid: 'https://www.myapp.com/page',
      invalid: 'https://other-site.com'
    }
  },

  // 2. IP 黑白名单
  ipControl: {
    type: 'whitelist',  // 或 'blacklist'
    ips: [
      '192.168.1.0/24',
      '10.0.0.0/8'
    ],
    description: '只允许特定 IP 访问'
  },

  // 3. URL 签名认证（私有资源）
  urlSignature: {
    enabled: true,
    expireTime: 3600,  // 1 小时过期
    useCase: '用于需要权限控制的资源',
    example: 'https://bucket.oss.com/file.pdf?Expires=1234567890&OSSAccessKeyId=xxx&Signature=xxx'
  },

  // 4. CORS 配置
  cors: {
    allowedOrigins: [
      'https://myapp.com',
      'https://*.myapp.com'
    ],
    allowedMethods: ['GET', 'HEAD'],
    allowedHeaders: ['*'],
    exposeHeaders: ['ETag', 'Content-Length'],
    maxAgeSeconds: 3600
  },

  // 5. HTTPS 强制
  https: {
    enabled: true,
    hsts: {
      enabled: true,
      maxAge: 31536000,  // 1 年
      includeSubDomains: true
    }
  }
};

// 生成签名 URL
const OSS = require('ali-oss');

const client = new OSS({
  region: 'oss-cn-hangzhou',
  accessKeyId: process.env.OSS_ACCESS_KEY_ID,
  accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET,
  bucket: 'my-private-bucket'
});

// 生成临时访问 URL（1 小时有效）
async function generateSignedUrl(objectKey) {
  const url = client.signatureUrl(objectKey, {
    expires: 3600,  // 1 小时
    method: 'GET'
  });

  return url;
}

// 使用示例
const signedUrl = await generateSignedUrl('private/document.pdf');
console.log('临时访问链接:', signedUrl);
// 输出: https://bucket.oss.com/private/document.pdf?Expires=...&Signature=...

// 前端性能监控
class OSSPerformanceMonitor {
  constructor() {
    this.metrics = [];
  }

  // 监控资源加载性能
  monitorResourceLoading() {
    if (!window.PerformanceObserver) return;

    const observer = new PerformanceObserver((list) => {
      for (const entry of list.getEntries()) {
        // 只监控 OSS 资源
        if (entry.name.includes('oss-cn-') || entry.name.includes('cdn.myapp.com')) {
          this.recordMetric({
            url: entry.name,
            duration: entry.duration,
            size: entry.transferSize,
            type: entry.initiatorType,
            timestamp: Date.now()
          });
        }
      }
    });

    observer.observe({ entryTypes: ['resource'] });
  }

  // 记录指标
  recordMetric(metric) {
    this.metrics.push(metric);

    // 上报到监控系统
    this.reportToAnalytics(metric);
  }

  // 上报到分析系统
  reportToAnalytics(metric) {
    // 使用 Beacon API 上报，不阻塞页面
    if (navigator.sendBeacon) {
      const data = JSON.stringify({
        type: 'oss_performance',
        ...metric
      });

      navigator.sendBeacon('/api/analytics', data);
    }
  }

  // 获取统计信息
  getStats() {
    if (this.metrics.length === 0) return null;

    const durations = this.metrics.map(m => m.duration);
    const sizes = this.metrics.map(m => m.size);

    return {
      count: this.metrics.length,
      avgDuration: durations.reduce((a, b) => a + b, 0) / durations.length,
      maxDuration: Math.max(...durations),
      minDuration: Math.min(...durations),
      totalSize: sizes.reduce((a, b) => a + b, 0),
      avgSize: sizes.reduce((a, b) => a + b, 0) / sizes.length
    };
  }

  // 检测慢资源
  detectSlowResources(threshold = 1000) {
    return this.metrics.filter(m => m.duration > threshold);
  }
}

// 使用示例
const monitor = new OSSPerformanceMonitor();
monitor.monitorResourceLoading();

// 页面卸载时输出统计
window.addEventListener('beforeunload', () => {
  const stats = monitor.getStats();
  console.log('OSS 资源加载统计:', stats);

  const slowResources = monitor.detectSlowResources(1000);
  if (slowResources.length > 0) {
    console.warn('慢资源:', slowResources);
  }
});

// 成本优化策略
const costOptimization = {
  // 1. 存储类型优化
  storageClass: {
    standard: {
      price: '0.12元/GB/月',
      useCase: '频繁访问的热数据',
      example: 'HTML、CSS、JS 文件'
    },
    ia: {
      price: '0.08元/GB/月',
      useCase: '不频繁访问的温数据',
      example: '旧版本文件、历史数据',
      minStorage: '30 天'
    },
    archive: {
      price: '0.03元/GB/月',
      useCase: '长期归档的冷数据',
      example: '日志文件、备份数据',
      minStorage: '60 天',
      retrievalTime: '1 分钟'
    }
  },

  // 2. 生命周期管理
  lifecycle: {
    rules: [
      {
        name: '转换为低频访问',
        prefix: 'versions/',
        days: 30,
        action: 'transition to IA',
        description: '30 天后的版本文件转为低频存储'
      },
      {
        name: '删除旧版本',
        prefix: 'versions/',
        days: 90,
        action: 'delete',
        description: '90 天后删除旧版本'
      },
      {
        name: '归档日志',
        prefix: 'logs/',
        days: 7,
        action: 'transition to Archive',
        description: '7 天后的日志归档'
      }
    ]
  },

  // 3. 图片优化
  imageOptimization: {
    format: {
      original: 'PNG (1MB)',
      webp: 'WebP (300KB)',
      avif: 'AVIF (200KB)',
      saving: '80%'
    },
    processing: {
      resize: '按需缩放',
      quality: '智能压缩',
      format: '自动转换'
    },
    example: {
      original: 'https://oss.com/image.png',
      optimized: 'https://oss.com/image.png?x-oss-process=image/resize,w_800/quality,q_85/format,webp'
    }
  },

  // 4. CDN 流量优化
  cdnTraffic: {
    compression: {
      gzip: '减少 70% 流量',
      brotli: '减少 80% 流量'
    },
    caching: {
      hitRate: '95%+',
      saving: '减少 95% 回源流量'
    },
    lazyLoad: {
      description: '图片懒加载',
      saving: '减少 50% 初始流量'
    }
  }
};

// 配置 OSS 生命周期规则
const OSS = require('ali-oss');

const client = new OSS({
  region: 'oss-cn-hangzhou',
  accessKeyId: process.env.OSS_ACCESS_KEY_ID,
  accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET,
  bucket: 'my-frontend-app'
});

async function setupLifecycleRules() {
  await client.putBucketLifecycle('my-frontend-app', [
    {
      id: 'transition-old-versions',
      prefix: 'versions/',
      status: 'Enabled',
      days: 30,
      transitions: [
        {
          days: 30,
          storageClass: 'IA'  // 转为低频访问
        }
      ]
    },
    {
      id: 'delete-old-versions',
      prefix: 'versions/',
      status: 'Enabled',
      expiration: {
        days: 90  // 90 天后删除
      }
    },
    {
      id: 'archive-logs',
      prefix: 'logs/',
      status: 'Enabled',
      transitions: [
        {
          days: 7,
          storageClass: 'Archive'  // 归档
        }
      ]
    }
  ]);

  console.log('✅ 生命周期规则配置成功');
}

setupLifecycleRules();

// 问题：SPA 应用刷新页面 404
// 原因：OSS 找不到对应的文件路径

// 解决方案 1：配置 OSS 静态网站托管
const ossConfig = {
  indexDocument: 'index.html',
  errorDocument: 'index.html',  // 错误页面也返回 index.html
  description: '所有路由都返回 index.html，由前端路由处理'
};

// 解决方案 2：使用 CDN 回源规则
const cdnConfig = {
  rule: {
    type: 'rewrite',
    source: '/(.*)',
    target: '/index.html',
    condition: 'file not exists',
    description: '文件不存在时返回 index.html'
  }
};

// 解决方案 3：使用 Nginx 代理（混合部署）
const nginxConfig = `
server {
    listen 80;
    server_name www.myapp.com;

    location / {
        proxy_pass https://my-bucket.oss-cn-hangzhou.aliyuncs.com;
        proxy_intercept_errors on;
        error_page 404 = /index.html;
    }
}
`;

// 问题：前端请求 OSS 资源时出现 CORS 错误

// 解决方案：配置 OSS CORS 规则
const corsRules = [
  {
    allowedOrigin: ['https://myapp.com', 'https://*.myapp.com'],
    allowedMethod: ['GET', 'HEAD'],
    allowedHeader: ['*'],
    exposeHeader: ['ETag', 'Content-Length', 'Content-Type'],
    maxAgeSeconds: 3600
  }
];

// 使用 SDK 配置
async function setupCORS() {
  await client.putBucketCORS('my-frontend-app', corsRules);
  console.log('✅ CORS 配置成功');
}

// 问题：更新文件后用户仍然看到旧版本

// 解决方案 1：使用文件名 hash（推荐）
const viteConfig = {
  build: {
    rollupOptions: {
      output: {
        entryFileNames: 'static/js/[name].[hash].js',
        chunkFileNames: 'static/js/[name].[hash].js',
        assetFileNames: 'static/assets/[name].[hash].[ext]'
      }
    }
  }
};

// 解决方案 2：刷新 CDN 缓存
async function refreshCDN(urls) {
  const { exec } = require('child_process');

  const urlList = urls.join(',');

  exec(`aliyun cdn RefreshObjectCaches --ObjectPath ${urlList} --ObjectType File`,
    (error, stdout, stderr) => {
      if (error) {
        console.error('刷新失败:', error);
        return;
      }
      console.log('✅ CDN 缓存已刷新');
    }
  );
}

// 使用示例
refreshCDN([
  'https://cdn.myapp.com/index.html',
  'https://cdn.myapp.com/static/js/app.js'
]);

// 解决方案 3：版本号查询参数
const resourceUrl = `https://cdn.myapp.com/app.js?v=${Date.now()}`;

// 问题：大文件上传超时或失败

// 解决方案：使用分片上传
async function multipartUpload(filePath, objectKey) {
  const client = new OSS({
    region: 'oss-cn-hangzhou',
    accessKeyId: process.env.OSS_ACCESS_KEY_ID,
    accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET,
    bucket: 'my-frontend-app'
  });

  try {
    // 分片上传，每片 1MB
    const result = await client.multipartUpload(objectKey, filePath, {
      parallel: 4,        // 并发上传 4 个分片
      partSize: 1024 * 1024,  // 每片 1MB
      progress: (p, checkpoint) => {
        // 上传进度
        console.log(`上传进度: ${(p * 100).toFixed(2)}%`);

        // 保存断点信息，用于断点续传
        fs.writeFileSync('checkpoint.json', JSON.stringify(checkpoint));
      }
    });

    console.log('✅ 上传成功:', result);
    return result;

  } catch (error) {
    console.error('上传失败:', error);

    // 断点续传
    if (fs.existsSync('checkpoint.json')) {
      const checkpoint = JSON.parse(fs.readFileSync('checkpoint.json'));
      console.log('从断点继续上传...');

      const result = await client.multipartUpload(objectKey, filePath, {
        checkpoint,
        progress: (p) => {
          console.log(`续传进度: ${(p * 100).toFixed(2)}%`);
        }
      });

      return result;
    }

    throw error;
  }
}

// 使用示例
multipartUpload('./dist/large-file.zip', 'downloads/large-file.zip');

// 完整的部署流程
const deploymentWorkflow = {
  // 阶段 1: 准备工作
  preparation: {
    steps: [
      '1. 注册云服务账号（阿里云/腾讯云等）',
      '2. 创建 OSS Bucket',
      '3. 配置访问权限（公共读）',
      '4. 开启静态网站托管',
      '5. 获取 AccessKey'
    ]
  },

  // 阶段 2: 本地开发
  development: {
    steps: [
      '1. 配置构建工具（Vite/Webpack）',
      '2. 设置文件名 hash',
      '3. 编写部署脚本',
      '4. 配置环境变量'
    ]
  },

  // 阶段 3: 构建部署
  deployment: {
    steps: [
      '1. 执行 npm run build',
      '2. 上传文件到 OSS',
      '3. 设置缓存策略',
      '4. 刷新 CDN 缓存（可选）',
      '5. 验证部署结果'
    ]
  },

  // 阶段 4: CDN 配置
  cdn: {
    steps: [
      '1. 添加 CDN 域名',
      '2. 配置 CNAME 解析',
      '3. 配置 HTTPS 证书',
      '4. 设置缓存规则',
      '5. 开启性能优化'
    ]
  },

  // 阶段 5: 监控运维
  monitoring: {
    steps: [
      '1. 配置性能监控',
      '2. 设置告警规则',
      '3. 定期查看访问日志',
      '4. 优化成本配置',
      '5. 版本管理和回滚'
    ]
  }
};

// 推荐的技术栈
const recommendedStack = {
  buildTool: 'Vite',           // 构建工具
  ossProvider: '阿里云 OSS',    // OSS 服务商
  cdnProvider: '阿里云 CDN',    // CDN 服务商
  cicd: 'GitHub Actions',      // CI/CD 工具
  monitoring: '阿里云 ARMS',    // 监控工具

  workflow: {
    develop: 'git push → GitHub Actions',
    build: 'npm run build',
    deploy: 'upload to OSS',
    cdn: 'auto refresh CDN',
    monitor: 'performance tracking'
  }
};