# API 认证
QWEN_API_KEY=your_api_key_here
QWEN_API_URL=https://api.qwen.com/v1  # 可选，默认为官方 API

# 应用设置
NEXT_PUBLIC_APP_URL=http://localhost:3000
NEXTAUTH_SECRET=your_nextauth_secret_here
NEXTAUTH_URL=http://localhost:3000

# 模型配置
QWEN_MODEL_VERSION=latest                    # 使用的模型版本
QWEN_MAX_IMAGE_SIZE=4096                     # 最大图片尺寸
QWEN_DEFAULT_QUALITY=high                    # 默认输出质量
QWEN_TIMEOUT=30000                          # 请求超时时间（毫秒）

# 速率限制
QWEN_RATE_LIMIT_RPM=60                      # 每分钟请求数
QWEN_RATE_LIMIT_RPD=1000                    # 每天请求数
QWEN_CONCURRENT_REQUESTS=5                   # 最大并发请求数

# 缓存
REDIS_URL=redis://localhost:6379            # Redis 缓存
CACHE_TTL=3600                              # 缓存生存时间（秒）
ENABLE_CACHE=true                           # 启用/禁用缓存

# 存储
S3_BUCKET_NAME=your-bucket-name             # AWS S3 存储桶
S3_REGION=us-east-1                         # AWS 区域
AWS_ACCESS_KEY_ID=your_access_key           # AWS 凭证
AWS_SECRET_ACCESS_KEY=your_secret_key       # AWS 凭证

# 监控
SENTRY_DSN=your_sentry_dsn                  # 错误追踪
LOG_LEVEL=info                              # 日志级别（debug, info, warn, error）
ENABLE_METRICS=true                         # 启用性能指标

# 开发
DEBUG_MODE=false                            # 启用调试日志
MOCK_API=false                              # 使用模拟 API 响应
DEV_TOOLS=false                             # 启用开发工具

// 模型配置选项
const modelConfig = {
  // 文本编辑模型
  textEdit: {
    model: 'qwen-image-edit-text-v1',     // 标准文本编辑
    precision: 'high',                     // high, medium, low
    language: 'auto',                      // auto, en, zh, es, fr 等
    preserveStyle: true                     // 保留原始文本样式
  },
  
  // 语义编辑模型
  semanticEdit: {
    model: 'qwen-image-edit-semantic-v1',  // 标准语义编辑
    strength: 0.7,                         // 编辑强度（0.1-1.0）
    guidance: 7.5,                         // 引导比例
    steps: 20                              // 推理步数
  },
  
  // 专用模型
  specialized: {
    portrait: 'qwen-image-edit-portrait-v1',    // 人像优化
    landscape: 'qwen-image-edit-landscape-v1',  // 风景优化
    product: 'qwen-image-edit-product-v1',      // 产品优化
    artistic: 'qwen-image-edit-artistic-v1'     // 艺术内容优化
  }
};

// 基于内容自动选择模型
const selectOptimalModel = (imageType: string, editType: string) => {
  const modelMap = {
    'portrait': {
      'text-edit': 'qwen-image-edit-portrait-text-v1',
      'semantic-edit': 'qwen-image-edit-portrait-v1'
    },
    'product': {
      'text-edit': 'qwen-image-edit-product-text-v1',
      'semantic-edit': 'qwen-image-edit-product-v1'
    },
    'general': {
      'text-edit': 'qwen-image-edit-text-v1',
      'semantic-edit': 'qwen-image-edit-semantic-v1'
    }
  };
  
  return modelMap[imageType]?.[editType] || modelMap['general'][editType];
};

// 性能优化设置
const performanceConfig = {
  // 图像预处理
  preprocessing: {
    autoResize: true,                    // 自动调整大图片尺寸
    maxDimension: 2048,                  // 最大宽度/高度
    quality: 0.9,                       // JPEG 质量（0.1-1.0）
    format: 'auto',                     // auto, jpeg, png, webp
    compression: 'balanced'              // fast, balanced, quality
  },
  
  // 处理优化
  processing: {
    batchSize: 4,                       // 每批图片数量
    parallelRequests: 2,                // 并发 API 请求数
    retryAttempts: 3,                   // 重试失败请求次数
    retryDelay: 1000,                   // 重试间隔（毫秒）
    timeout: 60000                      // 请求超时（毫秒）
  },
  
  // 内存管理
  memory: {
    maxCacheSize: '500MB',              // 最大缓存大小
    gcInterval: 300000,                 // 垃圾回收间隔（毫秒）
    preloadImages: false,               // 预加载常用图片
    lazyLoading: true                   // 启用懒加载
  }
};

