┌─────────────────┐
│   Controllers   │ ← Xử lý các yêu cầu/đáp ứng HTTP
├─────────────────┤
│    Services     │ ← Logic nghiệp vụ & xác thực
├─────────────────┤
│  Repositories   │ ← Trừu tượng hóa truy cập dữ liệu
├─────────────────┤
│     Models      │ ← Lược đồ cơ sở dữ liệu & xác thực
└─────────────────┘

// Mô hình Người Dùng với chỉ mục hợp lý
const UserSchema = new Schema({
  email: { 
    type: String, 
    required: true, 
    unique: true, 
    lowercase: true, 
    trim: true 
  },
  passwordHash: { type: String, required: true },
  displayName: { 
    type: String, 
    required: true, 
    minlength: 2, 
    maxlength: 50 
  },
  settings: {
    weekStart: { type: Number, default: 6 },
    locale: { type: String, default: 'fa-IR' },
    notificationsEmailEnabled: { type: Boolean, default: false }
  }
}, { timestamps: true });

// Chỉ mục chiến lược để tối ưu hiệu suất
UserSchema.index({ email: 1 }, { unique: true });

const middleware = (app) => {
    app.use(helmet({           // Tiêu đề bảo mật
        contentSecurityPolicy: {
            directives: {
                defaultSrc: ["'self'"],
                styleSrc: ["'self'", "'unsafe-inline'"],
                scriptSrc: ["'self'"]
            }
        }
    }));
    app.use(compression());    // Nén phản hồi
    app.use(morgan('combined')); // Ghi log yêu cầu
    app.use(express.json({ limit: '10mb' }));
    app.use(cors({
        origin: process.env.CORS_ORIGIN,
        credentials: true
    }));
    app.use(rateLimit({        // Bảo vệ DDoS
        windowMs: 15 * 60 * 1000, // 15 phút
        max: 1000,             // 1000 yêu cầu mỗi khoảng thời gian
        message: {
            error: 'Quá nhiều yêu cầu, vui lòng thử lại sau'
        }
    }));
};

// Mô hình Thói Quen với chỉ mục hỗn hợp
const HabitSchema = new Schema({
  userId: { type: Schema.Types.ObjectId, ref: 'User', required: true, index: true },
  name: { type: String, required: true, trim: true, minlength: 2, maxlength: 60 },
  archived: { type: Boolean, default: false, index: true }
});

// Chỉ mục hỗn hợp cho các truy vấn phổ biến
HabitSchema.index({ userId: 1, archived: 1 });
HabitSchema.index(
  { userId: 1, name: 1 },
  { unique: true, partialFilterExpression: { archived: false } }
);

// Phân tách rõ ràng các mối quan tâm
const habitRepository = {
  async findAll(userId) {
    return await Habit.find({ userId, archived: false })
      .populate('userId', 'displayName email')
      .sort({ order: 1, createdAt: -1 });
  },

  async create(habitData) {
    const habit = new Habit(habitData);
    return await habit.save();
  }
};

// Lớp dịch vụ xử lý logic nghiệp vụ
const habitService = {
  async createHabit(habitData) {
    // Xác thực
    if (!validateHabitData(habitData)) {
      throw new Error('Dữ liệu thói quen không hợp lệ');
    }

    // Logic nghiệp vụ
    const habit = await habitRepository.create(habitData);

    // Phát sự kiện
    eventEmitter.emit('habitCreated', habit);

    return habit;
  }
};

// Ví dụ kiểm thử tích hợp
describe('Habits API', () => {
  test('nên tạo một thói quen mới', async () => {
    const habitData = {
      userId: '64f1a2b3c4d5e6f7g8h9i0j1',
      name: 'Tập Thể Dục Hằng Ngày',
      description: '30 phút tập thể dục buổi sáng',
      color: '#4CAF50',
      frequency: 'hằng ngày'
    };

    const response = await request(app)
      .post('/api/habits')
      .send(habitData)
      .expect(201);

    expect(response.body.success).toBe(true);
    expect(response.body.data.name).toBe(habitData.name);
  });
});

// Hệ thống sự kiện cho kiến trúc tách rời
const eventEmitter = new EventEmitter();

// Dịch vụ phát sự kiện
const createHabit = async (habitData) => {
  const habit = await habitRepository.create(habitData);
  eventEmitter.emit('habitCreated', habit);
  return habit;
};

// Nhiều người nghe có thể phản ứng
 eventEmitter.on('habitCreated', (habit) => {
  // Gửi thông báo
  notificationService.send(habit.userId, 'Thói quen mới đã được tạo!');

  // Cập nhật phân tích
  analyticsService.track('habit_created', habit);

  // Vô hiệu hóa bộ nhớ cache
  cacheService.invalidate(`user:${habit.userId}:habits`);
});

// Trước: Truy vấn chậm
const habits = await Habit.find({ userId, archived: false });

// Sau: Tối ưu hóa với chỉ mục hợp lý
const habits = await Habit.find({ userId, archived: false })
  .populate('userId', 'displayName')
  .sort({ order: 1, createdAt: -1 })
  .limit(50);

// Trình xử lý lỗi toàn cục
const errorHandler = (err, req, res, next) => {
  console.error(err.stack);

  if (err.name === 'ValidationError') {
    return res.status(400).json({
      success: false,
      message: 'Lỗi xác thực',
      errors: Object.values(err.errors).map(e => e.message)
    });
  }

  res.status(500).json({
    success: false,
    message: 'Lỗi nội bộ máy chủ'
  });
};

// Xác thực đầu vào với Joi
const habitValidation = Joi.object({
  name: Joi.string().min(2).max(60).required(),
  description: Joi.string().max(300).optional(),
  color: Joi.string().pattern(/^#[0-9A-F]{6}$/i).optional(),
  frequency: Joi.string().valid('daily').default('daily')
});