problem.controller.ts

import { BaseController } from "../base.controller";
import type { IProblemService } from "../../services/problems/problem.service";
import { AppError } from "../../utils/app-error";
import { ERRORS } from "../../constants/errors";
import { ApiResponse } from "../../utils/api-response";
import type { ControllerRequest } from "../../types/infrastructure/hono.types";
import type { CreateProblemInput } from "../../validators/problems/problem.validator";
import { createLogger } from "../../libs/utils/logger";

import type { ProblemValidatorService } from "../../services/problems/problem-validator.service";

const logger = createLogger("problem-controller");

import { type ICradle } from "../../libs/awilix-container";

/**
 * ProblemController manages problem metadata, search, and pagination.
 */
export class ProblemController extends BaseController {
  private readonly problemService: IProblemService;
  private readonly problemValidatorService: ProblemValidatorService;

  constructor(cradle: ICradle) {
    super(cradle);
    this.problemService = cradle.problemService;
    this.problemValidatorService = cradle.problemValidatorService;
  }

  async createProblem(req: ControllerRequest<CreateProblemInput>) {
    return await this.problemService.upsertProblem(req.body);
  }

  async getProblemBySlug(req: ControllerRequest<never, { slug: string }>) {
    const { slug } = req.params;

    // 1. Logic Offloading: Validate slug existence
    return await this.problemValidatorService.validateProblemBySlug(slug);
  }

  async getProblemById(req: ControllerRequest<never, { problem_id: string }>) {
    const { problem_id } = req.params;

    // 1. Logic Offloading: Validate internal ID existence
    return await this.problemValidatorService.validateProblemExists(problem_id);
  }

  async getProblemsByTopic(
    req: ControllerRequest<never, { topic: string }, { limit?: number }>,
  ) {
    const { topic } = req.params;
    const { limit } = req.query;

    return await this.problemService.searchByTopic(topic, limit);
  }

  async getProblems(
    req: ControllerRequest<never, any, { page?: number; limit?: number; search?: string; topic?: string; difficulty?: string }>
  ) {
    const { page = 1, limit = 20, search, topic, difficulty } = req.query;

    const result = await this.problemService.getAllProblems(page, limit, {
      search,
      topic,
      difficulty,
    });

    // Return a pre-formatted paginated response
    // We removed countDocuments for speed; passing dummy totals to satisfy PaginationMeta
    return ApiResponse.paginated(result.problems, {
      totalItems: 0,
      itemCount: result.problems.length,
      perPage: limit,
      totalPages: 0,
      currentPage: page,
    });
  }

  async getUserSolvedProblems(
    req: ControllerRequest<never, { userId: string }>,
  ) {
    const { userId } = req.params;
    return await this.problemService.getUserSolvedProblems(userId);
  }
}