// 缓存策略配置
const cacheConfig = {
  // Redis 配置
  redis: {
    host: process.env.REDIS_HOST || 'localhost',
    port: parseInt(process.env.REDIS_PORT || '6379'),
    password: process.env.REDIS_PASSWORD,
    db: parseInt(process.env.REDIS_DB || '0'),
    keyPrefix: 'qwen-image-edit:',
    ttl: 3600 // 默认 TTL（秒）
  },
  
  // 缓存策略
  policies: {
    images: {
      ttl: 7200,                        // 处理后图片缓存 2 小时
      maxSize: '100MB',                 // 每个缓存项最大大小
      compression: true                 // 压缩缓存数据
    },
    metadata: {
      ttl: 86400,                       // 元数据缓存 24 小时
      maxEntries: 10000                 // 最大缓存条目数
    },
    results: {
      ttl: 3600,                        // API 结果缓存 1 小时
      invalidateOnError: true           // 错误时清除缓存
    }
  }
};

// 安全配置
const securityConfig = {
  // API 认证
  authentication: {
    apiKeyHeader: 'X-API-Key',          // 自定义 API 密钥头
    rateLimiting: {
      windowMs: 60000,                  // 1 分钟窗口
      maxRequests: 100,                 // 每窗口最大请求数
      skipSuccessfulRequests: false,    // 计算成功请求
      skipFailedRequests: false         // 计算失败请求
    },
    ipWhitelist: [],                    // 允许的 IP 地址
    userAgent: 'QwenImageEdit/1.0'      // 必需的用户代理
  },
  
  // 输入验证
  validation: {
    maxFileSize: '10MB',                // 最大上传大小
    allowedFormats: ['jpg', 'jpeg', 'png', 'webp'],
    maxInstructionLength: 1000,         // 指令最大字符数
    sanitizeInputs: true,               // 清理用户输入
    validateUrls: true                  // 验证图片 URL
  },
  
  // 输出安全
  output: {
    watermarkResults: false,            // 为结果添加水印
    stripMetadata: true,                // 移除 EXIF 数据
    contentFiltering: true,             // 过滤不当内容
    virusScan: false                    // 扫描恶意软件
  }
};

// Web 应用的 CORS 设置
const corsConfig = {
  origin: [
    'http://localhost:3000',
    'https://yourdomain.com',
    'https://*.yourdomain.com'
  ],
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: [
    'Content-Type',
    'Authorization',
    'X-API-Key',
    'X-Requested-With'
  ],
  credentials: true,
  maxAge: 86400 // 24 小时
};

# Dockerfile
FROM node:18-alpine

# 设置工作目录
WORKDIR /app

# 复制包文件
COPY package*.json ./
RUN npm ci --only=production

# 复制应用代码
COPY . .

# 构建应用
RUN npm run build

# 设置环境变量
ENV NODE_ENV=production
ENV PORT=3000

# 暴露端口
EXPOSE 3000

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD curl -f http://localhost:3000/api/health || exit 1

# 启动应用
CMD ["npm", "start"]

# docker-compose.yml
version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - QWEN_API_KEY=${QWEN_API_KEY}
      - REDIS_URL=redis://redis:6379
    depends_on:
      - redis
    restart: unless-stopped
    
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    restart: unless-stopped
    
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - app
    restart: unless-stopped

volumes:
  redis_data:

# k8s-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: qwen-image-edit
  labels:
    app: qwen-image-edit
spec:
  replicas: 3
  selector:
    matchLabels:
      app: qwen-image-edit
  template:
    metadata:
      labels:
        app: qwen-image-edit
    spec:
      containers:
      - name: app
        image: qwen-image-edit:latest
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "production"
        - name: QWEN_API_KEY
          valueFrom:
            secretKeyRef:
              name: qwen-secrets
              key: api-key
        - name: REDIS_URL
          value: "redis://redis-service:6379"
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /api/health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /api/ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: qwen-image-edit-service
spec:
  selector:
    app: qwen-image-edit
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: LoadBalancer

