# API Authentication
QWEN_API_KEY=your_api_key_here
QWEN_API_URL=https://api.qwen.com/v1  # Optional, defaults to official API

# Application Settings
NEXT_PUBLIC_APP_URL=http://localhost:3000
NEXTAUTH_SECRET=your_nextauth_secret_here
NEXTAUTH_URL=http://localhost:3000

# Model Configuration
QWEN_MODEL_VERSION=latest                    # Model version to use
QWEN_MAX_IMAGE_SIZE=4096                     # Maximum image dimension
QWEN_DEFAULT_QUALITY=high                    # Default output quality
QWEN_TIMEOUT=30000                          # Request timeout in milliseconds

# Rate Limiting
QWEN_RATE_LIMIT_RPM=60                      # Requests per minute
QWEN_RATE_LIMIT_RPD=1000                    # Requests per day
QWEN_CONCURRENT_REQUESTS=5                   # Max concurrent requests

# Caching
REDIS_URL=redis://localhost:6379            # Redis for caching
CACHE_TTL=3600                              # Cache time-to-live in seconds
ENABLE_CACHE=true                           # Enable/disable caching

# Storage
S3_BUCKET_NAME=your-bucket-name             # AWS S3 bucket for image storage
S3_REGION=us-east-1                         # AWS region
AWS_ACCESS_KEY_ID=your_access_key           # AWS credentials
AWS_SECRET_ACCESS_KEY=your_secret_key       # AWS credentials

# Monitoring
SENTRY_DSN=your_sentry_dsn                  # Error tracking
LOG_LEVEL=info                              # Logging level (debug, info, warn, error)
ENABLE_METRICS=true                         # Enable performance metrics

# Development
DEBUG_MODE=false                            # Enable debug logging
MOCK_API=false                              # Use mock API responses
DEV_TOOLS=false                             # Enable development tools

// Model configuration options
const modelConfig = {
  // Text editing models
  textEdit: {
    model: 'qwen-image-edit-text-v1',     // Standard text editing
    precision: 'high',                     // high, medium, low
    language: 'auto',                      // auto, en, zh, es, fr, etc.
    preserveStyle: true                     // Preserve original text style
  },
  
  // Semantic editing models
  semanticEdit: {
    model: 'qwen-image-edit-semantic-v1',  // Standard semantic editing
    strength: 0.7,                         // Edit strength (0.1-1.0)
    guidance: 7.5,                         // Guidance scale
    steps: 20                              // Inference steps
  },
  
  // Specialized models
  specialized: {
    portrait: 'qwen-image-edit-portrait-v1',    // Optimized for portraits
    landscape: 'qwen-image-edit-landscape-v1',  // Optimized for landscapes
    product: 'qwen-image-edit-product-v1',      // Optimized for products
    artistic: 'qwen-image-edit-artistic-v1'     // Optimized for artistic content
  }
};

// Automatic model selection based on content
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];
};

// Performance optimization settings
const performanceConfig = {
  // Image preprocessing
  preprocessing: {
    autoResize: true,                    // Automatically resize large images
    maxDimension: 2048,                  // Maximum width/height
    quality: 0.9,                       // JPEG quality (0.1-1.0)
    format: 'auto',                     // auto, jpeg, png, webp
    compression: 'balanced'              // fast, balanced, quality
  },
  
  // Processing optimization
  processing: {
    batchSize: 4,                       // Images per batch
    parallelRequests: 2,                // Concurrent API requests
    retryAttempts: 3,                   // Retry failed requests
    retryDelay: 1000,                   // Delay between retries (ms)
    timeout: 60000                      // Request timeout (ms)
  },
  
  // Memory management
  memory: {
    maxCacheSize: '500MB',              // Maximum cache size
    gcInterval: 300000,                 // Garbage collection interval (ms)
    preloadImages: false,               // Preload frequently used images
    lazyLoading: true                   // Enable lazy loading
  }
};

