# .env
NODE_ENV=development
PORT=3000

# Base de données
DATABASE_URL=postgresql://user:password@localhost:5432/company_manager
DATABASE_POOL_SIZE=20

# Redis
REDIS_URL=redis://localhost:6379
REDIS_PASSWORD=secure_password

# Stockage
AWS_REGION=eu-west-1
AWS_ACCESS_KEY_ID=your_access_key
AWS_SECRET_ACCESS_KEY=your_secret_key
S3_BUCKET=company-manager-dev

# Sécurité
JWT_SECRET=your_jwt_secret
ENCRYPTION_KEY=your_encryption_key

// config/environment.ts
interface Environment {
  database: {
    url: string;
    poolSize: number;
    ssl: boolean;
  };
  redis: {
    url: string;
    password: string;
    tls: boolean;
  };
  storage: {
    bucket: string;
    region: string;
  };
}

const environments: Record<string, Environment> = {
  production: {
    database: {
      url: process.env.DATABASE_URL!,
      poolSize: 20,
      ssl: true,
    },
    redis: {
      url: process.env.REDIS_URL!,
      password: process.env.REDIS_PASSWORD!,
      tls: true,
    },
    storage: {
      bucket: process.env.S3_BUCKET!,
      region: process.env.AWS_REGION!,
    },
  },
  staging: {
    // Configuration staging
  },
  development: {
    // Configuration développement
  },
};

// next.config.mjs
import { withConfig } from './config/with-config';

export default withConfig({
  output: 'standalone',
  experimental: {
    serverActions: true,
  },
  images: {
    domains: ['storage.googleapis.com'],
  },
});

// prisma/config.ts
import { PrismaClient } from "@company-manager/db";;

const prismaConfig = {
  log: ['query', 'info', 'warn', 'error'],
  errorFormat: 'pretty',
  datasources: {
    db: {
      url: process.env.DATABASE_URL,
    },
  },
};

export const prisma = new PrismaClient(prismaConfig);

// config/payment.ts
export const paymentConfig = {
  stripe: {
    secretKey: process.env.STRIPE_SECRET_KEY,
    webhookSecret: process.env.STRIPE_WEBHOOK_SECRET,
    apiVersion: '2023-10-16',
  },
  paypal: {
    clientId: process.env.PAYPAL_CLIENT_ID,
    clientSecret: process.env.PAYPAL_CLIENT_SECRET,
    environment: process.env.NODE_ENV === 'production' ? 'live' : 'sandbox',
  },
};

// config/email.ts
export const emailConfig = {
  smtp: {
    host: process.env.SMTP_HOST,
    port: parseInt(process.env.SMTP_PORT || '587'),
    secure: process.env.NODE_ENV === 'production',
    auth: {
      user: process.env.SMTP_USER,
      pass: process.env.SMTP_PASSWORD,
    },
  },
  from: {
    name: 'Company Manager',
    email: 'noreply@inklura.fr',
  },
  templates: {
    welcome: 'welcome-template',
    resetPassword: 'reset-password-template',
    orderConfirmation: 'order-confirmation-template',
  },
};

// config/cors.ts
export const corsConfig = {
  origin: process.env.CORS_ORIGIN?.split(',') || [
    'https://inklura.fr',
  ],
  methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
  allowedHeaders: ['Content-Type', 'Authorization'],
  exposedHeaders: ['Content-Range', 'X-Total-Count'],
  credentials: true,
  maxAge: 86400, // 24 heures
};

// config/rate-limit.ts
export const rateLimitConfig = {
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // limite par IP
  standardHeaders: true,
  legacyHeaders: false,
  handler: (req: any, res: any) => {
    res.status(429).json({
      error: 'Too many requests, please try again later.',
    });
  },
};

// config/logging.ts
import winston from 'winston';

export const loggingConfig = {
  level: process.env.LOG_LEVEL || 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    new winston.transports.File({
      filename: 'logs/error.log',
      level: 'error',
    }),
    new winston.transports.File({
      filename: 'logs/combined.log',
    }),
  ],
};

// config/sentry.ts
export const sentryConfig = {
  dsn: process.env.SENTRY_DSN,
  environment: process.env.NODE_ENV,
  tracesSampleRate: 1.0,
  integrations: [
    new Sentry.Integrations.Http({ tracing: true }),
    new Sentry.Integrations.Express(),
  ],
};

// config/cache.ts
import Redis from 'ioredis';

export const redisConfig = {
  host: process.env.REDIS_HOST || 'localhost',
  port: parseInt(process.env.REDIS_PORT || '6379'),
  password: process.env.REDIS_PASSWORD,
  tls: process.env.NODE_ENV === 'production' ? {} : undefined,
  retryStrategy: (times: number) => {
    return Math.min(times * 50, 2000);
  },
};

export const redis = new Redis(redisConfig);

// config/lru.ts
import { LRUCache } from 'lru-cache';

export const lruConfig = {
  max: 500,
  ttl: 1000 * 60 * 5, // 5 minutes
};

export const cache = new LRUCache(lruConfig);