# serverless.yml（用于 AWS Lambda）
service: qwen-image-edit

provider:
  name: aws
  runtime: nodejs18.x
  region: us-east-1
  environment:
    QWEN_API_KEY: ${env:QWEN_API_KEY}
    NODE_ENV: production
  iamRoleStatements:
    - Effect: Allow
      Action:
        - s3:GetObject
        - s3:PutObject
      Resource: "arn:aws:s3:::your-bucket/*"

functions:
  textEdit:
    handler: src/handlers/textEdit.handler
    events:
      - http:
          path: /api/text-edit
          method: post
          cors: true
    timeout: 30
    memorySize: 1024
    
  semanticEdit:
    handler: src/handlers/semanticEdit.handler
    events:
      - http:
          path: /api/semantic-edit
          method: post
          cors: true
    timeout: 60
    memorySize: 2048

plugins:
  - serverless-webpack
  - serverless-offline

// 日志配置
const loggingConfig = {
  level: process.env.LOG_LEVEL || 'info',
  format: 'json',
  
  // 控制台日志
  console: {
    enabled: true,
    colorize: process.env.NODE_ENV !== 'production',
    timestamp: true
  },
  
  // 文件日志
  file: {
    enabled: true,
    filename: 'logs/app.log',
    maxSize: '10MB',
    maxFiles: 5,
    compress: true
  },
  
  // 外部日志服务
  external: {
    sentry: {
      enabled: !!process.env.SENTRY_DSN,
      dsn: process.env.SENTRY_DSN,
      environment: process.env.NODE_ENV,
      tracesSampleRate: 0.1
    },
    datadog: {
      enabled: !!process.env.DD_API_KEY,
      apiKey: process.env.DD_API_KEY,
      service: 'qwen-image-edit',
      version: process.env.APP_VERSION
    }
  }
};

// 指标和监控
const metricsConfig = {
  // Prometheus 指标
  prometheus: {
    enabled: true,
    endpoint: '/metrics',
    defaultLabels: {
      service: 'qwen-image-edit',
      version: process.env.APP_VERSION
    }
  },
  
  // 自定义指标
  custom: {
    requestDuration: true,      // 跟踪请求持续时间
    requestCount: true,         // 跟踪请求计数
    errorRate: true,           // 跟踪错误率
    imageProcessingTime: true, // 跟踪处理时间
    cacheHitRate: true,        // 跟踪缓存性能
    apiUsage: true             // 跟踪 API 使用情况
  },
  
  // 健康检查
  health: {
    endpoint: '/api/health',
    checks: [
      'database',
      'redis',
      'external-api',
      'disk-space',
      'memory-usage'
    ]
  }
};

// 配置验证模式
import Joi from 'joi';

const configSchema = Joi.object({
  // 必需配置
  QWEN_API_KEY: Joi.string().required(),
  NODE_ENV: Joi.string().valid('development', 'production', 'test').default('development'),
  
  // 带默认值的可选配置
  QWEN_API_URL: Joi.string().uri().default('https://api.qwen.com/v1'),
  QWEN_TIMEOUT: Joi.number().integer().min(1000).max(300000).default(30000),
  QWEN_MAX_IMAGE_SIZE: Joi.number().integer().min(512).max(8192).default(4096),
  
  // 缓存配置
  REDIS_URL: Joi.string().uri().optional(),
  CACHE_TTL: Joi.number().integer().min(60).max(86400).default(3600),
  
  // 安全配置
  RATE_LIMIT_RPM: Joi.number().integer().min(1).max(1000).default(60),
  MAX_FILE_SIZE: Joi.string().regex(/^\d+[KMGT]?B$/i).default('10MB')
});

// 启动时验证配置
const validateConfig = () => {
  const { error, value } = configSchema.validate(process.env, {
    allowUnknown: true,
    stripUnknown: false
  });
  
  if (error) {
    throw new Error(`配置验证失败: ${error.message}`);
  }
  
  return value;
};

export const config = validateConfig();