// Your perfectly tested but architecturally broken backend
class UserController {
  async createUser(req, res) {
    try {
      // Everything works, tests pass, but maintainability is zero
      const userData = req.body;

      // Validation mixed with business logic
      if (!userData.email || !userData.password) {
        return res.status(400).json({ error: "Missing fields" });
      }

      if (userData.password.length < 8) {
        return res.status(400).json({ error: "Password too short" });
      }

      // Database operations mixed with HTTP logic
      const existingUser = await db.users.findOne({ email: userData.email });
      if (existingUser) {
        return res.status(409).json({ error: "User exists" });
      }

      // Cryptography in the controller
      const salt = crypto.randomBytes(16);
      const hashedPassword = crypto.pbkdf2Sync(
        userData.password,
        salt,
        100000,
        64,
        "sha512"
      );

      // Business rules scattered everywhere
      const role = userData.email.includes("@company.com") ? "admin" : "user";
      const department = userData.email.includes("eng@")
        ? "engineering"
        : "general";

      // Direct database manipulation
      const newUser = await db.users.insertOne({
        email: userData.email,
        password: hashedPassword.toString("hex"),
        salt: salt.toString("hex"),
        role,
        department,
        createdAt: new Date(),
        isActive: true,
        loginAttempts: 0,
        lastLogin: null,
      });

      // Email sending in the controller
      await sendWelcomeEmail(newUser.email, newUser.role);

      // Audit logging mixed in
      await db.auditLog.insertOne({
        action: "user_created",
        userId: newUser._id,
        timestamp: new Date(),
        ip: req.ip,
      });

      res.status(201).json({
        user: {
          id: newUser._id,
          email: newUser.email,
          role: newUser.role,
        },
      });

      // The problems that will destroy your team's velocity:
      // - Impossible to test individual business rules
      // - Can't reuse user creation logic elsewhere
      // - Changes require touching multiple concerns simultaneously
      // - New developers spend days understanding one function
      // - Bug fixes break unrelated functionality
      // - Code reviews become painful archeological expeditions
    } catch (error) {
      console.error("Error:", error); // Useless error handling
      res.status(500).json({ error: "Something went wrong" });
    }
  }
}

// What happens when code quality is ignored:
const codeQualityFailureImpact = {
  developmentVelocity: {
    problem: "Simple feature requests take weeks instead of days",
    cause: "Developers spend 80% of time deciphering existing code",
    impact: "Team velocity drops 60% after 6 months",
    solution: "Complete refactoring project costing 4 months",
  },

  productionIncidents: {
    problem: "Bug fix in user registration breaks payment processing",
    cause: "Tightly coupled code with shared dependencies",
    impact: "$2.3M revenue lost during 8-hour outage",
    rootCause: "No separation of concerns or proper abstraction layers",
  },

  teamMorale: {
    problem: "Senior developers leaving for 'cleaner codebases'",
    cause: "Constant firefighting instead of building features",
    impact: "Knowledge drain and 6-month hiring delays",
    prevention: "Code quality standards enforced from day one",
  },

  // Beautiful tests on ugly code still produce ugly systems
  // that nobody wants to maintain or extend
};

// ❌ Code that works but makes developers cry
class OrderProcessor {
  processOrder(orderData, userId, paymentInfo, shippingAddress, promoCode) {
    // Function does everything and trusts nothing
    if (!orderData || !orderData.items || orderData.items.length === 0) {
      throw new Error("Invalid order data");
    }

    let totalAmount = 0;
    for (let i = 0; i < orderData.items.length; i++) {
      const item = orderData.items[i];
      const product = db.products.findOne({ _id: item.productId });
      if (!product) {
        throw new Error("Product not found: " + item.productId);
      }
      if (product.stock < item.quantity) {
        throw new Error("Insufficient stock for " + product.name);
      }
      totalAmount += product.price * item.quantity;
    }

    // Discount calculation buried in the middle
    if (promoCode) {
      const promo = db.promoCodes.findOne({ code: promoCode });
      if (promo && promo.expiresAt > new Date()) {
        if (promo.type === "percentage") {
          totalAmount = totalAmount * (1 - promo.value / 100);
        } else if (promo.type === "fixed") {
          totalAmount = Math.max(0, totalAmount - promo.value);
        }
      }
    }

    // Payment processing mixed with order logic
    const paymentResult = paymentGateway.charge(
      paymentInfo.cardNumber,
      paymentInfo.expiryMonth,
      paymentInfo.expiryYear,
      paymentInfo.cvv,
      totalAmount
    );

    if (!paymentResult.success) {
      throw new Error("Payment failed: " + paymentResult.error);
    }

    // Inventory updates scattered throughout
    for (let i = 0; i < orderData.items.length; i++) {
      const item = orderData.items[i];
      db.products.updateOne(
        { _id: item.productId },
        { $inc: { stock: -item.quantity } }
      );
    }

    // Order creation at the end
    const order = {
      userId,
      items: orderData.items,
      totalAmount,
      paymentId: paymentResult.transactionId,
      shippingAddress,
      status: "confirmed",
      createdAt: new Date(),
    };

    const savedOrder = db.orders.insertOne(order);

    // Notification logic embedded
    emailService.sendOrderConfirmation(userId, savedOrder._id);

    return savedOrder;
  }
}

