reason-flow/server/config/appConfig.js

const path = require('path');
const logger = require('../utils/logger');

// Load environment variables
require('dotenv').config();

const appConfig = {
  // Server Configuration
  server: {
    port: parseInt(process.env.PORT) || 8000,
    host: process.env.HOST || 'localhost',
    env: process.env.NODE_ENV || 'development',
    corsOrigin: process.env.CORS_ORIGIN || 'http://localhost:3000'
  },

  // Database Configuration
  database: {
    host: process.env.DB_HOST || 'localhost',
    port: parseInt(process.env.DB_PORT) || 5432,
    name: process.env.DB_NAME || 'reason_flow',
    user: process.env.DB_USER || 'postgres',
    password: process.env.DB_PASSWORD,
    ssl: process.env.DB_SSL === 'true'
  },

  // API Configuration
  apis: {
    groq: {
      apiKey: process.env.GROQ_API_KEY,
      model: process.env.GROQ_MODEL || 'moonshotai/kimi-k2-instruct-0905',
      baseUrl: process.env.GROQ_BASE_URL || 'https://api.groq.com'
    },
    openai: {
      apiKey: process.env.OPENAI_API_KEY,
      baseUrl: process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1'
    },
    serp: {
      apiKey: process.env.SERP_API_KEY,
      engine: process.env.SERP_ENGINE || 'google'
    }
  },

  // Authentication Configuration
  auth: {
    jwtSecret: process.env.JWT_SECRET,
    jwtExpiresIn: process.env.JWT_EXPIRES_IN || '7d',
    adminEmail: process.env.ADMIN_EMAIL || 'admin@reasonflow.com',
    adminPassword: process.env.ADMIN_PASSWORD || 'admin123',
    adminFirstName: process.env.ADMIN_FIRST_NAME || 'Admin',
    adminLastName: process.env.ADMIN_LAST_NAME || 'User'
  },

  // File Upload Configuration
  upload: {
    maxFileSize: process.env.MAX_FILE_SIZE || '50MB',
    uploadPath: process.env.UPLOAD_PATH || './uploads',
    allowedFileTypes: (process.env.ALLOWED_FILE_TYPES || 'pdf,txt,doc,docx').split(',')
  },

  // Rate Limiting Configuration
  rateLimit: {
    enabled: process.env.RATE_LIMIT_ENABLED !== 'false',
    maxRequests: parseInt(process.env.RATE_LIMIT_MAX_REQUESTS) || 100,
    windowMs: parseInt(process.env.RATE_LIMIT_WINDOW_MS) || 900000
  },

  // Logging Configuration
  logging: {
    level: process.env.LOG_LEVEL || 'info',
    file: process.env.LOG_FILE || './logs/app.log',
    maxSize: process.env.LOG_MAX_SIZE || '10MB',
    maxFiles: parseInt(process.env.LOG_MAX_FILES) || 5
  },

  // Model Configuration
  models: {
    model1: {
      temperature: parseFloat(process.env.MODEL1_TEMPERATURE) || 0.3,
      maxTokens: parseInt(process.env.MODEL1_MAX_TOKENS) || 3000
    },
    queryModel: {
      temperature: parseFloat(process.env.QUERYMODEL_TEMPERATURE) || 0.5,
      maxTokens: parseInt(process.env.QUERYMODEL_MAX_TOKENS) || 4000
    }
  },

  // Fine-tuning Configuration
  fineTuning: {
    enabled: process.env.FINE_TUNING_ENABLED === 'true',
    schedule: process.env.FINE_TUNING_SCHEDULE || 'weekly',
    batchSize: parseInt(process.env.FINE_TUNING_BATCH_SIZE) || 10
  },

  // Feedback Configuration
  feedback: {
    processingEnabled: process.env.FEEDBACK_PROCESSING_ENABLED === 'true',
    batchSize: parseInt(process.env.FEEDBACK_BATCH_SIZE) || 50,
    schedule: process.env.FEEDBACK_PROCESSING_SCHEDULE || 'daily'
  },

  // Security Configuration
  security: {
    helmetEnabled: process.env.HELMET_ENABLED !== 'false',
    corsOrigin: process.env.CORS_ORIGIN || 'http://localhost:3000'
  },

  // Monitoring Configuration
  monitoring: {
    healthCheckEnabled: process.env.HEALTH_CHECK_ENABLED !== 'false',
    metricsEnabled: process.env.METRICS_ENABLED === 'true',
    performanceMonitoring: process.env.PERFORMANCE_MONITORING === 'true'
  },

  // Development Configuration
  development: {
    debugMode: process.env.DEBUG_MODE === 'true',
    verboseLogging: process.env.VERBOSE_LOGGING === 'true',
    hotReload: process.env.HOT_RELOAD === 'true'
  },

  // Redis Configuration
  redis: {
    url: process.env.REDIS_URL || 'redis://localhost:6379',
    password: process.env.REDIS_PASSWORD
  },

  // Vector Database Configuration
  vectorDb: {
    url: process.env.VECTOR_DB_URL,
    apiKey: process.env.VECTOR_DB_API_KEY
  }
};

// Validation function
const validateConfig = () => {
  const errors = [];
  const warnings = [];

  // Required fields validation
  if (!appConfig.apis.groq.apiKey) {
    errors.push('GROQ_API_KEY is required');
  }

  if (!appConfig.auth.jwtSecret) {
    errors.push('JWT_SECRET is required');
  }

  if (!appConfig.database.password) {
    errors.push('DB_PASSWORD is required');
  }

  // Production-specific validations
  if (appConfig.server.env === 'production') {
    if (appConfig.auth.jwtSecret === 'dev_secret_key_change_in_production') {
      errors.push('JWT_SECRET must be changed for production');
    }

    if (!appConfig.apis.openai.apiKey) {
      warnings.push('OPENAI_API_KEY is recommended for production');
    }

    if (appConfig.database.ssl === false) {
      warnings.push('Database SSL is recommended for production');
    }
  }

  // Development warnings
  if (appConfig.server.env === 'development') {
    if (appConfig.auth.jwtSecret === 'dev_secret_key_change_in_production') {
      warnings.push('Using default JWT secret for development');
    }
  }

  // Log warnings
  warnings.forEach(warning => {
    logger.warn(`Configuration warning: ${warning}`);
  });

  // Throw errors
  if (errors.length > 0) {
    const errorMessage = `Configuration errors: ${errors.join(', ')}`;
    logger.error(errorMessage);
    throw new Error(errorMessage);
  }

  logger.info('Configuration validated successfully');
  return true;
};

// Get configuration for specific environment
const getConfigForEnv = (env) => {
  const envConfig = { ...appConfig };
  
  switch (env) {
    case 'production':
      envConfig.server.port = parseInt(process.env.PORT) || 8000;
      envConfig.server.host = '0.0.0.0';
      envConfig.development.debugMode = false;
      envConfig.development.verboseLogging = false;
      envConfig.logging.level = 'info';
      break;
      
    case 'test':
      envConfig.server.port = parseInt(process.env.PORT) || 8001;
      envConfig.database.name = process.env.DB_NAME || 'reason_flow_test';
      envConfig.development.debugMode = false;
      envConfig.logging.level = 'error';
      break;
      
    case 'development':
    default:
      envConfig.development.debugMode = true;
      envConfig.logging.level = 'debug';
      break;
  }
  
  return envConfig;
};

module.exports = {
  appConfig,
  validateConfig,
  getConfigForEnv
};