import { BNestBaseModuleService } from "@bish-nest/core/data/module-service/base-module.service";
import { BNestPrismaService } from "@bish-nest/core/services";
import { SystemLogService } from "@api/shared/services";
import { SaveResponseDataInterface } from "@bish-nest/core/interfaces/save-response-data.interface";
import { BadRequestException, Injectable, NotFoundException } from "@nestjs/common";
import { SystemLogEntityType } from "@prisma/client";

@Injectable()
export class AssessmentService extends BNestBaseModuleService {
  constructor(
    protected prisma: BNestPrismaService,
    private readonly systemLogService: SystemLogService,
  ) {
    super();
  }
  /**
   * Check if the associated course has enrollments
   */
  private async checkCourseEnrollments(courseId: number): Promise<void> {
    const enrollmentCount = await this.prisma.client.learningGroupParticipant.count({
      where: {
        course_id: courseId,
      },
    });

    if (enrollmentCount > 0) {
      throw new BadRequestException(
        `Cannot modify assessment. The associated course has ${enrollmentCount} enrolled participant(s). Assessments for courses with enrollments cannot be modified or deleted.`,
      );
    }
  }

  /**
   * Override add method to prevent creation when course has enrollments
   */
  async add(data: any) {
    // Check if course_id is provided in the data
    const courseId = data.course_id || data.course?.id;

    if (courseId) {
      await this.checkCourseEnrollments(courseId);
    }

    // Proceed with normal add
    const addResponse = await super.add(data);
    const assessment = addResponse.data;

    // Log the creation
    await this.systemLogService.logInsert(
      SystemLogEntityType.ASSESSMENT,
      assessment.id,
      assessment as Record<string, unknown>,
    );

    return addResponse;
  }

  /**
   * Override save method to prevent modifications when course has enrollments
   */
  async save(id: number, data: any): Promise<SaveResponseDataInterface<any>> {
    // Get old data before update
    const oldAssessment = await this.prisma.client.assessment.findUnique({
      where: { id },
    });

    if (!oldAssessment) {
      throw new NotFoundException(`Assessment with ID ${id} not found`);
    }

    // Check if the associated course has enrollments
    await this.checkCourseEnrollments(oldAssessment.course_id);

    // Also check if the course_id is being changed in the update data
    const courseId = data.course_id || data.course?.id;
    if (courseId && courseId !== oldAssessment.course_id) {
      await this.checkCourseEnrollments(courseId);
    }

    // Proceed with normal save
    const saveResponse = await super.save(id, data);
    const updatedAssessment = saveResponse.data;

    // Calculate changed fields and log the update
    const changedFields = SystemLogService.calculateChangedFields(
      oldAssessment as Record<string, unknown>,
      updatedAssessment as Record<string, unknown>,
    );

    await this.systemLogService.logUpdate(
      SystemLogEntityType.ASSESSMENT,
      id,
      oldAssessment as Record<string, unknown>,
      updatedAssessment as Record<string, unknown>,
      changedFields,
    );

    return saveResponse;
  }

  /**
   * Override delete method to prevent deletion when course has enrollments
   */
  async delete(id: number): Promise<void> {
    // Get assessment data before deletion
    const assessment = await this.prisma.client.assessment.findUnique({
      where: { id },
    });

    if (!assessment) {
      throw new NotFoundException(`Assessment with ID ${id} not found`);
    }

    // Check if the associated course has enrollments
    await this.checkCourseEnrollments(assessment.course_id);

    // Call parent delete method
    await super.delete(id);

    // Log the deletion
    await this.systemLogService.logDelete(
      SystemLogEntityType.ASSESSMENT,
      id,
      assessment as Record<string, unknown>,
    );
  }
}