// Problems that will haunt your dreams:
// - 70-line function doing 8 different things
// - No way to test discount logic in isolation
// - Payment failure leaves inventory in inconsistent state
// - Adding tax calculation requires reading entire function
// - Impossible to reuse discount logic elsewhere

// ✅ Clean, maintainable order processing system
class OrderService {
  constructor() {
    this.inventoryService = new InventoryService();
    this.paymentService = new PaymentService();
    this.discountService = new DiscountService();
    this.notificationService = new NotificationService();
    this.orderRepository = new OrderRepository();
  }

  async processOrder(orderRequest) {
    try {
      // Single responsibility: orchestrate the order process
      await this.validateOrderRequest(orderRequest);

      const orderCalculation = await this.calculateOrderTotals(orderRequest);
      const reservationId = await this.reserveInventory(orderRequest.items);

      try {
        const paymentResult = await this.processPayment(
          orderCalculation,
          orderRequest.paymentInfo
        );

        const order = await this.createOrder({
          ...orderRequest,
          calculation: orderCalculation,
          paymentId: paymentResult.transactionId,
        });

        await this.confirmInventoryReservation(reservationId);
        await this.sendOrderConfirmation(order);

        return order;
      } catch (paymentError) {
        // Clean error handling with proper cleanup
        await this.releaseInventoryReservation(reservationId);
        throw new OrderProcessingError("Payment failed", paymentError);
      }
    } catch (error) {
      // Centralized error handling with context
      this.handleOrderError(error, orderRequest);
      throw error;
    }
  }

  async validateOrderRequest(orderRequest) {
    const validator = new OrderRequestValidator();

    const validationResult = await validator.validate(orderRequest);
    if (!validationResult.isValid) {
      throw new ValidationError(
        "Invalid order request",
        validationResult.errors
      );
    }
  }

  async calculateOrderTotals(orderRequest) {
    const calculator = new OrderCalculator(this.discountService);

    return await calculator.calculate({
      items: orderRequest.items,
      promoCode: orderRequest.promoCode,
      shippingAddress: orderRequest.shippingAddress,
    });
  }

  async reserveInventory(items) {
    // Delegate to specialized service with clear responsibility
    return await this.inventoryService.reserveItems(items);
  }

  async processPayment(orderCalculation, paymentInfo) {
    // Payment processing isolated and testable
    return await this.paymentService.processPayment({
      amount: orderCalculation.total,
      currency: orderCalculation.currency,
      paymentMethod: paymentInfo,
    });
  }

  async createOrder(orderData) {
    const order = Order.create({
      userId: orderData.userId,
      items: orderData.items,
      calculation: orderData.calculation,
      paymentId: orderData.paymentId,
      shippingAddress: orderData.shippingAddress,
    });

    return await this.orderRepository.save(order);
  }
}

// Specialized classes with single responsibilities
class OrderCalculator {
  constructor(discountService) {
    this.discountService = discountService;
  }

  async calculate(calculationRequest) {
    const subtotal = this.calculateSubtotal(calculationRequest.items);
    const shipping = this.calculateShipping(calculationRequest.shippingAddress);
    const tax = this.calculateTax(subtotal, calculationRequest.shippingAddress);

    const discount = await this.discountService.calculateDiscount({
      subtotal,
      promoCode: calculationRequest.promoCode,
    });

    const total = subtotal + shipping + tax - discount.amount;

    return {
      subtotal,
      shipping,
      tax,
      discount,
      total,
      currency: "USD",
    };
  }

  calculateSubtotal(items) {
    return items.reduce((sum, item) => {
      return sum + item.price * item.quantity;
    }, 0);
  }

  calculateShipping(shippingAddress) {
    // Shipping calculation logic isolated and testable
    const shippingCalculator = new ShippingCalculator();
    return shippingCalculator.calculateCost(shippingAddress);
  }

  calculateTax(subtotal, shippingAddress) {
    // Tax calculation separated from business logic
    const taxCalculator = new TaxCalculator();
    return taxCalculator.calculateTax(subtotal, shippingAddress);
  }
}

class DiscountService {
  constructor() {
    this.promoRepository = new PromoRepository();
  }

  async calculateDiscount(discountRequest) {
    if (!discountRequest.promoCode) {
      return { amount: 0, reason: "No promo code provided" };
    }

    const promoCode = await this.promoRepository.findActiveByCode(
      discountRequest.promoCode
    );

    if (!promoCode) {
      return { amount: 0, reason: "Invalid or expired promo code" };
    }

    const discount = this.applyDiscount(promoCode, discountRequest.subtotal);

    await this.recordDiscountUsage(promoCode, discount);

    return discount;
  }

  applyDiscount(promoCode, subtotal) {
    switch (promoCode.type) {
      case "percentage":
        return {
          amount: subtotal * (promoCode.value / 100),
          type: "percentage",
          value: promoCode.value,
        };

      case "fixed":
        return {
          amount: Math.min(promoCode.value, subtotal),
          type: "fixed",
          value: promoCode.value,
        };

      case "buy_one_get_one":
        return this.calculateBOGODiscount(promoCode, subtotal);

      default:
        throw new Error(`Unsupported discount type: ${promoCode.type}`);
    }
  }

  calculateBOGODiscount(promoCode, subtotal) {
    // Complex discount logic isolated in its own method
    // Easy to test, easy to modify, easy to understand
    const applicableItems = this.findApplicableItems(
      promoCode.applicableProducts
    );
    const discount = this.calculateBOGOAmount(applicableItems);

    return {
      amount: discount,
      type: "buy_one_get_one",
      applicableItems: applicableItems.length,
    };
  }
}