// Caching strategy configuration
const cacheConfig = {
  // Redis configuration
  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 // Default TTL in seconds
  },
  
  // Cache policies
  policies: {
    images: {
      ttl: 7200,                        // 2 hours for processed images
      maxSize: '100MB',                 // Maximum size per cached item
      compression: true                 // Compress cached data
    },
    metadata: {
      ttl: 86400,                       // 24 hours for metadata
      maxEntries: 10000                 // Maximum cache entries
    },
    results: {
      ttl: 3600,                        // 1 hour for API results
      invalidateOnError: true           // Clear cache on errors
    }
  }
};

// Security configuration
const securityConfig = {
  // API authentication
  authentication: {
    apiKeyHeader: 'X-API-Key',          // Custom API key header
    rateLimiting: {
      windowMs: 60000,                  // 1 minute window
      maxRequests: 100,                 // Max requests per window
      skipSuccessfulRequests: false,    // Count successful requests
      skipFailedRequests: false         // Count failed requests
    },
    ipWhitelist: [],                    // Allowed IP addresses
    userAgent: 'QwenImageEdit/1.0'      // Required user agent
  },
  
  // Input validation
  validation: {
    maxFileSize: '10MB',                // Maximum upload size
    allowedFormats: ['jpg', 'jpeg', 'png', 'webp'],
    maxInstructionLength: 1000,         // Max characters in instructions
    sanitizeInputs: true,               // Sanitize user inputs
    validateUrls: true                  // Validate image URLs
  },
  
  // Output security
  output: {
    watermarkResults: false,            // Add watermarks to results
    stripMetadata: true,                // Remove EXIF data
    contentFiltering: true,             // Filter inappropriate content
    virusScan: false                    // Scan for malware
  }
};

// CORS settings for web applications
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 hours
};

# Dockerfile
FROM node:18-alpine

# Set working directory
WORKDIR /app

# Copy package files
COPY package*.json ./
RUN npm ci --only=production

# Copy application code
COPY . .

# Build application
RUN npm run build

# Set environment variables
ENV NODE_ENV=production
ENV PORT=3000

# Expose port
EXPOSE 3000

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

# Start application
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 (for 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

// Logging configuration
const loggingConfig = {
  level: process.env.LOG_LEVEL || 'info',
  format: 'json',
  
  // Console logging
  console: {
    enabled: true,
    colorize: process.env.NODE_ENV !== 'production',
    timestamp: true
  },
  
  // File logging
  file: {
    enabled: true,
    filename: 'logs/app.log',
    maxSize: '10MB',
    maxFiles: 5,
    compress: true
  },
  
  // External logging services
  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
    }
  }
};

// Metrics and monitoring
const metricsConfig = {
  // Prometheus metrics
  prometheus: {
    enabled: true,
    endpoint: '/metrics',
    defaultLabels: {
      service: 'qwen-image-edit',
      version: process.env.APP_VERSION
    }
  },
  
  // Custom metrics
  custom: {
    requestDuration: true,      // Track request duration
    requestCount: true,         // Track request count
    errorRate: true,           // Track error rate
    imageProcessingTime: true, // Track processing time
    cacheHitRate: true,        // Track cache performance
    apiUsage: true             // Track API usage
  },
  
  // Health checks
  health: {
    endpoint: '/api/health',
    checks: [
      'database',
      'redis',
      'external-api',
      'disk-space',
      'memory-usage'
    ]
  }
};

// Configuration validation schema
import Joi from 'joi';

const configSchema = Joi.object({
  // Required configurations
  QWEN_API_KEY: Joi.string().required(),
  NODE_ENV: Joi.string().valid('development', 'production', 'test').default('development'),
  
  // Optional configurations with defaults
  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),
  
  // Cache configuration
  REDIS_URL: Joi.string().uri().optional(),
  CACHE_TTL: Joi.number().integer().min(60).max(86400).default(3600),
  
  // Security configuration
  RATE_LIMIT_RPM: Joi.number().integer().min(1).max(1000).default(60),
  MAX_FILE_SIZE: Joi.string().regex(/^\d+[KMGT]?B$/i).default('10MB')
});

// Validate configuration on startup
const validateConfig = () => {
  const { error, value } = configSchema.validate(process.env, {
    allowUnknown: true,
    stripUnknown: false
  });
  
  if (error) {
    throw new Error(`Configuration validation failed: ${error.message}`);
  }
  
  return value;
};

export const config = validateConfig();