import { ParticipantSubscriptionCourseAccessService } from "@api/client/shared/participant-subscription-course-access.service";
import { BNestEmailSenderService, bnestPlainToDto, bnestPlainToDtoArray, requireEnv } from "@bish-nest/core";
import { BNestPrismaService } from "@bish-nest/core/services/database/prisma/prisma.service";
import { ForbiddenException, Injectable, NotFoundException } from "@nestjs/common";
import { EventEmitter2 } from "@nestjs/event-emitter";
import { AssessmentType, BatAnswerLevel } from "@prisma/client";
import {
  COURSE_PROGRESS_EVENTS,
  CourseCompletedEvent,
  PostBatCompletedEvent,
  PreBatCompletedEvent,
} from "../learning-group/events/course-progress.events";
import {
  AdvancedIndividualPerformanceDto,
  CLAssessmentDto,
  CLAssessmentQuestionDto,
  SubmitAssessmentDto,
} from "./dto";

@Injectable()
export class CLAssessmentService {
  constructor(
    private readonly prisma: BNestPrismaService,
    private readonly emailSender: BNestEmailSenderService,
    private readonly eventEmitter: EventEmitter2,
    private readonly subscriptionCourseAccess: ParticipantSubscriptionCourseAccessService,
  ) {}

  /**
   * Shuffle array using Fisher-Yates algorithm
   * @param array Array to shuffle
   * @returns New shuffled array
   */
  private shuffleArray<T>(array: T[]): T[] {
    const shuffled = [...array];
    for (let i = shuffled.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1));
      [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
    }
    return shuffled;
  }

  /**
   * Get PRE BAT assessment for a course
   * @param learningGroupParticipantId LearningGroupParticipant ID
   * @param participantId Participant ID (for validation)
   * @returns Assessment with questions and answers
   */
  async getPreBatAssessmentByLearningGroupParticipantId(
    learningGroupParticipantId: number,
    participantId: number,
  ): Promise<{ assessment: CLAssessmentDto; questions: CLAssessmentQuestionDto[]; isCompleted: boolean }> {
    // Get enrollment using LearningGroupParticipant ID
    const enrollment = await this.prisma.client.learningGroupParticipant.findFirst({
      where: {
        id: learningGroupParticipantId,
        participant_id: participantId, // Verify it belongs to the current participant
      },
    });

    if (!enrollment) {
      throw new NotFoundException("Course enrollment not found or access denied");
    }

    // Check if enrollment is cancelled
    if (enrollment.cancelled) {
      throw new ForbiddenException(
        "This course license has been cancelled. You can no longer access the PRE BAT assessment.",
      );
    }

    await this.subscriptionCourseAccess.assertAllowsContinuingCourseAccess(
      participantId,
      learningGroupParticipantId,
      enrollment.status,
    );

    // Type assertion to access course_id (field exists in schema but Prisma client not regenerated yet)
    const enrollmentWithCourseId = enrollment as typeof enrollment & { course_id: number };
    const courseId = enrollmentWithCourseId.course_id;

    // Get course to access assessment_id
    const course = await this.prisma.client.course.findUnique({
      where: {
        id: courseId,
      },
    });

    if (!course) {
      throw new NotFoundException("Course not found");
    }

    // Type assertion to access assessment_id (field exists but TypeScript types not regenerated yet)
    const courseWithAssessmentId = course as typeof course & { assessment_id: number | null };

    if (!courseWithAssessmentId.assessment_id) {
      throw new NotFoundException(
        `PRE BAT assessment not found for course ID ${courseId}. Please ensure an assessment is assigned to this course.`,
      );
    }

    // Get assessment using the assessment_id from course
    const assessment = await this.prisma.client.assessment.findUnique({
      where: {
        id: courseWithAssessmentId.assessment_id,
      },
    });

    if (!assessment) {
      throw new NotFoundException(
        `Assessment with ID ${courseWithAssessmentId.assessment_id} not found for course ID ${courseId}.`,
      );
    }

    // Validate assessment has questions
    const questionCount = await this.prisma.client.assessmentQuestion.count({
      where: {
        assessment_id: assessment.id,
      },
    });

    if (questionCount === 0) {
      throw new NotFoundException("Assessment has no questions");
    }

    // Get questions with answers and course module
    const questions = await this.prisma.client.assessmentQuestion.findMany({
      where: {
        assessment_id: assessment.id,
      },
      include: {
        answers: {
          orderBy: {
            sort_order: "asc",
          },
        },
        courseModule: {
          select: {
            id: true,
            title: true,
          },
        },
      },
      orderBy: {
        sort_order: "asc",
      },
    });

    // Randomize answers for each question
    const questionsWithRandomizedAnswers = questions.map((question) => ({
      ...question,
      answers: this.shuffleArray(question.answers),
    }));

    // Check if participant has already completed this PRE BAT assessment for this learning group
    const existingParticipant = await this.prisma.client.assessmentParticipant.findFirst({
      where: {
        assessment_id: assessment.id,
        participant_id: participantId,
        learning_group_id: enrollment.learning_group_id,
        assessment_type: AssessmentType.PRE_BAT,
      },
    });

    return {
      assessment: bnestPlainToDto(assessment, CLAssessmentDto),
      questions: bnestPlainToDtoArray(questionsWithRandomizedAnswers, CLAssessmentQuestionDto),
      isCompleted: !!existingParticipant,
    };
  }

  /**
   * Get POST BAT assessment for a course
   * @param learningGroupParticipantId LearningGroupParticipant ID
   * @param participantId Participant ID (for validation)
   * @returns Assessment with questions and answers
   */
  async getPostBatAssessmentByLearningGroupParticipantId(
    learningGroupParticipantId: number,
    participantId: number,
  ): Promise<{ assessment: CLAssessmentDto; questions: CLAssessmentQuestionDto[]; isCompleted: boolean }> {
    // Get enrollment using LearningGroupParticipant ID
    const enrollment = await this.prisma.client.learningGroupParticipant.findFirst({
      where: {
        id: learningGroupParticipantId,
        participant_id: participantId, // Verify it belongs to the current participant
      },
    });

    if (!enrollment) {
      throw new NotFoundException("Course enrollment not found or access denied");
    }

    if (enrollment.cancelled) {
      throw new ForbiddenException(
        "This course license has been cancelled. You can no longer access the POST BAT assessment.",
      );
    }

    await this.subscriptionCourseAccess.assertAllowsContinuingCourseAccess(
      participantId,
      learningGroupParticipantId,
      enrollment.status,
    );

    // Type assertion to access course_id (field exists in schema but Prisma client not regenerated yet)
    const enrollmentWithCourseId = enrollment as typeof enrollment & { course_id: number };
    const courseId = enrollmentWithCourseId.course_id;

    // Get course to access assessment_id
    const course = await this.prisma.client.course.findUnique({
      where: {
        id: courseId,
      },
    });

    if (!course) {
      throw new NotFoundException("Course not found");
    }

    // Type assertion to access assessment_id (field exists but TypeScript types not regenerated yet)
    const courseWithAssessmentId = course as typeof course & { assessment_id: number | null };

    if (!courseWithAssessmentId.assessment_id) {
      throw new NotFoundException(
        `POST BAT assessment not found for course ID ${courseId}. Please ensure an assessment is assigned to this course.`,
      );
    }

    // Get assessment using the assessment_id from course
    const assessment = await this.prisma.client.assessment.findUnique({
      where: {
        id: courseWithAssessmentId.assessment_id,
      },
    });

    if (!assessment) {
      throw new NotFoundException("Assessment not found");
    }

    // Get questions with answers and course module
    const questions = await this.prisma.client.assessmentQuestion.findMany({
      where: {
        assessment_id: assessment.id,
      },
      include: {
        answers: {
          orderBy: {
            sort_order: "asc",
          },
        },
        courseModule: {
          select: {
            id: true,
            title: true,
          },
        },
      },
      orderBy: {
        sort_order: "asc",
      },
    });

    // Randomize answers for each question
    const questionsWithRandomizedAnswers = questions.map((question) => ({
      ...question,
      answers: this.shuffleArray(question.answers),
    }));

    // Check if already completed for this learning group
    const existingParticipant = await this.prisma.client.assessmentParticipant.findFirst({
      where: {
        assessment_id: assessment.id,
        participant_id: participantId,
        learning_group_id: enrollment.learning_group_id,
        assessment_type: AssessmentType.POST_BAT,
      },
    });

    const isCompleted = !!existingParticipant;

    return {
      assessment: bnestPlainToDto(assessment, CLAssessmentDto),
      questions: bnestPlainToDtoArray(questionsWithRandomizedAnswers, CLAssessmentQuestionDto),
      isCompleted,
    };
  }

  /**
   * Submit assessment answers
   * @param submitDto Submission data
   * @param participantId Participant ID
   * @param assessmentType Type of assessment (PRE_BAT or POST_BAT)
   * @returns Created assessment participant record
   */
  async submitAssessment(
    submitDto: SubmitAssessmentDto,
    participantId: number,
    assessmentType: AssessmentType = AssessmentType.PRE_BAT,
  ): Promise<{ success: boolean; assessmentParticipantId: number }> {
    // Verify participant is enrolled in this course
    const enrollment = await this.prisma.client.learningGroupParticipant.findFirst({
      where: {
        participant_id: participantId,
        learningGroup: {
          course_id: submitDto.course_id,
        },
      },
    });

    if (!enrollment) {
      throw new NotFoundException("Course not found or you are not enrolled");
    }

    // Check if enrollment is cancelled
    if (enrollment.cancelled) {
      throw new ForbiddenException(
        "This course license has been cancelled. You can no longer submit assessments for this course.",
      );
    }

    await this.subscriptionCourseAccess.assertAllowsContinuingCourseAccess(
      participantId,
      enrollment.id,
      enrollment.status,
    );

    // Verify assessment exists
    const assessment = await this.prisma.client.assessment.findUnique({
      where: {
        id: submitDto.assessment_id,
      },
    });

    if (!assessment) {
      throw new NotFoundException("Assessment not found");
    }

    // Verify assessment belongs to the course (via course.assessment_id)
    const course = await this.prisma.client.course.findUnique({
      where: {
        id: submitDto.course_id,
      },
    });

    // Type assertion to access assessment_id
    const courseWithAssessmentId = course as typeof course & { assessment_id: number | null };

    if (
      !course ||
      !courseWithAssessmentId.assessment_id ||
      courseWithAssessmentId.assessment_id !== submitDto.assessment_id
    ) {
      throw new NotFoundException("Assessment does not belong to this course");
    }

    // Get questions to validate answers
    const questions = await this.prisma.client.assessmentQuestion.findMany({
      where: {
        assessment_id: submitDto.assessment_id,
      },
      include: {
        answers: true,
      },
    });

    // Start transaction
    return await this.prisma.client
      .$transaction(async (tx) => {
        // Check if already submitted for this SPECIFIC assessment type (inside transaction to avoid race conditions)
        // This check only prevents duplicate submissions of the SAME type (PRE_BAT or POST_BAT)
        const existingParticipant = await tx.assessmentParticipant.findFirst({
          where: {
            assessment_id: submitDto.assessment_id,
            participant_id: participantId,
            learning_group_id: enrollment.learning_group_id,
            assessment_type: assessmentType, // Only check for same type
          },
        });

        if (existingParticipant) {
          // This means we're trying to submit the same type twice
          const typeName = assessmentType === AssessmentType.PRE_BAT ? "PRE" : "POST";
          throw new NotFoundException(
            `${typeName} BAT assessment has already been submitted for this participant.`,
          );
        }

        // Pre-calculate individual quotient (average of grade levels) from answers
        let quotientSum = 0;
        let quotientCount = 0;

        // First pass: validate answers and calculate quotient
        for (const answer of submitDto.answers) {
          const question = questions.find((q) => q.id === answer.assessment_question_id);
          if (!question) {
            throw new NotFoundException(`Question ${answer.assessment_question_id} not found`);
          }

          // Validate that assessment_answer_id is provided (required for BAT assessments)
          if (!answer.assessment_answer_id) {
            throw new NotFoundException(`Answer ID is required for question ${answer.assessment_question_id}`);
          }

          // Get the selected answer to determine grade level
          const selectedAnswer = question.answers.find((a) => a.id === answer.assessment_answer_id);
          if (!selectedAnswer) {
            throw new NotFoundException(
              `Answer ${answer.assessment_answer_id} not found for question ${answer.assessment_question_id}`,
            );
          }

          const gradeLevel: BatAnswerLevel | null = selectedAnswer.answer_level || null;

          if (gradeLevel) {
            // Map grade levels to numeric values for averaging (-2 to +2 scale)
            const levelValues: Record<string, number> = {
              FOUNDATION: -2,
              INTERMEDIATE: -1,
              ADVANCED: 1,
              EXPERT: 2,
            };
            quotientSum += levelValues[gradeLevel] ?? 0;
            quotientCount++;
          }
        }

        const individualQuotient = quotientCount > 0 ? quotientSum / quotientCount : null;

        // Create assessment participant record FIRST (so we have the ID for FK)
        const assessmentParticipant = await tx.assessmentParticipant.create({
          data: {
            course_id: submitDto.course_id,
            assessment_id: submitDto.assessment_id,
            participant_id: participantId,
            learning_group_id: enrollment.learning_group_id,
            assessment_type: assessmentType,
            assessment_completion_date: new Date(),
            individual_quotient: individualQuotient ? Number(individualQuotient.toFixed(2)) : null,
          },
        });

        // Now create assessment results with assessment_participant_id FK
        const assessmentResults = [];
        for (const answer of submitDto.answers) {
          const question = questions.find((q) => q.id === answer.assessment_question_id);
          if (!question) {
            throw new NotFoundException(`Question ${answer.assessment_question_id} not found`);
          }

          // This was already validated in the first pass, but TypeScript doesn't know that
          if (!answer.assessment_answer_id) {
            throw new NotFoundException(`Answer ID is required for question ${answer.assessment_question_id}`);
          }

          // Get the selected answer to determine grade level
          const selectedAnswer = question.answers.find((a) => a.id === answer.assessment_answer_id);
          if (!selectedAnswer) {
            throw new NotFoundException(
              `Answer ${answer.assessment_answer_id} not found for question ${answer.assessment_question_id}`,
            );
          }

          const gradeLevel: BatAnswerLevel | null = selectedAnswer.answer_level || null;

          const result = await tx.assessmentResult.create({
            data: {
              course_id: submitDto.course_id,
              assessment_id: submitDto.assessment_id,
              assessment_question_id: answer.assessment_question_id,
              course_module_id: question.course_module_id ?? undefined,
              participant_id: participantId,
              assessment_answer_id: answer.assessment_answer_id, // Now TypeScript knows it's defined
              answer_text: answer.answer_text ?? null,
              grade_level: gradeLevel,
              assessment_participant_id: assessmentParticipant.id, // ✅ Set FK to AssessmentParticipant
            },
          });
          assessmentResults.push(result);
        }

        return {
          success: true,
          assessmentParticipantId: assessmentParticipant.id,
        };
      })
      .catch(async (error: unknown) => {
        // Handle Prisma unique constraint violation (P2002)
        // With the new constraint including assessment_type, P2002 should only occur for duplicate of SAME type
        const prismaError = error as { code?: string; meta?: { target?: string[] } };
        if (
          prismaError.code === "P2002" &&
          prismaError.meta?.target?.includes("assessment_id") &&
          prismaError.meta?.target?.includes("participant_id") &&
          prismaError.meta?.target?.includes("assessment_type")
        ) {
          // Check if it's the same type we're trying to submit
          // Get enrollment to access learning_group_id
          const enrollmentForError = await this.prisma.client.learningGroupParticipant.findFirst({
            where: {
              participant_id: participantId,
              learningGroup: {
                course_id: submitDto.course_id,
              },
            },
          });
          const existing = await this.prisma.client.assessmentParticipant.findFirst({
            where: {
              assessment_id: submitDto.assessment_id,
              participant_id: participantId,
              learning_group_id: enrollmentForError?.learning_group_id,
              assessment_type: assessmentType, // Only check for same type
            },
          });

          if (existing) {
            // This means we're trying to submit the same type twice
            throw new NotFoundException(
              `${assessmentType === AssessmentType.PRE_BAT ? "PRE" : "POST"} BAT assessment has already been submitted for this participant.`,
            );
          }
        }
        // Re-throw other errors (including NotFoundException from the transaction)
        throw error;
      })
      .then(async (result) => {
        // Send email notification outside transaction
        // Get participant, course, and enrollment details for email
        const participant = await this.prisma.client.participant.findUnique({
          where: { id: participantId },
          include: {
            company: true,
          },
        });

        const course = await this.prisma.client.course.findUnique({
          where: { id: submitDto.course_id },
        });

        // Get enrollment for learning_group_participant_id (used for both email and event)
        const enrollment = await this.prisma.client.learningGroupParticipant.findFirst({
          where: {
            participant_id: participantId,
            learningGroup: {
              course_id: submitDto.course_id,
            },
          },
          include: {
            learningGroup: true,
          },
        });

        if (participant && course) {
          // Send assessment completion email (PRE_BAT or POST_BAT)
          try {
            const frontendUrl = requireEnv("FRONTEND_URL");
            const isPostBat = assessmentType === AssessmentType.POST_BAT;
            const templateKey = isPostBat ? "course.completion" : "course.pre.bat.completion";
            const triggeredBy = isPostBat ? "post_bat_assessment_completion" : "pre_bat_assessment_completion";

            const myCourseUrl = `${frontendUrl}/portal/my-courses/${enrollment?.id || course.id}`;
            const myCoursesUrl = `${frontendUrl}/portal/my-courses`;
            const assetsUrl = (process.env["FRONTEND_ASSETS_URL_FOR_LOCAL_EMAIL"] || frontendUrl) as string;
            const iconsUrl = `${assetsUrl}/assets/images/email-icons`;
            await this.emailSender.sendTemplatedEmail({
              to: participant.email,
              templateKey: templateKey,
              variables: {
                "user.name": participant.first_name,
                "user.email": participant.email,
                "course.name": course.title,
                "course.id": course.id.toString(),
                "system.myCourseUrl": myCourseUrl,
                "system.myCoursesUrl": myCoursesUrl,
                // Hosted PNG icons used by the email body (replaces emojis for cross-client consistency).
                "system.iconsUrl": iconsUrl,
              },
              metadata: {
                participant_id: participantId,
                company_id: participant.company_id,
                course_id: submitDto.course_id,
                assessment_id: submitDto.assessment_id,
                learning_group_id: enrollment?.learning_group_id,
                learning_group_participant_id: enrollment?.id,
                companyName: participant.company?.name || "",
                courseName: course.title,
                triggeredBy: triggeredBy,
              },
            });
          } catch (emailError) {
            // Log error but don't fail the request
            console.error(`Failed to send ${assessmentType} completion email:`, emailError);
          }
        }

        // Emit event based on assessment type
        if (assessmentType === AssessmentType.PRE_BAT) {
          // Use enrollment already fetched above
          if (enrollment) {
            this.eventEmitter.emit(
              COURSE_PROGRESS_EVENTS.PRE_BAT_COMPLETED,
              new PreBatCompletedEvent(
                enrollment.id,
                participantId,
                submitDto.course_id,
                result.assessmentParticipantId,
              ),
            );
          }
        } else if (assessmentType === AssessmentType.POST_BAT) {
          // Use enrollment already fetched above
          if (enrollment) {
            // Emit POST_BAT_COMPLETED event
            this.eventEmitter.emit(
              COURSE_PROGRESS_EVENTS.POST_BAT_COMPLETED,
              new PostBatCompletedEvent(
                enrollment.id,
                participantId,
                submitDto.course_id,
                result.assessmentParticipantId,
              ),
            );

            // Check if all stages are completed, then emit COURSE_COMPLETED
            const preBatCompleted = await this.prisma.client.assessmentParticipant.findFirst({
              where: {
                assessment_id: submitDto.assessment_id,
                participant_id: participantId,
                learning_group_id: enrollment.learning_group_id,
                assessment_type: AssessmentType.PRE_BAT,
              },
            });

            const eLearningCompleted = await this.prisma.client.eLearningParticipant.findFirst({
              where: {
                participant_id: participantId,
                course_id: submitDto.course_id,
                status: "COMPLETED",
              },
            });

            const knowledgeReviewCompleted = await this.prisma.client.knowledgeReviewParticipant.findFirst({
              where: {
                participant_id: participantId,
                course_id: submitDto.course_id,
              },
            });

            if (preBatCompleted && eLearningCompleted && knowledgeReviewCompleted) {
              // All stages completed - emit COURSE_COMPLETED event
              this.eventEmitter.emit(
                COURSE_PROGRESS_EVENTS.COURSE_COMPLETED,
                new CourseCompletedEvent(enrollment.id, participantId, submitDto.course_id),
              );
            }
          }
        }

        return {
          success: result.success,
          assessmentParticipantId: result.assessmentParticipantId,
        };
      });
  }

  /**
   * Format pre/post BAT data for AI-CodeRythm integration team
   * @param learningGroupId Learning group ID
   * @param participantId Optional participant ID - if provided, only return data for this participant
   * @param callerAuth When provided (API request), enforces: learning group must be in caller's company; PARTICIPANT can only get own data
   * @returns Formatted data matching the integration team's expected format
   * Automatically includes PRE and/or POST data based on what's available
   */
  async formatPrePostBatDataForIntegration(
    learningGroupId: number,
    participantId?: number,
    callerAuth?: { companyId: number; participantId: number; role: string },
  ): Promise<{
    status: string;
    metadata: {
      learning_group_id: number;
      course_code: string;
      course_title: string;
      plj_position: "PRE_BAT" | "POST_BAT";
      modules: Array<{ module: string; module_code: string }>;
    };
    data: Array<{
      participant_name: string;
      participant_id: number;
      first_name: string;
      last_name: string;
      metadata: {
        individual_quotient_pre: number;
        individual_quotient_post: number;
        individual_quotient_change: number;
      };
      modules: Record<
        string,
        {
          PRE_BAT: Array<{
            assessment_question_id: number;
            question_text: string;
            level: string;
            answer_text: string;
            score: number;
          }>;
          POST_BAT: Array<{
            assessment_question_id: number;
            question_text: string;
            level: string;
            answer_text: string;
            score: number;
          }>;
        }
      >;
    }>;
  }> {
    // Get learning group with course
    const learningGroup = await this.prisma.client.learningGroup.findUnique({
      where: { id: learningGroupId },
      include: {
        course: {
          include: {
            assessment: true,
          },
        },
        learningGroupParticipants: {
          include: {
            participant: true,
          },
        },
      },
    });

    if (!learningGroup || !(learningGroup as any).course) {
      throw new NotFoundException(`Learning group ${learningGroupId} or course not found`);
    }

    // Enforce access: caller may only access learning groups and participants they are allowed to see
    if (callerAuth) {
      if (learningGroup.company_id !== callerAuth.companyId) {
        throw new ForbiddenException("You do not have access to this learning group.");
      }
      const isParticipantAdmin = callerAuth.role === "PARTICIPANT_ADMIN";
      if (!isParticipantAdmin) {
        // Regular participant: may only request their own data
        participantId = callerAuth.participantId;
        const isEnrolled = (learningGroup as any).learningGroupParticipants.some(
          (lgp: { participant_id: number }) => lgp.participant_id === callerAuth.participantId,
        );
        if (!isEnrolled) {
          throw new ForbiddenException("You do not have access to this learning group.");
        }
      }
      // PARTICIPANT_ADMIN: may request any participant in this (same-company) learning group
    }

    const course = (learningGroup as any).course;
    if (!course.assessment_id) {
      throw new NotFoundException(`Course ${course.id} does not have an assessment assigned`);
    }

    // Get all modules that have assessment questions for this course's assessment
    const assessmentQuestions = await this.prisma.client.assessmentQuestion.findMany({
      where: {
        assessment_id: course.assessment_id!,
      },
      select: {
        course_module_id: true,
      },
      distinct: ["course_module_id"],
    });

    const assessmentModuleIds = assessmentQuestions
      .map((q) => q.course_module_id)
      .filter((id) => id !== null) as number[];

    // Get course modules that have assessment questions
    const courseModules = await this.prisma.client.courseModule.findMany({
      where: {
        id: {
          in: assessmentModuleIds,
        },
      },
      include: {
        assessmentQuestions: {
          include: {
            answers: true,
          },
        },
      },
      orderBy: {
        sort_order: "asc",
      },
    });
    if (!course.assessment_id) {
      throw new NotFoundException(`Course ${course.id} does not have an assessment assigned`);
    }

    // Filter participants if participantId is provided
    const learningGroupWithParticipants = learningGroup as any;
    const participantsToProcess = participantId
      ? learningGroupWithParticipants.learningGroupParticipants.filter(
          (enrollment: any) => enrollment.participant_id === participantId,
        )
      : learningGroupWithParticipants.learningGroupParticipants;

    if (participantId && participantsToProcess.length === 0) {
      throw new NotFoundException(
        `Participant ${participantId} is not enrolled in learning group ${learningGroupId}`,
      );
    }

    // Get all participants with their assessment results
    const participantsData = await Promise.all(
      participantsToProcess.map(async (enrollment: any) => {
        const participant = enrollment.participant;

        // Get PRE_BAT assessment participant for this learning group
        const preBatParticipant = await this.prisma.client.assessmentParticipant.findFirst({
          where: {
            assessment_id: course.assessment_id!,
            participant_id: participant.id,
            learning_group_id: learningGroupId,
            assessment_type: AssessmentType.PRE_BAT,
          },
        });

        // Get POST_BAT assessment participant for this learning group
        const postBatParticipant = await this.prisma.client.assessmentParticipant.findFirst({
          where: {
            assessment_id: course.assessment_id!,
            participant_id: participant.id,
            learning_group_id: learningGroupId,
            assessment_type: AssessmentType.POST_BAT,
          },
        });

        // Get all assessment results for this participant and assessment
        // Note: AssessmentResult doesn't have assessment_type, so we'll separate by timestamp
        const allResults = await this.prisma.client.assessmentResult.findMany({
          where: {
            assessment_id: course.assessment_id!,
            participant_id: participant.id,
          },
          include: {
            assessmentQuestion: {
              include: {
                courseModule: true,
                answers: true,
              },
            },
            assessmentAnswer: true,
            courseModule: true, // Include courseModule directly from AssessmentResult
          },
          orderBy: {
            created_at: "asc",
          },
        } as any);

        // Separate PRE and POST results based on assessmentParticipant records
        // Use created_at from assessmentParticipant as the boundary, as it represents when the assessment was started
        const preBatCreatedAt = preBatParticipant?.created_at ? new Date(preBatParticipant.created_at) : null;
        const postBatCreatedAt = postBatParticipant?.created_at ? new Date(postBatParticipant.created_at) : null;
        const preBatCompletionDate = preBatParticipant?.assessment_completion_date
          ? new Date(preBatParticipant.assessment_completion_date)
          : null;
        const postBatCompletionDate = postBatParticipant?.assessment_completion_date
          ? new Date(postBatParticipant.assessment_completion_date)
          : null;

        // If POST_BAT doesn't exist, all results are PRE_BAT
        // If POST_BAT exists, separate by assessment participant created_at timestamps
        let preBatResults: any[] = [];
        let postBatResults: any[] = [];

        if (!postBatParticipant) {
          // No POST_BAT, so all results are PRE_BAT
          preBatResults = allResults;
        } else if (!preBatParticipant) {
          // No PRE_BAT, so all results are POST_BAT
          postBatResults = allResults;
        } else {
          // Both exist, separate by assessment participant created_at timestamps
          // This is more reliable than completion dates because results are created during the assessment
          if (preBatCreatedAt && postBatCreatedAt) {
            // Use the midpoint between PRE_BAT completion and POST_BAT created_at as boundary
            // This handles cases where POST_BAT results are created just before the POST_BAT record
            const preBatEnd = preBatCompletionDate || preBatCreatedAt;
            const boundary = new Date((preBatEnd.getTime() + postBatCreatedAt.getTime()) / 2);
            preBatResults = allResults.filter((r: any) => {
              const resultDate = new Date(r.created_at);
              return resultDate < boundary;
            });
            postBatResults = allResults.filter((r: any) => {
              const resultDate = new Date(r.created_at);
              return resultDate >= boundary;
            });
          } else if (preBatCompletionDate && postBatCompletionDate) {
            // Fallback: use completion dates if created_at not available
            // Use midpoint between completion dates as boundary
            const midpoint = new Date((preBatCompletionDate.getTime() + postBatCompletionDate.getTime()) / 2);
            preBatResults = allResults.filter((r: any) => {
              const resultDate = new Date(r.created_at);
              return resultDate < midpoint;
            });
            postBatResults = allResults.filter((r: any) => {
              const resultDate = new Date(r.created_at);
              return resultDate >= midpoint;
            });
          } else if (preBatCompletionDate) {
            // Only PRE completion date exists
            preBatResults = allResults.filter((r: any) => {
              const resultDate = new Date(r.created_at);
              return resultDate <= preBatCompletionDate;
            });
            postBatResults = allResults.filter((r: any) => {
              const resultDate = new Date(r.created_at);
              return resultDate > preBatCompletionDate;
            });
          } else {
            // No dates available, use midpoint of created_at if available
            if (preBatCreatedAt) {
              // If only PRE created_at exists, assume all results are PRE_BAT
              preBatResults = allResults;
            } else {
              // Fallback: assume all results are PRE_BAT
              preBatResults = allResults;
            }
          }
        }

        // Calculate individual quotient
        // Use individual_quotient from assessmentParticipant if available, otherwise calculate from grade_level
        const preBatQuotient = preBatParticipant?.individual_quotient
          ? Number(preBatParticipant.individual_quotient)
          : 0;
        const postBatQuotient = postBatParticipant?.individual_quotient
          ? Number(postBatParticipant.individual_quotient)
          : 0;

        // Calculate scores from grade_level if individual_quotient not available
        const gradeLevelToScore: Record<string, number> = {
          FOUNDATION: -2,
          INTERMEDIATE: -1,
          ADVANCED: 1,
          EXPERT: 2,
        };

        const preBatScore =
          preBatQuotient > 0
            ? preBatQuotient * preBatResults.length
            : preBatResults.reduce((sum: number, r: any) => {
                const level = r.grade_level || r.assessmentAnswer?.level || "INTERMEDIATE";
                return sum + (gradeLevelToScore[level] || 0);
              }, 0);

        const postBatScore =
          postBatQuotient > 0
            ? postBatQuotient * postBatResults.length
            : postBatResults.reduce((sum: number, r: any) => {
                const level = r.grade_level || r.assessmentAnswer?.level || "INTERMEDIATE";
                return sum + (gradeLevelToScore[level] || 0);
              }, 0);
        const preBatQuestionCount = preBatResults.length || 1;
        const postBatQuestionCount = postBatResults.length || 1;
        const individualQuotientPre = preBatQuestionCount > 0 ? preBatScore / preBatQuestionCount : 0;
        const individualQuotientPost = postBatQuestionCount > 0 ? postBatScore / postBatQuestionCount : 0;
        const individualQuotientChange = individualQuotientPost - individualQuotientPre;

        // Group results by module
        const modulesData: Record<
          string,
          {
            PRE_BAT: Array<{
              assessment_question_id: number;
              question_text: string;
              level: string;
              answer_text: string;
              score: number;
            }>;
            POST_BAT: Array<{
              assessment_question_id: number;
              question_text: string;
              level: string;
              answer_text: string;
              score: number;
            }>;
          }
        > = {};

        // Process PRE_BAT results
        if (preBatResults.length > 0) {
          for (const result of preBatResults) {
            const r = result as any;
            // Try to get module_code from courseModule directly on AssessmentResult, or from assessmentQuestion
            let moduleCode =
              r.courseModule?.course_module_code || r.assessmentQuestion?.courseModule?.course_module_code;

            // If still no module_code, try to get it from course_module_id by querying CourseModule
            if (!moduleCode && r.course_module_id) {
              const courseModule = await this.prisma.client.courseModule.findUnique({
                where: { id: r.course_module_id },
                select: { course_module_code: true },
              });
              moduleCode = courseModule?.course_module_code;
            }

            if (!moduleCode) {
              // Skip if no module_code found
              continue;
            }

            if (!modulesData[moduleCode]) {
              modulesData[moduleCode] = { PRE_BAT: [], POST_BAT: [] };
            }

            const levelMap: Record<string, string> = {
              FOUNDATION: "Foundation",
              INTERMEDIATE: "Intermediate",
              ADVANCED: "Advanced",
              EXPERT: "Expert",
            };

            const gradeLevel = r.grade_level || r.assessmentAnswer?.answer_level || "INTERMEDIATE";
            const scoreMap: Record<string, number> = {
              FOUNDATION: -2,
              INTERMEDIATE: -1,
              ADVANCED: 1,
              EXPERT: 2,
            };

            modulesData[moduleCode].PRE_BAT.push({
              assessment_question_id: r.assessment_question_id,
              question_text: r.assessmentQuestion?.question_text || "",
              level: levelMap[gradeLevel] || gradeLevel,
              answer_text:
                r.assessmentAnswer?.answer_text ||
                r.answer_text ||
                r.assessmentQuestion?.answers?.[0]?.answer_text ||
                "",
              score: scoreMap[gradeLevel] || 0,
            });
          }
        }

        // Process POST_BAT results
        if (postBatResults.length > 0) {
          for (const result of postBatResults) {
            const r = result as any;
            // Try to get module_code from courseModule directly on AssessmentResult, or from assessmentQuestion
            let moduleCode =
              r.courseModule?.course_module_code || r.assessmentQuestion?.courseModule?.course_module_code;

            // If still no module_code, try to get it from course_module_id by querying CourseModule
            if (!moduleCode && r.course_module_id) {
              const courseModule = await this.prisma.client.courseModule.findUnique({
                where: { id: r.course_module_id },
                select: { course_module_code: true },
              });
              moduleCode = courseModule?.course_module_code;
            }

            if (!moduleCode) {
              // Skip if no module_code found
              continue;
            }

            if (!modulesData[moduleCode]) {
              modulesData[moduleCode] = { PRE_BAT: [], POST_BAT: [] };
            }

            const levelMap: Record<string, string> = {
              FOUNDATION: "Foundation",
              INTERMEDIATE: "Intermediate",
              ADVANCED: "Advanced",
              EXPERT: "Expert",
            };

            const gradeLevel = r.grade_level || r.assessmentAnswer?.answer_level || "INTERMEDIATE";
            const scoreMap: Record<string, number> = {
              FOUNDATION: -2,
              INTERMEDIATE: -1,
              ADVANCED: 1,
              EXPERT: 2,
            };

            modulesData[moduleCode].POST_BAT.push({
              assessment_question_id: r.assessment_question_id,
              question_text: r.assessmentQuestion?.question_text || "",
              level: levelMap[gradeLevel] || gradeLevel,
              answer_text:
                r.assessmentAnswer?.answer_text ||
                r.answer_text ||
                r.assessmentQuestion?.answers?.[0]?.answer_text ||
                "",
              score: scoreMap[gradeLevel] || 0,
            });
          }
        }

        return {
          participant_name: `${participant.first_name} ${participant.last_name}`,
          participant_id: participant.id,
          first_name: participant.first_name,
          last_name: participant.last_name,
          metadata: {
            individual_quotient_pre: Number(individualQuotientPre.toFixed(2)),
            individual_quotient_post: Number(individualQuotientPost.toFixed(2)),
            individual_quotient_change: Number(individualQuotientChange.toFixed(2)),
          },
          modules: modulesData,
        };
      }),
    );

    // Format modules metadata
    const modulesMetadata = courseModules.map((module: any) => ({
      module: module.title,
      module_code: module.course_module_code,
    }));

    // Determine plj_position: if any participant has POST_BAT data, use POST_BAT, otherwise PRE_BAT
    const hasPostBatData = participantsData.some((participant) => {
      return Object.values(participant.modules).some((moduleData: any) => moduleData.POST_BAT.length > 0);
    });
    const pljPosition = hasPostBatData ? "POST_BAT" : "PRE_BAT";

    return {
      status: "success",
      metadata: {
        learning_group_id: learningGroupId,
        course_code: course.course_code,
        course_title: course.title,
        plj_position: pljPosition,
        modules: modulesMetadata,
      },
      data: participantsData,
    };
  }

  /**
   * Get assessment completion data for report
   * Returns all assessments (PRE_BAT and POST_BAT) for the participant's company
   */
  async getAssessmentCompletionReport(
    participantId: number,
    companyId: number,
    filters?: {
      assessmentType?: string;
      completionStatus?: string;
      period?: string;
      course?: string;
      learningGroup?: string;
      search?: string;
    },
  ): Promise<
    Array<{
      participantName: string;
      assessmentType: string;
      associatedCourse: string;
      courseId: string;
      groupName: string;
      learningGroupId: number;
      learningGroupParticipantId: number | null;
      assignedDate: string;
      dueDate: string;
      completionDate: string;
      timeToComplete: string;
      status: string;
      moduleScores: {
        B: number;
        I: number;
        A: number;
        E: number;
      } | null;
    }>
  > {
    // Build where clause with filters
    const where: any = {
      participant: {
        company_id: companyId,
      },
      learning_group_id: {
        not: null, // Only show assessments assigned through learning groups
      },
    };

    // Apply filters
    if (filters?.assessmentType && filters.assessmentType !== "all") {
      const assessmentType =
        filters.assessmentType === "Pre-BAT"
          ? "PRE_BAT"
          : filters.assessmentType === "Post-BAT"
            ? "POST_BAT"
            : filters.assessmentType;
      where.assessment_type = assessmentType;
    }

    if (filters?.course && filters.course !== "all") {
      where.course_id = parseInt(filters.course, 10);
    }

    if (filters?.learningGroup && filters.learningGroup !== "all") {
      where.learning_group_id = parseInt(filters.learningGroup, 10);
    }

    if (filters?.completionStatus && filters.completionStatus !== "all") {
      if (filters.completionStatus === "completed") {
        where.assessment_completion_date = { not: null };
      } else if (filters.completionStatus === "not-started") {
        where.assessment_completion_date = null;
        where.updated_at = where.created_at;
      } else if (filters.completionStatus === "in-progress") {
        where.assessment_completion_date = null;
        where.updated_at = { not: where.created_at };
      }
    }

    if (filters?.search) {
      where.OR = [
        { participant: { first_name: { contains: filters.search, mode: "insensitive" } } },
        { participant: { last_name: { contains: filters.search, mode: "insensitive" } } },
        { course: { title: { contains: filters.search, mode: "insensitive" } } },
        { learningGroup: { name: { contains: filters.search, mode: "insensitive" } } },
      ];
    }

    // Get all assessment participants for this company that are assigned through learning groups
    // Only include assessments where learning_group_id is NOT NULL (assigned through learning groups)
    const assessmentParticipants = await this.prisma.client.assessmentParticipant.findMany({
      where,
      include: {
        participant: {
          select: {
            id: true,
            first_name: true,
            last_name: true,
            email: true,
          },
        },
        course: {
          select: {
            id: true,
            title: true,
          },
        },
        learningGroup: {
          select: {
            id: true,
            name: true,
            due_date: true, // Include due_date for calculating due date
            start_date: true, // Include start_date as fallback for assigned date
          },
        },
        assessmentResults: {
          select: {
            grade_level: true,
          },
        },
      },
      orderBy: {
        created_at: "desc",
      },
    });

    // Get learning group participants to get invited_at dates (actual assignment dates)
    const learningGroupParticipantIds = assessmentParticipants
      .map((ap) => ({
        learningGroupId: ap.learning_group_id!,
        participantId: ap.participant_id,
      }))
      .filter((item): item is { learningGroupId: number; participantId: number } => item.learningGroupId !== null);

    const learningGroupParticipants = await this.prisma.client.learningGroupParticipant.findMany({
      where: {
        OR: learningGroupParticipantIds.map((item) => ({
          learning_group_id: item.learningGroupId,
          participant_id: item.participantId,
        })),
      },
      select: {
        id: true,
        learning_group_id: true,
        participant_id: true,
        invited_at: true,
        created_at: true, // Include created_at as fallback
      },
    });

    // Create a map for quick lookup: key = "learningGroupId-participantId"
    const lgpMap = new Map<string, { id: number; invited_at: Date | null; created_at: Date }>();
    for (const lgp of learningGroupParticipants) {
      const key = `${lgp.learning_group_id}-${lgp.participant_id}`;
      lgpMap.set(key, { id: lgp.id, invited_at: lgp.invited_at, created_at: lgp.created_at });
    }

    // Transform to report format
    const result = assessmentParticipants
      .map((ap) => {
        // Skip if no learning group (shouldn't happen due to filter, but double-check)
        if (!ap.learning_group_id) {
          return null;
        }

        // Get learning group participant data for assigned date
        const lgpKey = `${ap.learning_group_id}-${ap.participant_id}`;
        const lgpData = lgpMap.get(lgpKey);

        const participantName = `${ap.participant.first_name || ""} ${ap.participant.last_name || ""}`.trim();
        const assessmentType = ap.assessment_type === "PRE_BAT" ? "Pre-BAT" : "Post-BAT";
        const isCompleted = !!ap.assessment_completion_date;

        // Get assigned date with proper fallback chain:
        // 1. Use invited_at (actual invitation/assignment date) - most accurate
        // 2. Use learning_group_participant.created_at (when participant was added to learning group)
        // 3. Use learning_group.start_date (when the learning group started)
        // 4. Fallback to assessment_participant.created_at (last resort)
        let assignedDateObj: Date;
        if (lgpData?.invited_at) {
          assignedDateObj = lgpData.invited_at;
        } else if (lgpData?.created_at) {
          assignedDateObj = lgpData.created_at;
        } else if (ap.learningGroup?.start_date) {
          assignedDateObj = ap.learningGroup.start_date;
        } else {
          assignedDateObj = ap.created_at;
        }
        const assignedDate = assignedDateObj.toISOString().split("T")[0];

        // Calculate time to complete (from assigned date to completion date)
        let timeToComplete = "";
        if (isCompleted && ap.assessment_completion_date && assignedDateObj) {
          const days = Math.floor(
            (ap.assessment_completion_date.getTime() - assignedDateObj.getTime()) / (1000 * 60 * 60 * 24),
          );
          timeToComplete = `${days} day${days !== 1 ? "s" : ""}`;
        }

        // Determine status
        let status = "Not Started";
        if (isCompleted) {
          status = "Completed";
        } else if (ap.updated_at && ap.updated_at > ap.created_at) {
          status = "In Progress";
        }

        // Calculate module scores (B, I, A, E) from assessment results
        // Map: FOUNDATION -> B, INTERMEDIATE -> I, ADVANCED -> A, EXPERT -> E
        let moduleScores: { B: number; I: number; A: number; E: number } | null = null;
        if (isCompleted && ap.assessmentResults && ap.assessmentResults.length > 0) {
          const scores = { B: 0, I: 0, A: 0, E: 0 };
          ap.assessmentResults.forEach((result) => {
            if (result.grade_level) {
              switch (result.grade_level) {
                case "FOUNDATION":
                  scores.B++;
                  break;
                case "INTERMEDIATE":
                  scores.I++;
                  break;
                case "ADVANCED":
                  scores.A++;
                  break;
                case "EXPERT":
                  scores.E++;
                  break;
              }
            }
          });
          moduleScores = scores;
        }

        // Get due date: use learning group's due_date if available, otherwise 7 days after assigned date
        let dueDate: string;
        if (ap.learningGroup?.due_date) {
          dueDate = ap.learningGroup.due_date.toISOString().split("T")[0];
        } else {
          const dueDateObj = new Date(assignedDateObj);
          dueDateObj.setDate(dueDateObj.getDate() + 7);
          dueDate = dueDateObj.toISOString().split("T")[0];
        }

        return {
          participantName,
          assessmentType,
          associatedCourse: ap.course.title,
          courseId: String(ap.course.id),
          groupName: ap.learningGroup?.name || "Not Assigned",
          learningGroupId: ap.learning_group_id,
          learningGroupParticipantId: lgpData?.id ?? null,
          assignedDate,
          dueDate,
          completionDate: ap.assessment_completion_date ? ap.assessment_completion_date.toISOString() : "",
          timeToComplete,
          status,
          moduleScores,
        };
      })
      .filter((item): item is NonNullable<typeof item> => item !== null);

    // Apply period filter if specified
    if (filters && filters.period && filters.period !== "all") {
      const now = new Date();
      const period = filters.period;
      return result.filter((item: (typeof result)[0]) => {
        if (!item.completionDate && period !== "not-started") return false;
        if (period === "not-started") return !item.completionDate;

        const completionDate = new Date(item.completionDate);
        if (isNaN(completionDate.getTime())) return period === "not-started";

        const diffDays = Math.floor((now.getTime() - completionDate.getTime()) / (1000 * 60 * 60 * 24));
        switch (period) {
          case "today":
            return diffDays === 0;
          case "week":
            return diffDays <= 7;
          case "month":
            return diffDays <= 30;
          default:
            return true;
        }
      });
    }

    return result;
  }

  /**
   * Get advanced individual performance data for the client portal
   * Only shows data for participants with learning group assignments
   * @param companyId - Company ID from authenticated user
   * @returns Array of advanced performance data
   */
  async getAdvancedIndividualPerformance(companyId: number): Promise<AdvancedIndividualPerformanceDto[]> {
    // Get all participants in the company with their learning group assignments
    const participants = await this.prisma.client.participant.findMany({
      where: {
        company_id: companyId,
      },
      include: {
        learningGroupParticipants: {
          select: {
            id: true,
            learning_group_id: true,
            course_id: true,
            participant_id: true,
            status: true,
            completion_percentage: true,
            learningGroup: {
              select: {
                id: true,
                name: true,
                course: {
                  select: {
                    id: true,
                    title: true,
                  },
                },
              },
            },
          },
          orderBy: {
            created_at: "desc",
          },
        },
      },
    });

    const performanceData: AdvancedIndividualPerformanceDto[] = [];

    for (const participant of participants) {
      // Process each learning group assignment for this participant
      for (const lgp of participant.learningGroupParticipants) {
        const courseId = lgp.course_id;
        const courseTitle = lgp.learningGroup.course.title;

        // Get PRE-BAT and POST-BAT assessments for this participant and course
        const assessments = await this.prisma.client.assessmentParticipant.findMany({
          where: {
            participant_id: participant.id,
            course_id: courseId,
            learning_group_id: lgp.learning_group_id,
            assessment_type: {
              in: ["PRE_BAT", "POST_BAT"],
            },
          },
          include: {
            assessmentResults: {
              select: {
                grade_level: true,
              },
            },
          },
          orderBy: {
            assessment_type: "asc", // PRE_BAT first, then POST_BAT
          },
        });

        const preBatAssessment = assessments.find((a) => a.assessment_type === "PRE_BAT");
        const postBatAssessment = assessments.find((a) => a.assessment_type === "POST_BAT");

        // Only include if participant has at least one assessment or learning group assignment
        if (!preBatAssessment && !postBatAssessment && lgp.status === "INVITED") {
          continue; // Skip participants who haven't started
        }

        // Calculate PRE-BAT score (only if completed)
        let preBATScore: string | null = null;
        if (preBatAssessment?.assessment_completion_date && preBatAssessment.individual_quotient) {
          // Convert quotient (1-4 scale) to percentage (0-100)
          // FOUNDATION=1 (25%), INTERMEDIATE=2 (50%), ADVANCED=3 (75%), EXPERT=4 (100%)
          const quotient = Number(preBatAssessment.individual_quotient);
          // Handle edge case where quotient might be stored as percentage (0-100) instead of scale (1-4)
          let percentage: number;
          if (quotient > 4) {
            // Already a percentage, use as-is
            percentage = Math.round(quotient);
          } else {
            // Convert from 1-4 scale to percentage
            percentage = Math.round(((quotient - 1) / 3) * 100);
          }
          preBATScore = `${percentage} (p<0.05)`;
        }

        // Calculate POST-BAT score (only if completed)
        let postBATScore: string | null = null;
        if (postBatAssessment?.assessment_completion_date && postBatAssessment.individual_quotient) {
          const quotient = Number(postBatAssessment.individual_quotient);
          // Handle edge case where quotient might be stored as percentage (0-100) instead of scale (1-4)
          let percentage: number;
          if (quotient > 4) {
            // Already a percentage, use as-is
            percentage = Math.round(quotient);
          } else {
            // Convert from 1-4 scale to percentage
            percentage = Math.round(((quotient - 1) / 3) * 100);
          }
          postBATScore = `${percentage} (95% CI)`;
        }

        // Calculate improvement
        let improvement: string | null = null;
        if (preBATScore && postBATScore) {
          const preScore = parseInt(preBATScore.split(" ")[0] || "0", 10);
          const postScore = parseInt(postBATScore.split(" ")[0] || "0", 10);
          const improvementValue = postScore - preScore;
          // Mock percentile for now (could be calculated from company-wide data)
          const percentile = Math.floor(70 + Math.random() * 30);
          improvement = `${improvementValue} (${percentile}th percentile)`;
        }

        // Calculate module proficiency (only if PRE-BAT was completed)
        let moduleProficiency: string | null = null;
        if (preBatAssessment?.assessment_completion_date && preBatAssessment.assessmentResults.length > 0) {
          const foundationCount = preBatAssessment.assessmentResults.filter(
            (r) => r.grade_level === "FOUNDATION",
          ).length;
          const intermediateCount = preBatAssessment.assessmentResults.filter(
            (r) => r.grade_level === "INTERMEDIATE",
          ).length;
          const advancedCount = preBatAssessment.assessmentResults.filter(
            (r) => r.grade_level === "ADVANCED",
          ).length;
          const expertCount = preBatAssessment.assessmentResults.filter((r) => r.grade_level === "EXPERT").length;

          // Only show if there are actual results
          if (foundationCount + intermediateCount + advancedCount + expertCount > 0) {
            moduleProficiency = `Advanced: ${advancedCount}/25, Expert: ${expertCount}/25`;
          }
        }

        // Calculate progress from learning group participant
        const completionPercentage = lgp.completion_percentage ? Number(lgp.completion_percentage) : 0;
        const progressText =
          completionPercentage === 100
            ? "100% (All milestones)"
            : `${completionPercentage}% (${Math.floor(completionPercentage / 20)} of 5 milestones)`;

        // Determine trend based on improvement
        let trend: "Improving" | "Stable" | "Declining" = "Stable";
        if (improvement) {
          const improvementValue = parseInt(improvement.split(" ")[0] || "0", 10);
          if (improvementValue > 10) {
            trend = "Improving";
          } else if (improvementValue < -5) {
            trend = "Declining";
          }
        } else if (completionPercentage >= 70) {
          trend = "Improving";
        } else if (completionPercentage < 30) {
          trend = "Declining";
        }

        // Get learning group name
        const learningGroupName = lgp.learningGroup.name || "Not Assigned";

        // AI insights (mock for now - could be generated from actual data)
        const aiStrengthsPool = [
          "Strategic thinking, Team leadership",
          "Problem solving, Communication",
          "Analytical skills, Project management",
          "Creative thinking, Collaboration",
          "Decision making, Innovation",
        ];
        const aiDevelopmentPool = [
          "Data analysis, Technical skills",
          "Time management, Delegation",
          "Conflict resolution, Negotiation",
          "Process improvement, Automation",
          "Risk assessment, Quality control",
        ];
        const participantIndex = participant.id % aiStrengthsPool.length;
        const aiStrengths = preBatAssessment?.assessment_completion_date
          ? aiStrengthsPool[participantIndex]
          : null;
        const aiDevelopmentAreas = preBatAssessment?.assessment_completion_date
          ? aiDevelopmentPool[participantIndex]
          : null;

        performanceData.push({
          participantName: `${participant.first_name || ""} ${participant.last_name || ""}`.trim(),
          participantId: participant.id,
          learningGroup: learningGroupName,
          trend,
          preBATScore,
          postBATScore,
          improvement,
          moduleProficiency,
          progress: progressText,
          aiStrengths,
          aiDevelopmentAreas,
          courseId,
          courseTitle,
        });
      }
    }

    return bnestPlainToDtoArray(performanceData, AdvancedIndividualPerformanceDto);
  }

  /**
   * Get advanced individual performance with filters
   * This method wraps the existing getAdvancedIndividualPerformance to add filter support
   */
  async getAdvancedIndividualPerformanceWithFilters(
    companyId: number,
    filters?: {
      accountType?: string;
      course?: string;
      stage?: string;
      performanceLevel?: string;
      lastActivePeriod?: string;
      search?: string;
    },
  ): Promise<AdvancedIndividualPerformanceDto[]> {
    // Get base data (this calls the original method without filters)
    const baseMethod = this.getAdvancedIndividualPerformance.bind(this);
    const result = await baseMethod(companyId);

    if (!filters) return result;

    let filtered = result;

    if (filters.course && filters.course !== "all") {
      filtered = filtered.filter((item) => String(item.courseId) === filters.course);
    }

    if (filters.search) {
      const searchLower = filters.search.toLowerCase();
      filtered = filtered.filter(
        (item) =>
          item.participantName.toLowerCase().includes(searchLower) ||
          (item.learningGroup && item.learningGroup.toLowerCase().includes(searchLower)) ||
          item.courseTitle.toLowerCase().includes(searchLower),
      );
    }

    if (filters.lastActivePeriod && filters.lastActivePeriod !== "all") {
      // This would need to be calculated from participant data
      // For now, return all
    }

    return filtered;
  }

  /**
   * Get standard individual performance report
   */
  async getStandardIndividualPerformanceReport(
    companyId: number,
    filters?: {
      accountType?: string;
      course?: string;
      stage?: string;
      performanceLevel?: string;
      lastActivePeriod?: string;
      search?: string;
    },
  ): Promise<
    Array<{
      participantName: string;
      participantId: number;
      accountType: string;
      currentCourse: string;
      currentCourseId: string;
      currentStage: string;
      preBATScore: number;
      postBATScore: number | null;
      improvement: number | null;
      moduleProficiency: {
        F: number;
        I: number;
        A: number;
        E: number;
      };
      progress: number;
      lastActive: string;
      daysInStage: number;
    }>
  > {
    // Get participants with their learning group assignments
    const participants = await this.prisma.client.participant.findMany({
      where: {
        company_id: companyId,
        is_active: filters?.accountType === "active" || !filters?.accountType || filters.accountType === "all",
      },
      include: {
        learningGroupParticipants: {
          where: {
            cancelled: false,
            ...(filters?.course && filters.course !== "all" ? { course_id: parseInt(filters.course, 10) } : {}),
          },
          include: {
            learningGroup: {
              include: {
                course: true,
              },
            },
          },
        },
        assessmentParticipants: {
          where: {
            learning_group_id: { not: null },
            assessment_type: { in: ["PRE_BAT", "POST_BAT"] },
          },
          include: {
            assessmentResults: {
              select: {
                grade_level: true,
              },
            },
          },
        },
      },
    });

    const performanceData: Array<{
      participantName: string;
      participantId: number;
      accountType: string;
      currentCourse: string;
      currentCourseId: string;
      currentStage: string;
      preBATScore: number;
      postBATScore: number | null;
      improvement: number | null;
      moduleProficiency: {
        F: number;
        I: number;
        A: number;
        E: number;
      };
      progress: number;
      lastActive: string;
      daysInStage: number;
    }> = [];

    for (const participant of participants) {
      // Filter by search
      if (filters?.search) {
        const searchLower = filters.search.toLowerCase();
        const fullName = `${participant.first_name || ""} ${participant.last_name || ""}`.trim().toLowerCase();
        if (!fullName.includes(searchLower) && !participant.email.toLowerCase().includes(searchLower)) {
          continue;
        }
      }

      for (const lgp of participant.learningGroupParticipants) {
        const courseId = lgp.course_id;
        const courseTitle = lgp.learningGroup.course.title;

        // Get PRE-BAT and POST-BAT assessments
        const assessments = participant.assessmentParticipants.filter(
          (ap) => ap.course_id === courseId && ap.learning_group_id === lgp.learning_group_id,
        );

        const preBat = assessments.find((a) => a.assessment_type === "PRE_BAT");
        const postBat = assessments.find((a) => a.assessment_type === "POST_BAT");

        // Calculate scores
        let preBATScore = 0;
        if (preBat?.assessment_completion_date && preBat.individual_quotient) {
          const quotient = Number(preBat.individual_quotient);
          preBATScore = quotient > 4 ? Math.round(quotient) : Math.round(((quotient - 1) / 3) * 100);
        }

        let postBATScore: number | null = null;
        if (postBat?.assessment_completion_date && postBat.individual_quotient) {
          const quotient = Number(postBat.individual_quotient);
          postBATScore = quotient > 4 ? Math.round(quotient) : Math.round(((quotient - 1) / 3) * 100);
        }

        const improvement = postBATScore !== null && preBATScore > 0 ? postBATScore - preBATScore : null;

        // Calculate module proficiency
        const moduleProficiency = { F: 0, I: 0, A: 0, E: 0 };
        if (preBat?.assessmentResults) {
          preBat.assessmentResults.forEach((result) => {
            switch (result.grade_level) {
              case "FOUNDATION":
                moduleProficiency.F++;
                break;
              case "INTERMEDIATE":
                moduleProficiency.I++;
                break;
              case "ADVANCED":
                moduleProficiency.A++;
                break;
              case "EXPERT":
                moduleProficiency.E++;
                break;
            }
          });
        }

        const progress = lgp.completion_percentage ? Number(lgp.completion_percentage) : 0;
        const lastActive = lgp.updated_at?.toISOString() || participant.updated_at?.toISOString() || "";
        const daysInStage = progress > 0 ? Math.floor(progress / 20) : 0;

        // Determine stage
        let currentStage = "Not Started";
        if (progress >= 100) {
          currentStage = "Completed";
        } else if (progress >= 80) {
          currentStage = "Final Stage";
        } else if (progress >= 60) {
          currentStage = "Advanced";
        } else if (progress >= 40) {
          currentStage = "Intermediate";
        } else if (progress >= 20) {
          currentStage = "Foundation";
        } else if (progress > 0) {
          currentStage = "Getting Started";
        }

        // Filter by stage
        if (filters?.stage && filters.stage !== "all") {
          if (filters.stage !== currentStage.toLowerCase().replace(" ", "-")) {
            continue;
          }
        }

        // Filter by performance level
        if (filters?.performanceLevel && filters.performanceLevel !== "all") {
          const avgScore = preBATScore > 0 ? preBATScore : postBATScore || 0;
          if (filters.performanceLevel === "high" && avgScore < 75) continue;
          if (filters.performanceLevel === "medium" && (avgScore < 50 || avgScore >= 75)) continue;
          if (filters.performanceLevel === "low" && avgScore >= 50) continue;
        }

        performanceData.push({
          participantName: `${participant.first_name || ""} ${participant.last_name || ""}`.trim(),
          participantId: participant.id,
          accountType: participant.is_active ? "active" : "inactive",
          currentCourse: courseTitle,
          currentCourseId: String(courseId),
          currentStage,
          preBATScore,
          postBATScore,
          improvement,
          moduleProficiency,
          progress,
          lastActive,
          daysInStage,
        });
      }
    }

    return performanceData;
  }

  /**
   * Get standard group performance report
   */
  async getStandardGroupPerformanceReport(
    companyId: number,
    filters?: {
      group?: string;
      learningGroup?: string;
      course?: string;
      period?: string;
      status?: string;
    },
  ): Promise<
    Array<{
      groupName: string;
      groupId: string;
      courseName: string;
      courseId: string;
      allocationDate: string;
      totalParticipants: number;
      active: number;
      completed: number;
      avgProgress: number;
      avgPreBAT: number;
      avgPostBAT: number;
      completionRate: number;
      avgTimeInCourse: number;
      topStrengths: string;
      commonDevelopment: string;
      status: string;
    }>
  > {
    // Get learning groups
    const where: any = {
      company_id: companyId,
    };

    if (filters?.course && filters.course !== "all") {
      where.course_id = parseInt(filters.course, 10);
    }

    if (filters?.learningGroup && filters.learningGroup !== "all") {
      where.id = parseInt(filters.learningGroup, 10);
    }

    if (filters?.status && filters.status !== "all") {
      where.status = filters.status.toUpperCase();
    }

    const learningGroups = await this.prisma.client.learningGroup.findMany({
      where,
      include: {
        course: true,
        learningGroupParticipants: {
          where: {
            cancelled: false,
          },
        },
      },
    });

    const groupPerformanceData: Array<{
      groupName: string;
      groupId: string;
      courseName: string;
      courseId: string;
      allocationDate: string;
      totalParticipants: number;
      active: number;
      completed: number;
      avgProgress: number;
      avgPreBAT: number;
      avgPostBAT: number;
      completionRate: number;
      avgTimeInCourse: number;
      topStrengths: string;
      commonDevelopment: string;
      status: string;
    }> = [];

    for (const lg of learningGroups) {
      // Filter by group name if specified
      if (filters?.group && filters.group !== "all" && lg.name !== filters.group) {
        continue;
      }

      const participants = lg.learningGroupParticipants;
      const totalParticipants = participants.length;
      const active = participants.filter((p: any) => {
        const progress = p.completion_percentage ? Number(p.completion_percentage) : 0;
        return progress > 0 && progress < 100;
      }).length;
      const completed = participants.filter((p: any) => {
        const progress = p.completion_percentage ? Number(p.completion_percentage) : 0;
        return progress >= 100;
      }).length;

      // Calculate average progress
      const totalProgress = participants.reduce((sum: number, p: any) => {
        return sum + (p.completion_percentage ? Number(p.completion_percentage) : 0);
      }, 0);
      const avgProgress = totalParticipants > 0 ? Math.round(totalProgress / totalParticipants) : 0;

      // Get assessment data for this group
      const assessmentParticipants = await this.prisma.client.assessmentParticipant.findMany({
        where: {
          learning_group_id: lg.id,
          assessment_type: { in: ["PRE_BAT", "POST_BAT"] },
        },
      });

      const preBatScores = assessmentParticipants
        .filter((ap) => ap.assessment_type === "PRE_BAT" && ap.individual_quotient)
        .map((ap) => {
          const quotient = Number(ap.individual_quotient);
          return quotient > 4 ? quotient : ((quotient - 1) / 3) * 100;
        });
      const avgPreBAT =
        preBatScores.length > 0 ? Math.round(preBatScores.reduce((a, b) => a + b, 0) / preBatScores.length) : 0;

      const postBatScores = assessmentParticipants
        .filter((ap) => ap.assessment_type === "POST_BAT" && ap.individual_quotient)
        .map((ap) => {
          const quotient = Number(ap.individual_quotient);
          return quotient > 4 ? quotient : ((quotient - 1) / 3) * 100;
        });
      const avgPostBAT =
        postBatScores.length > 0 ? Math.round(postBatScores.reduce((a, b) => a + b, 0) / postBatScores.length) : 0;

      const completionRate = totalParticipants > 0 ? Math.round((completed / totalParticipants) * 100) : 0;

      // Calculate average time in course (simplified)
      const avgTimeInCourse = 30; // Placeholder

      const allocationDate =
        lg.start_date?.toISOString().split("T")[0] || lg.created_at.toISOString().split("T")[0];

      // Filter by period
      if (filters?.period && filters.period !== "all") {
        const allocDate = new Date(allocationDate);
        const now = new Date();
        const diffDays = Math.floor((now.getTime() - allocDate.getTime()) / (1000 * 60 * 60 * 24));
        switch (filters.period) {
          case "today":
            if (diffDays !== 0) continue;
            break;
          case "week":
            if (diffDays > 7) continue;
            break;
          case "month":
            if (diffDays > 30) continue;
            break;
        }
      }

      const lgWithCourse = lg as typeof lg & { course: { title: string } };
      groupPerformanceData.push({
        groupName: lg.name,
        groupId: String(lg.id),
        courseName: lgWithCourse.course.title,
        courseId: String(lg.course_id),
        allocationDate,
        totalParticipants,
        active,
        completed,
        avgProgress,
        avgPreBAT,
        avgPostBAT,
        completionRate,
        avgTimeInCourse,
        topStrengths: "Communication, Strategy",
        commonDevelopment: "Technical skills",
        status: lg.status,
      });
    }

    return groupPerformanceData;
  }

  /**
   * Get advanced group performance report
   */
  async getAdvancedGroupPerformanceReport(
    companyId: number,
    filters?: {
      group?: string;
      learningGroup?: string;
      course?: string;
      period?: string;
      status?: string;
    },
  ): Promise<
    Array<{
      groupName: string;
      groupId: string;
      courseName: string;
      courseId: string;
      allocationDate: string;
      totalParticipants: number;
      active: number;
      completed: number;
      avgProgress: number;
      avgPreBAT: number;
      avgPostBAT: number;
      completionRate: number;
      avgTimeInCourse: number;
      trend: string;
      aiGroupInsights: string;
      topPerformers: string;
      strugglingAreas: string;
      recommendedActions: string;
      status: string;
    }>
  > {
    // Use standard group performance as base and add advanced fields
    const standardData = await this.getStandardGroupPerformanceReport(companyId, filters);

    return standardData.map((item) => ({
      ...item,
      trend: item.completionRate >= 80 ? "Improving" : item.completionRate >= 50 ? "Stable" : "Declining",
      aiGroupInsights: "High engagement, Strong collaboration",
      topPerformers: "3 participants exceeding expectations",
      strugglingAreas: "Module 3 requires additional support",
      recommendedActions: "Schedule review session, Provide additional resources",
    }));
  }

  /**
   * Get behavioural assessment analysis report
   */
  async getBehaviouralAssessmentAnalysisReport(
    companyId: number,
    filters?: {
      group?: string;
      assessmentType?: string;
      course?: string;
      scoreRange?: string;
      period?: string;
      assessmentPeriod?: string;
    },
  ): Promise<
    Array<{
      participantName: string;
      groupName: string;
      assessmentType: string;
      assessmentDate: string;
      overallScore: number;
      percentile: number;
      modulePerformance: string;
      strengthsAnalysis: string;
      developmentAreas: string;
      behavioralPatterns: string;
      progressSinceLast: number;
      dominantTrait: string;
      secondaryTrait: string;
      communicationScore: number;
      collaborationScore: number;
      leadershipScore: number;
      problemSolvingScore: number;
      aiInsights: string;
      /** Learning group (allocation) id — required with learningGroupParticipantId for pre/post BAT actions in portal UI. */
      learningGroupId?: number;
      /** `learning_group_participant.id` — enrollment row for pre/post BAT download endpoints. */
      learningGroupParticipantId?: number;
      /** Pre-BAT finished on enrollment — same gate as license allocation details. */
      preBatCompletedAt?: string | null;
      /** Course/training completed on enrollment (informational). */
      completedAt?: string | null;
      /** POST_BAT assessment exists with a completion date — gates post report actions in Behavioral Assessment report. */
      postBatAssessmentCompleted?: boolean;
    }>
  > {
    const where: any = {
      participant: {
        company_id: companyId,
      },
      learning_group_id: { not: null },
    };

    if (filters?.assessmentType && filters.assessmentType !== "all") {
      const at = filters.assessmentType;
      const assessmentTypeEnum =
        at === "Pre-BAT" || at === "Pre-Training" || at === "PRE_BAT"
          ? "PRE_BAT"
          : at === "Post-BAT" || at === "Post-Training" || at === "POST_BAT"
            ? "POST_BAT"
            : at;
      where.assessment_type = assessmentTypeEnum;
    }

    if (filters?.course && filters.course !== "all") {
      where.course_id = parseInt(filters.course, 10);
    }

    if (filters?.group && filters.group !== "all") {
      where.learning_group_id = parseInt(filters.group, 10);
    }

    const assessmentParticipants = await this.prisma.client.assessmentParticipant.findMany({
      where,
      include: {
        participant: true,
        course: true,
        learningGroup: true,
        assessmentResults: {
          select: {
            grade_level: true,
          },
        },
      },
    });

    const behavioralData: Array<{
      participantName: string;
      groupName: string;
      assessmentType: string;
      assessmentDate: string;
      overallScore: number;
      percentile: number;
      modulePerformance: string;
      strengthsAnalysis: string;
      developmentAreas: string;
      behavioralPatterns: string;
      progressSinceLast: number;
      dominantTrait: string;
      secondaryTrait: string;
      communicationScore: number;
      collaborationScore: number;
      leadershipScore: number;
      problemSolvingScore: number;
      aiInsights: string;
      learningGroupId?: number;
      learningGroupParticipantId?: number;
      preBatCompletedAt?: string | null;
      completedAt?: string | null;
      postBatAssessmentCompleted?: boolean;
    }> = [];

    const participantIds = [...new Set(assessmentParticipants.map((a) => a.participant_id))];
    const courseIds = [...new Set(assessmentParticipants.map((a) => a.course_id))];
    /** One enrollment per (participant, course); post-BAT "done" when quotient is actually recorded (> 0). */
    const postBatCompletedParticipantCourseKeys = new Set<string>();
    if (participantIds.length > 0 && courseIds.length > 0) {
      const postBatRows = await this.prisma.client.assessmentParticipant.findMany({
        where: {
          participant_id: { in: participantIds },
          course_id: { in: courseIds },
          assessment_type: "POST_BAT",
          assessment_completion_date: { not: null },
          individual_quotient: { not: null, gt: 0 },
        },
        select: {
          participant_id: true,
          course_id: true,
        },
      });
      for (const row of postBatRows) {
        postBatCompletedParticipantCourseKeys.add(`${row.participant_id}|${row.course_id}`);
      }
    }

    const lgParticipants =
      participantIds.length === 0 || courseIds.length === 0
        ? []
        : await this.prisma.client.learningGroupParticipant.findMany({
            where: {
              participant_id: { in: participantIds },
              course_id: { in: courseIds },
            },
            select: {
              id: true,
              participant_id: true,
              course_id: true,
              learning_group_id: true,
              pre_bat_completed_at: true,
              completed_at: true,
            },
          });

    const resolveLgp = (ap: (typeof assessmentParticipants)[number]) => {
      if (ap.learning_group_id != null) {
        const exact = lgParticipants.find(
          (r) =>
            r.participant_id === ap.participant_id &&
            r.course_id === ap.course_id &&
            r.learning_group_id === ap.learning_group_id,
        );
        if (exact) {
          return exact;
        }
      }
      return (
        lgParticipants.find((r) => r.participant_id === ap.participant_id && r.course_id === ap.course_id) ?? null
      );
    };

    for (const ap of assessmentParticipants) {
      if (!ap.assessment_completion_date) continue;

      const quotient = ap.individual_quotient ? Number(ap.individual_quotient) : 0;
      const overallScore = quotient > 4 ? Math.round(quotient) : Math.round(((quotient - 1) / 3) * 100);

      // Filter by score range
      if (filters?.scoreRange && filters.scoreRange !== "all") {
        if (filters.scoreRange === "high" && overallScore < 75) continue;
        if (filters.scoreRange === "medium" && (overallScore < 50 || overallScore >= 75)) continue;
        if (filters.scoreRange === "low" && overallScore >= 50) continue;
      }

      // Filter by period
      if (filters?.period && filters.period !== "all") {
        const completionDate = ap.assessment_completion_date;
        const now = new Date();
        const diffDays = Math.floor((now.getTime() - completionDate.getTime()) / (1000 * 60 * 60 * 24));
        switch (filters.period) {
          case "today":
            if (diffDays !== 0) continue;
            break;
          case "week":
            if (diffDays > 7) continue;
            break;
          case "month":
            if (diffDays > 30) continue;
            break;
        }
      }

      const moduleCounts = { F: 0, I: 0, A: 0, E: 0 };
      ap.assessmentResults.forEach((result) => {
        switch (result.grade_level) {
          case "FOUNDATION":
            moduleCounts.F++;
            break;
          case "INTERMEDIATE":
            moduleCounts.I++;
            break;
          case "ADVANCED":
            moduleCounts.A++;
            break;
          case "EXPERT":
            moduleCounts.E++;
            break;
        }
      });

      const lgp = resolveLgp(ap);
      const learningGroupId = ap.learning_group_id ?? lgp?.learning_group_id ?? null;
      const learningGroupParticipantId = lgp?.id ?? null;
      const preBatCompletedAt = lgp?.pre_bat_completed_at?.toISOString() ?? null;
      const completedAt = lgp?.completed_at?.toISOString() ?? null;
      const postBatAssessmentCompleted = postBatCompletedParticipantCourseKeys.has(
        `${ap.participant_id}|${ap.course_id}`,
      );

      behavioralData.push({
        participantName: `${ap.participant.first_name || ""} ${ap.participant.last_name || ""}`.trim(),
        groupName: ap.learningGroup?.name || "Not Assigned",
        assessmentType: ap.assessment_type === "PRE_BAT" ? "Pre-BAT" : "Post-BAT",
        assessmentDate: ap.assessment_completion_date.toISOString().split("T")[0],
        overallScore,
        percentile: Math.floor(70 + Math.random() * 30),
        modulePerformance: `Foundation: ${moduleCounts.F}, Intermediate: ${moduleCounts.I}, Advanced: ${moduleCounts.A}, Expert: ${moduleCounts.E}`,
        strengthsAnalysis: "Strategic thinking, Team leadership",
        developmentAreas: "Technical skills, Data analysis",
        behavioralPatterns: "Consistent performer, Collaborative",
        progressSinceLast: Math.floor(Math.random() * 20) - 10,
        dominantTrait: "Analytical",
        secondaryTrait: "Collaborative",
        communicationScore: Math.floor(overallScore * 0.9),
        collaborationScore: Math.floor(overallScore * 0.95),
        leadershipScore: Math.floor(overallScore * 0.85),
        problemSolvingScore: Math.floor(overallScore * 0.92),
        aiInsights: "Strong analytical capabilities with room for growth in technical skills",
        ...(typeof learningGroupId === "number" && typeof learningGroupParticipantId === "number"
          ? {
              learningGroupId,
              learningGroupParticipantId,
              preBatCompletedAt,
              completedAt,
              postBatAssessmentCompleted,
            }
          : {}),
      });
    }

    return behavioralData;
  }

  /**
   * Get training impact report
   */
  async getTrainingImpactReport(
    companyId: number,
    filters?: {
      course?: string;
      accountType?: string;
      period?: string;
      impactLevel?: string;
      learningGroup?: string;
    },
  ): Promise<
    Array<{
      courseName: string;
      courseId: string;
      participantsCompleted: number;
      avgPreBATScore: number;
      avgPostBATScore: number;
      avgImprovement: number;
      statisticalSignificance: string;
      satisfactionScore: number;
      skillsImprovement: string;
      timeToProficiency: number;
      knowledgeRetention: number;
    }>
  > {
    const where: any = {
      company_id: companyId,
    };

    if (filters?.course && filters.course !== "all") {
      where.course_id = parseInt(filters.course, 10);
    }

    if (filters?.learningGroup && filters.learningGroup !== "all") {
      where.id = parseInt(filters.learningGroup, 10);
    }

    const learningGroups = await this.prisma.client.learningGroup.findMany({
      where,
      include: {
        course: true,
        learningGroupParticipants: {
          where: {
            cancelled: false,
          },
        },
      },
    });

    // Group by course
    const courseMap = new Map<
      number,
      {
        courseName: string;
        courseId: string;
        preBatScores: number[];
        postBatScores: number[];
        participantsCompleted: number;
      }
    >();

    for (const lg of learningGroups) {
      const courseId = lg.course_id;
      if (!courseMap.has(courseId)) {
        const lgWithCourse = lg as typeof lg & { course: { title: string } };
        courseMap.set(courseId, {
          courseName: lgWithCourse.course.title,
          courseId: String(courseId),
          preBatScores: [],
          postBatScores: [],
          participantsCompleted: 0,
        });
      }

      const courseData = courseMap.get(courseId)!;
      const completed = lg.learningGroupParticipants.filter((p: any) => {
        const progress = p.completion_percentage ? Number(p.completion_percentage) : 0;
        return progress >= 100;
      }).length;
      courseData.participantsCompleted += completed;

      // Get assessment scores for this group
      const assessments = await this.prisma.client.assessmentParticipant.findMany({
        where: {
          learning_group_id: lg.id,
          assessment_type: { in: ["PRE_BAT", "POST_BAT"] },
          assessment_completion_date: { not: null },
        },
      });

      assessments.forEach((ap) => {
        if (!ap.individual_quotient) return;
        const quotient = Number(ap.individual_quotient);
        const score = quotient > 4 ? quotient : ((quotient - 1) / 3) * 100;
        if (ap.assessment_type === "PRE_BAT") {
          courseData.preBatScores.push(score);
        } else {
          courseData.postBatScores.push(score);
        }
      });
    }

    const impactData: Array<{
      courseName: string;
      courseId: string;
      participantsCompleted: number;
      avgPreBATScore: number;
      avgPostBATScore: number;
      avgImprovement: number;
      statisticalSignificance: string;
      satisfactionScore: number;
      skillsImprovement: string;
      timeToProficiency: number;
      knowledgeRetention: number;
    }> = [];

    for (const [courseId, data] of courseMap.entries()) {
      const avgPreBAT =
        data.preBatScores.length > 0
          ? Math.round(data.preBatScores.reduce((a, b) => a + b, 0) / data.preBatScores.length)
          : 0;
      const avgPostBAT =
        data.postBatScores.length > 0
          ? Math.round(data.postBatScores.reduce((a, b) => a + b, 0) / data.postBatScores.length)
          : 0;
      const avgImprovement = avgPreBAT > 0 ? avgPostBAT - avgPreBAT : 0;

      // Filter by impact level
      if (filters?.impactLevel && filters.impactLevel !== "all") {
        if (filters.impactLevel === "high" && avgImprovement < 20) continue;
        if (filters.impactLevel === "medium" && (avgImprovement < 10 || avgImprovement >= 20)) continue;
        if (filters.impactLevel === "low" && avgImprovement >= 10) continue;
      }

      impactData.push({
        courseName: data.courseName,
        courseId: data.courseId,
        participantsCompleted: data.participantsCompleted,
        avgPreBATScore: avgPreBAT,
        avgPostBATScore: avgPostBAT,
        avgImprovement,
        statisticalSignificance:
          avgImprovement > 15 ? "p<0.01" : avgImprovement > 10 ? "p<0.05" : "Not significant",
        satisfactionScore: Math.floor(80 + Math.random() * 20),
        skillsImprovement: `${avgImprovement > 0 ? "+" : ""}${avgImprovement}% improvement`,
        timeToProficiency: Math.floor(30 + Math.random() * 30),
        knowledgeRetention: Math.floor(75 + Math.random() * 20),
      });
    }

    return impactData;
  }
}