// Domain objects with clear responsibilities
class Order {
  static create(orderData) {
    const order = new Order();
    order.id = generateId();
    order.userId = orderData.userId;
    order.items = orderData.items;
    order.calculation = orderData.calculation;
    order.paymentId = orderData.paymentId;
    order.shippingAddress = orderData.shippingAddress;
    order.status = OrderStatus.CONFIRMED;
    order.createdAt = new Date();

    // Domain validation in the domain object
    order.validate();

    return order;
  }

  validate() {
    if (!this.userId) {
      throw new DomainError("Order must have a user ID");
    }

    if (!this.items || this.items.length === 0) {
      throw new DomainError("Order must have at least one item");
    }

    if (!this.calculation || this.calculation.total <= 0) {
      throw new DomainError("Order total must be greater than zero");
    }

    // Domain rules enforced at the domain level
    if (this.calculation.total > 10000 && !this.requiresApproval) {
      throw new DomainError("Large orders require approval");
    }
  }

  cancel() {
    if (this.status !== OrderStatus.CONFIRMED) {
      throw new DomainError("Can only cancel confirmed orders");
    }

    this.status = OrderStatus.CANCELLED;
    this.cancelledAt = new Date();
  }

  ship(trackingNumber) {
    if (this.status !== OrderStatus.CONFIRMED) {
      throw new DomainError("Can only ship confirmed orders");
    }

    this.status = OrderStatus.SHIPPED;
    this.trackingNumber = trackingNumber;
    this.shippedAt = new Date();
  }
}

// Clean, focused error handling
class OrderProcessingError extends Error {
  constructor(message, originalError) {
    super(message);
    this.name = "OrderProcessingError";
    this.originalError = originalError;
  }
}

class ValidationError extends Error {
  constructor(message, validationErrors) {
    super(message);
    this.name = "ValidationError";
    this.validationErrors = validationErrors;
  }
}

class DomainError extends Error {
  constructor(message) {
    super(message);
    this.name = "DomainError";
  }
}

// ✅ SOLID principles applied to real backend systems

// S - Single Responsibility Principle
// Each class has one reason to change
class UserNotificationService {
  constructor(emailService, smsService, pushService) {
    this.emailService = emailService;
    this.smsService = smsService;
    this.pushService = pushService;
  }

  // Only responsible for coordinating notifications
  async notifyUser(userId, notification) {
    const user = await this.getUserPreferences(userId);
    const notificationStrategies = this.selectNotificationStrategies(
      user.preferences,
      notification.urgency
    );

    const results = await Promise.allSettled(
      notificationStrategies.map((strategy) =>
        strategy.send(user, notification)
      )
    );

    return this.aggregateResults(results);
  }

  selectNotificationStrategies(preferences, urgency) {
    const strategies = [];

    if (preferences.email && urgency !== "low") {
      strategies.push(this.emailService);
    }

    if (preferences.sms && urgency === "high") {
      strategies.push(this.smsService);
    }

    if (preferences.push) {
      strategies.push(this.pushService);
    }

    return strategies;
  }
}

// O - Open/Closed Principle
// Open for extension, closed for modification
class PaymentProcessor {
  constructor() {
    this.processors = new Map();
  }

  // Add new payment methods without modifying existing code
  registerProcessor(type, processor) {
    this.processors.set(type, processor);
  }

  async processPayment(paymentRequest) {
    const processor = this.processors.get(paymentRequest.type);
    if (!processor) {
      throw new Error(`Unsupported payment type: ${paymentRequest.type}`);
    }

    // Each processor implements the same interface
    return await processor.process(paymentRequest);
  }
}

// Payment processors implement common interface
class CreditCardProcessor {
  async process(paymentRequest) {
    // Credit card specific logic
    const validation = await this.validateCard(paymentRequest.cardInfo);
    if (!validation.isValid) {
      throw new PaymentError("Invalid card information");
    }

    const charge = await this.chargeCard(paymentRequest);
    return this.createPaymentResult(charge);
  }

  async validateCard(cardInfo) {
    // Luhn algorithm validation, expiry checks, etc.
    return {
      isValid:
        this.passesLuhnCheck(cardInfo.number) &&
        this.isNotExpired(cardInfo.expiry),
      errors: [],
    };
  }
}

class PayPalProcessor {
  async process(paymentRequest) {
    // PayPal specific logic
    const token = await this.authenticateWithPayPal(paymentRequest.paypalInfo);
    const payment = await this.createPayPalPayment(paymentRequest, token);
    return this.createPaymentResult(payment);
  }
}

class CryptoPaymentProcessor {
  async process(paymentRequest) {
    // Cryptocurrency specific logic
    const wallet = await this.validateWallet(paymentRequest.walletAddress);
    const transaction = await this.createBlockchainTransaction(paymentRequest);
    return this.createPaymentResult(transaction);
  }
}

// L - Liskov Substitution Principle
// Derived classes must be substitutable for base classes
class CacheService {
  async get(key) {
    throw new Error("get method must be implemented");
  }

  async set(key, value, ttl = 3600) {
    throw new Error("set method must be implemented");
  }

  async delete(key) {
    throw new Error("delete method must be implemented");
  }

  async clear() {
    throw new Error("clear method must be implemented");
  }
}

class RedisCacheService extends CacheService {
  constructor(redisClient) {
    super();
    this.redis = redisClient;
  }

  async get(key) {
    const value = await this.redis.get(key);
    return value ? JSON.parse(value) : null;
  }

  async set(key, value, ttl = 3600) {
    await this.redis.setex(key, ttl, JSON.stringify(value));
  }

  async delete(key) {
    await this.redis.del(key);
  }

  async clear() {
    await this.redis.flushdb();
  }
}

class MemoryCacheService extends CacheService {
  constructor() {
    super();
    this.cache = new Map();
    this.timers = new Map();
  }

  async get(key) {
    return this.cache.get(key) || null;
  }

  async set(key, value, ttl = 3600) {
    this.cache.set(key, value);

    // Clear existing timer
    if (this.timers.has(key)) {
      clearTimeout(this.timers.get(key));
    }

    // Set expiration timer
    const timer = setTimeout(() => {
      this.cache.delete(key);
      this.timers.delete(key);
    }, ttl * 1000);

    this.timers.set(key, timer);
  }

  async delete(key) {
    this.cache.delete(key);
    if (this.timers.has(key)) {
      clearTimeout(this.timers.get(key));
      this.timers.delete(key);
    }
  }

  async clear() {
    this.cache.clear();
    this.timers.forEach((timer) => clearTimeout(timer));
    this.timers.clear();
  }
}

// Both implementations can be used interchangeably
class UserService {
  constructor(cacheService, userRepository) {
    this.cache = cacheService; // Can be Redis or Memory cache
    this.userRepository = userRepository;
  }

  async getUser(userId) {
    // Works with any CacheService implementation
    const cached = await this.cache.get(`user:${userId}`);
    if (cached) {
      return cached;
    }

    const user = await this.userRepository.findById(userId);
    if (user) {
      await this.cache.set(`user:${userId}`, user, 1800); // 30 minutes
    }

    return user;
  }
}

// I - Interface Segregation Principle
// Clients shouldn't depend on interfaces they don't use
class UserRepository {
  async findById(id) {
    throw new Error("findById must be implemented");
  }

  async findByEmail(email) {
    throw new Error("findByEmail must be implemented");
  }

  async create(userData) {
    throw new Error("create must be implemented");
  }

  async update(id, userData) {
    throw new Error("update must be implemented");
  }

  async delete(id) {
    throw new Error("delete must be implemented");
  }
}

// Separate interfaces for specialized needs
class UserAnalyticsRepository {
  async getUserLoginStats(userId, dateRange) {
    throw new Error("getUserLoginStats must be implemented");
  }

  async getActiveUserCount(dateRange) {
    throw new Error("getActiveUserCount must be implemented");
  }

  async getUserRetentionMetrics(cohortDate) {
    throw new Error("getUserRetentionMetrics must be implemented");
  }
}

class UserSecurityRepository {
  async recordFailedLogin(userId, metadata) {
    throw new Error("recordFailedLogin must be implemented");
  }

  async getFailedLoginAttempts(userId, timeWindow) {
    throw new Error("getFailedLoginAttempts must be implemented");
  }

  async lockUserAccount(userId, reason) {
    throw new Error("lockUserAccount must be implemented");
  }
}

// Services only depend on interfaces they actually need
class LoginService {
  constructor(userRepository, userSecurityRepository, authService) {
    this.userRepository = userRepository; // Only basic user operations
    this.userSecurityRepository = userSecurityRepository; // Only security operations
    this.authService = authService;
  }

  async authenticateUser(email, password) {
    const user = await this.userRepository.findByEmail(email);
    if (!user) {
      // Record failed attempt even for non-existent users (security)
      await this.userSecurityRepository.recordFailedLogin(null, {
        email,
        reason: "user_not_found",
        ip: this.getClientIP(),
      });
      throw new AuthenticationError("Invalid credentials");
    }

    const isValidPassword = await this.authService.validatePassword(
      password,
      user.passwordHash
    );

    if (!isValidPassword) {
      await this.userSecurityRepository.recordFailedLogin(user.id, {
        reason: "invalid_password",
        ip: this.getClientIP(),
      });
      throw new AuthenticationError("Invalid credentials");
    }

    return user;
  }
}

// D - Dependency Inversion Principle
// High-level modules shouldn't depend on low-level modules
class OrderService {
  constructor(dependencies) {
    // Depend on abstractions, not concretions
    this.orderRepository = dependencies.orderRepository;
    this.paymentService = dependencies.paymentService;
    this.inventoryService = dependencies.inventoryService;
    this.notificationService = dependencies.notificationService;
    this.logger = dependencies.logger;
  }

  async createOrder(orderData) {
    try {
      this.logger.info("Creating order", { userId: orderData.userId });

      // Check inventory
      const inventoryCheck = await this.inventoryService.checkAvailability(
        orderData.items
      );

      if (!inventoryCheck.allAvailable) {
        throw new InsufficientInventoryError(inventoryCheck.unavailableItems);
      }

      // Process payment
      const paymentResult = await this.paymentService.processPayment({
        amount: orderData.total,
        paymentMethod: orderData.paymentMethod,
      });

      // Create order record
      const order = await this.orderRepository.create({
        ...orderData,
        paymentId: paymentResult.transactionId,
        status: "confirmed",
      });

      // Update inventory
      await this.inventoryService.reserveItems(orderData.items);

      // Send confirmation
      await this.notificationService.sendOrderConfirmation(order);

      this.logger.info("Order created successfully", { orderId: order.id });

      return order;
    } catch (error) {
      this.logger.error("Order creation failed", {
        error: error.message,
        orderData,
      });
      throw error;
    }
  }
}

// Dependency injection container
class DIContainer {
  constructor() {
    this.dependencies = new Map();
    this.singletons = new Map();
  }

  register(name, factory, options = {}) {
    this.dependencies.set(name, {
      factory,
      singleton: options.singleton || false,
    });
  }

  resolve(name) {
    const dependency = this.dependencies.get(name);
    if (!dependency) {
      throw new Error(`Dependency '${name}' not registered`);
    }

    if (dependency.singleton) {
      if (!this.singletons.has(name)) {
        this.singletons.set(name, dependency.factory(this));
      }
      return this.singletons.get(name);
    }

    return dependency.factory(this);
  }
}

// Configuration of dependencies
const container = new DIContainer();

container.register("logger", () => new ConsoleLogger(), { singleton: true });
container.register("database", () => new MongoDatabase(), { singleton: true });
container.register("cache", () => new RedisCacheService(), { singleton: true });

container.register(
  "userRepository",
  (container) => new MongoUserRepository(container.resolve("database"))
);

container.register(
  "orderRepository",
  (container) => new MongoOrderRepository(container.resolve("database"))
);

container.register(
  "paymentService",
  (container) => new StripePaymentService(container.resolve("logger"))
);

container.register(
  "orderService",
  (container) =>
    new OrderService({
      orderRepository: container.resolve("orderRepository"),
      paymentService: container.resolve("paymentService"),
      inventoryService: container.resolve("inventoryService"),
      notificationService: container.resolve("notificationService"),
      logger: container.resolve("logger"),
    })
);

// Usage - clean, testable, configurable
const orderService = container.resolve("orderService");
const order = await orderService.createOrder(orderData);

// ✅ Essential backend design patterns in action

// Repository Pattern - Data Access Abstraction
class UserRepository {
  constructor(database) {
    this.db = database;
  }

  async findById(id) {
    return await this.db.users.findOne({ _id: id });
  }

  async findByEmail(email) {
    return await this.db.users.findOne({ email });
  }

  async findActiveUsers() {
    return await this.db.users.find({ isActive: true }).toArray();
  }

  async save(user) {
    if (user.id) {
      return await this.db.users.updateOne(
        { _id: user.id },
        { $set: user },
        { upsert: true }
      );
    } else {
      return await this.db.users.insertOne(user);
    }
  }
}

// Unit of Work Pattern - Transaction Management
class UnitOfWork {
  constructor(database) {
    this.db = database;
    this.newEntities = [];
    this.dirtyEntities = [];
    this.removedEntities = [];
  }

  registerNew(entity) {
    this.newEntities.push(entity);
  }

  registerDirty(entity) {
    if (!this.dirtyEntities.find((e) => e.id === entity.id)) {
      this.dirtyEntities.push(entity);
    }
  }

  registerRemoved(entity) {
    this.removedEntities.push(entity);
  }

  async commit() {
    const session = this.db.startSession();

    try {
      await session.withTransaction(async () => {
        // Insert new entities
        for (const entity of this.newEntities) {
          await this.insertEntity(entity, session);
        }

        // Update dirty entities
        for (const entity of this.dirtyEntities) {
          await this.updateEntity(entity, session);
        }

        // Remove deleted entities
        for (const entity of this.removedEntities) {
          await this.deleteEntity(entity, session);
        }
      });

      this.clear();
    } catch (error) {
      await session.abortTransaction();
      throw error;
    } finally {
      await session.endSession();
    }
  }

  clear() {
    this.newEntities = [];
    this.dirtyEntities = [];
    this.removedEntities = [];
  }
}

// Factory Pattern - Object Creation
class DatabaseConnectionFactory {
  static connections = new Map();

  static async createConnection(type, config) {
    const key = `${type}-${JSON.stringify(config)}`;

    if (this.connections.has(key)) {
      return this.connections.get(key);
    }

    let connection;

    switch (type) {
      case "mongodb":
        connection = await this.createMongoConnection(config);
        break;
      case "postgresql":
        connection = await this.createPostgresConnection(config);
        break;
      case "redis":
        connection = await this.createRedisConnection(config);
        break;
      default:
        throw new Error(`Unsupported database type: ${type}`);
    }

    this.connections.set(key, connection);
    return connection;
  }

  static async createMongoConnection(config) {
    const { MongoClient } = require("mongodb");
    const client = new MongoClient(config.url);
    await client.connect();
    return client.db(config.database);
  }

  static async createPostgresConnection(config) {
    const { Client } = require("pg");
    const client = new Client(config);
    await client.connect();
    return client;
  }
}

// Strategy Pattern - Algorithm Selection
class ValidationStrategy {
  validate(data) {
    throw new Error("validate method must be implemented");
  }
}

class EmailValidationStrategy extends ValidationStrategy {
  validate(email) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return {
      isValid: emailRegex.test(email),
      errors: emailRegex.test(email) ? [] : ["Invalid email format"],
    };
  }
}

class PasswordValidationStrategy extends ValidationStrategy {
  validate(password) {
    const errors = [];

    if (password.length < 8) {
      errors.push("Password must be at least 8 characters");
    }

    if (!/[A-Z]/.test(password)) {
      errors.push("Password must contain uppercase letter");
    }

    if (!/[a-z]/.test(password)) {
      errors.push("Password must contain lowercase letter");
    }

    if (!/\d/.test(password)) {
      errors.push("Password must contain number");
    }

    return {
      isValid: errors.length === 0,
      errors,
    };
  }
}

class ValidationContext {
  constructor(strategy) {
    this.strategy = strategy;
  }

  setStrategy(strategy) {
    this.strategy = strategy;
  }

  validate(data) {
    return this.strategy.validate(data);
  }
}

// Observer Pattern - Event System
class EventEmitter {
  constructor() {
    this.listeners = new Map();
  }

  on(event, listener) {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, []);
    }
    this.listeners.get(event).push(listener);
  }

  off(event, listener) {
    if (this.listeners.has(event)) {
      const listeners = this.listeners.get(event);
      const index = listeners.indexOf(listener);
      if (index > -1) {
        listeners.splice(index, 1);
      }
    }
  }

  async emit(event, data) {
    if (this.listeners.has(event)) {
      const listeners = this.listeners.get(event);
      await Promise.all(listeners.map((listener) => listener(data)));
    }
  }
}

class UserService extends EventEmitter {
  constructor(userRepository) {
    super();
    this.userRepository = userRepository;
  }

  async createUser(userData) {
    const user = await this.userRepository.save(userData);

    // Emit event for other services to handle
    await this.emit("user:created", { user });

    return user;
  }

  async updateUser(id, updates) {
    const user = await this.userRepository.findById(id);
    const updatedUser = await this.userRepository.save({ ...user, ...updates });

    await this.emit("user:updated", {
      user: updatedUser,
      previousData: user,
      changes: updates,
    });

    return updatedUser;
  }
}

// Event handlers
class EmailService {
  async handleUserCreated(eventData) {
    await this.sendWelcomeEmail(eventData.user);
  }

  async handleUserUpdated(eventData) {
    if (eventData.changes.email) {
      await this.sendEmailChangeNotification(eventData.user);
    }
  }
}

class AnalyticsService {
  async handleUserCreated(eventData) {
    await this.trackUserRegistration(eventData.user);
  }

  async handleUserUpdated(eventData) {
    await this.trackUserProfileUpdate(eventData.user, eventData.changes);
  }
}

// Wire up event handlers
const userService = new UserService(userRepository);
const emailService = new EmailService();
const analyticsService = new AnalyticsService();

userService.on(
  "user:created",
  emailService.handleUserCreated.bind(emailService)
);
userService.on(
  "user:created",
  analyticsService.handleUserCreated.bind(analyticsService)
);
userService.on(
  "user:updated",
  emailService.handleUserUpdated.bind(emailService)
);
userService.on(
  "user:updated",
  analyticsService.handleUserUpdated.bind(analyticsService)
);

// Decorator Pattern - Behavior Enhancement
class CacheDecorator {
  constructor(service, cache, ttl = 3600) {
    this.service = service;
    this.cache = cache;
    this.ttl = ttl;
  }

  async findById(id) {
    const cacheKey = `user:${id}`;
    const cached = await this.cache.get(cacheKey);

    if (cached) {
      return cached;
    }

    const result = await this.service.findById(id);
    if (result) {
      await this.cache.set(cacheKey, result, this.ttl);
    }

    return result;
  }

  async findByEmail(email) {
    const cacheKey = `user:email:${email}`;
    const cached = await this.cache.get(cacheKey);

    if (cached) {
      return cached;
    }

    const result = await this.service.findByEmail(email);
    if (result) {
      await this.cache.set(cacheKey, result, this.ttl);
    }

    return result;
  }
}

class LoggingDecorator {
  constructor(service, logger) {
    this.service = service;
    this.logger = logger;
  }

  async findById(id) {
    this.logger.info("Finding user by ID", { id });
    const start = Date.now();

    try {
      const result = await this.service.findById(id);
      const duration = Date.now() - start;

      this.logger.info("User found successfully", {
        id,
        duration,
        found: !!result,
      });

      return result;
    } catch (error) {
      const duration = Date.now() - start;
      this.logger.error("Error finding user", {
        id,
        duration,
        error: error.message,
      });
      throw error;
    }
  }
}

// Chain decorators together
const baseUserRepository = new UserRepository(database);
const cachedUserRepository = new CacheDecorator(baseUserRepository, cache);
const loggedUserRepository = new LoggingDecorator(cachedUserRepository, logger);

// Command Pattern - Request Handling
class Command {
  async execute() {
    throw new Error("execute method must be implemented");
  }

  async undo() {
    throw new Error("undo method must be implemented");
  }
}

class CreateUserCommand extends Command {
  constructor(userData, userService) {
    super();
    this.userData = userData;
    this.userService = userService;
    this.createdUser = null;
  }

  async execute() {
    this.createdUser = await this.userService.createUser(this.userData);
    return this.createdUser;
  }

  async undo() {
    if (this.createdUser) {
      await this.userService.deleteUser(this.createdUser.id);
    }
  }
}

class UpdateUserCommand extends Command {
  constructor(userId, updates, userService) {
    super();
    this.userId = userId;
    this.updates = updates;
    this.userService = userService;
    this.previousData = null;
  }

  async execute() {
    this.previousData = await this.userService.findById(this.userId);
    return await this.userService.updateUser(this.userId, this.updates);
  }

  async undo() {
    if (this.previousData) {
      await this.userService.updateUser(this.userId, this.previousData);
    }
  }
}

class CommandInvoker {
  constructor() {
    this.history = [];
    this.currentIndex = -1;
  }

  async execute(command) {
    // Remove any commands after current index
    this.history = this.history.slice(0, this.currentIndex + 1);

    const result = await command.execute();

    this.history.push(command);
    this.currentIndex++;

    return result;
  }

  async undo() {
    if (this.currentIndex >= 0) {
      const command = this.history[this.currentIndex];
      await command.undo();
      this.currentIndex--;
    }
  }

  async redo() {
    if (this.currentIndex < this.history.length - 1) {
      this.currentIndex++;
      const command = this.history[this.currentIndex];
      await command.execute();
    }
  }
}

// Usage
const commandInvoker = new CommandInvoker();

const createCommand = new CreateUserCommand(userData, userService);
const user = await commandInvoker.execute(createCommand);

const updateCommand = new UpdateUserCommand(
  user.id,
  { name: "New Name" },
  userService
);
await commandInvoker.execute(updateCommand);

// Can undo operations
await commandInvoker.undo(); // Undoes the update
await commandInvoker.undo(); // Undoes the creation

// ✅ Enterprise-ready backend project organization
/*
project-root/
├── src/
│   ├── api/                    // HTTP layer
│   │   ├── controllers/        // Request handlers
│   │   ├── middlewares/        // Express middlewares
│   │   ├── routes/            // Route definitions
│   │   └── validators/        // Request validation
│   │
│   ├── application/           // Application layer
│   │   ├── commands/          // Command handlers
│   │   ├── queries/           // Query handlers
│   │   ├── services/          // Application services
│   │   └── use-cases/         // Business use cases
│   │
│   ├── domain/                // Domain layer
│   │   ├── entities/          // Domain entities
│   │   ├── repositories/      // Repository interfaces
│   │   ├── services/          // Domain services
│   │   └── value-objects/     // Value objects
│   │
│   ├── infrastructure/        // Infrastructure layer
│   │   ├── database/          // Database implementations
│   │   ├── external/          // External service clients
│   │   ├── messaging/         // Message queue implementations
│   │   └── repositories/      // Repository implementations
│   │
│   ├── shared/               // Shared utilities
│   │   ├── constants/        // Application constants
│   │   ├── errors/           // Error definitions
│   │   ├── types/            // TypeScript types
│   │   └── utils/            // Utility functions
│   │
│   └── config/               // Configuration
│       ├── database.js       // Database configuration
│       ├── env.js           // Environment variables
│       └── app.js           // Application configuration
│
├── tests/                    // Test files
│   ├── unit/                // Unit tests
│   ├── integration/         // Integration tests
│   └── e2e/                // End-to-end tests
│
├── docs/                    // Documentation
├── scripts/                 // Build and deployment scripts
└── package.json
*/

// Clean separation of concerns in action
// src/domain/entities/User.js
class User {
  constructor(data) {
    this.id = data.id;
    this.email = new Email(data.email);
    this.password = new Password(data.password);
    this.profile = new UserProfile(data.profile);
    this.createdAt = data.createdAt || new Date();
    this.isActive = data.isActive !== undefined ? data.isActive : true;
  }

  // Domain business rules
  changeEmail(newEmail) {
    if (this.email.equals(newEmail)) {
      throw new DomainError("New email must be different from current email");
    }

    this.email = new Email(newEmail);
    this.recordDomainEvent(new EmailChangedEvent(this.id, newEmail));
  }

  deactivate() {
    if (!this.isActive) {
      throw new DomainError("User is already inactive");
    }

    this.isActive = false;
    this.recordDomainEvent(new UserDeactivatedEvent(this.id));
  }

  updateProfile(profileData) {
    this.profile = this.profile.update(profileData);
    this.recordDomainEvent(new ProfileUpdatedEvent(this.id, profileData));
  }
}

// src/domain/value-objects/Email.js
class Email {
  constructor(value) {
    if (!this.isValid(value)) {
      throw new DomainError("Invalid email format");
    }
    this.value = value.toLowerCase();
  }

  isValid(email) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
  }

  equals(other) {
    return other instanceof Email && this.value === other.value;
  }

  toString() {
    return this.value;
  }
}

// src/domain/repositories/UserRepository.js (Interface)
class UserRepository {
  async findById(id) {
    throw new Error("findById must be implemented");
  }

  async findByEmail(email) {
    throw new Error("findByEmail must be implemented");
  }

  async save(user) {
    throw new Error("save must be implemented");
  }

  async delete(id) {
    throw new Error("delete must be implemented");
  }
}

// src/infrastructure/repositories/MongoUserRepository.js
class MongoUserRepository extends UserRepository {
  constructor(database) {
    super();
    this.db = database;
    this.collection = database.collection("users");
  }

  async findById(id) {
    const userData = await this.collection.findOne({ _id: id });
    return userData ? this.toDomainEntity(userData) : null;
  }

  async findByEmail(email) {
    const userData = await this.collection.findOne({
      email: email.toString(),
    });
    return userData ? this.toDomainEntity(userData) : null;
  }

  async save(user) {
    const persistenceData = this.toPersistenceData(user);

    if (user.id) {
      await this.collection.updateOne(
        { _id: user.id },
        { $set: persistenceData }
      );
    } else {
      const result = await this.collection.insertOne(persistenceData);
      user.id = result.insertedId;
    }

    return user;
  }

  toDomainEntity(data) {
    return new User({
      id: data._id,
      email: data.email,
      password: data.password,
      profile: data.profile,
      createdAt: data.createdAt,
      isActive: data.isActive,
    });
  }

  toPersistenceData(user) {
    return {
      _id: user.id,
      email: user.email.toString(),
      password: user.password.getHash(),
      profile: user.profile.toPlainObject(),
      createdAt: user.createdAt,
      isActive: user.isActive,
    };
  }
}

// src/application/services/UserApplicationService.js
class UserApplicationService {
  constructor(userRepository, emailService, eventDispatcher) {
    this.userRepository = userRepository;
    this.emailService = emailService;
    this.eventDispatcher = eventDispatcher;
  }

  async createUser(userData) {
    // Check if user already exists
    const existingUser = await this.userRepository.findByEmail(
      new Email(userData.email)
    );

    if (existingUser) {
      throw new ApplicationError("User with this email already exists");
    }

    // Create domain entity
    const user = new User({
      email: userData.email,
      password: userData.password,
      profile: userData.profile,
    });

    // Save to repository
    const savedUser = await this.userRepository.save(user);

    // Dispatch domain events
    await this.eventDispatcher.dispatchAll(user.getDomainEvents());

    return savedUser;
  }

  async updateUserProfile(userId, profileData) {
    const user = await this.userRepository.findById(userId);
    if (!user) {
      throw new ApplicationError("User not found");
    }

    user.updateProfile(profileData);
    const updatedUser = await this.userRepository.save(user);

    await this.eventDispatcher.dispatchAll(user.getDomainEvents());

    return updatedUser;
  }
}

// src/api/controllers/UserController.js
class UserController {
  constructor(userApplicationService) {
    this.userApplicationService = userApplicationService;
  }

  async create(req, res, next) {
    try {
      const user = await this.userApplicationService.createUser(req.body);

      res.status(201).json({
        success: true,
        data: {
          id: user.id,
          email: user.email.toString(),
          profile: user.profile.toPublicData(),
          createdAt: user.createdAt,
        },
      });
    } catch (error) {
      next(error);
    }
  }

  async updateProfile(req, res, next) {
    try {
      const user = await this.userApplicationService.updateUserProfile(
        req.params.id,
        req.body
      );

      res.json({
        success: true,
        data: {
          id: user.id,
          email: user.email.toString(),
          profile: user.profile.toPublicData(),
        },
      });
    } catch (error) {
      next(error);
    }
  }
}

// src/api/routes/userRoutes.js
const express = require("express");
const { body, param } = require("express-validator");

const userRoutes = (userController) => {
  const router = express.Router();

  router.post(
    "/users",
    [
      body("email").isEmail().normalizeEmail(),
      body("password").isLength({ min: 8 }),
      body("profile.firstName").trim().isLength({ min: 2 }),
      body("profile.lastName").trim().isLength({ min: 2 }),
    ],
    validateRequest,
    userController.create.bind(userController)
  );

  router.put(
    "/users/:id/profile",
    [
      param("id").isMongoId(),
      body("firstName").optional().trim().isLength({ min: 2 }),
      body("lastName").optional().trim().isLength({ min: 2 }),
    ],
    validateRequest,
    userController.updateProfile.bind(userController)
  );

  return router;
};

// src/config/dependencies.js
class DependencyContainer {
  constructor() {
    this.dependencies = new Map();
    this.setup();
  }

  setup() {
    // Infrastructure
    this.register("database", () => this.createDatabaseConnection());
    this.register("eventDispatcher", () => new EventDispatcher());
    this.register("emailService", () => new EmailService());

    // Repositories
    this.register(
      "userRepository",
      () => new MongoUserRepository(this.get("database"))
    );

    // Application Services
    this.register(
      "userApplicationService",
      () =>
        new UserApplicationService(
          this.get("userRepository"),
          this.get("emailService"),
          this.get("eventDispatcher")
        )
    );

    // Controllers
    this.register(
      "userController",
      () => new UserController(this.get("userApplicationService"))
    );
  }

  register(name, factory) {
    this.dependencies.set(name, factory);
  }

  get(name) {
    const factory = this.dependencies.get(name);
    if (!factory) {
      throw new Error(`Dependency '${name}' not found`);
    }
    return factory();
  }
}

// src/app.js - Application assembly
class Application {
  constructor() {
    this.container = new DependencyContainer();
    this.express = express();
    this.setupMiddlewares();
    this.setupRoutes();
    this.setupErrorHandling();
  }

  setupMiddlewares() {
    this.express.use(express.json());
    this.express.use(cors());
    this.express.use(helmet());
    this.express.use(requestLogger);
  }

  setupRoutes() {
    const userController = this.container.get("userController");

    this.express.use("/api/v1", userRoutes(userController));
    this.express.use("/health", healthCheckRouter);
  }

  setupErrorHandling() {
    this.express.use(errorHandler);
    this.express.use(notFoundHandler);
  }

  async start(port = 3000) {
    try {
      await this.container.get("database").connect();

      this.express.listen(port, () => {
        console.log(`Server running on port ${port}`);
      });
    } catch (error) {
      console.error("Failed to start application:", error);
      process.exit(1);
    }
  }
}

// bin/server.js - Application entry point
const Application = require("../src/app");

const app = new Application();
app.start(process.env.PORT || 3000);