import "server-only";
import { cache } from "react";
import { prisma } from "@/lib/db";
import type {
  AccountStatus,
  EnrollmentStatus,
  Prisma,
  PublishStatus,
  Role,
  XpSource,
} from "@prisma/client";

/**
 * Administrative reads: the user directory, the audit trail and platform
 * reports.
 *
 * Every access rule is expressed in SQL rather than post-filtered in the page,
 * so a row the actor may not see is never serialised into the RSC payload. In
 * particular `getPlatformReport` narrows a teacher's report to the classes they
 * teach and the courses they own (mirroring `courseAccessFilter`).
 */

export const USER_PAGE_SIZE = 20;
export const AUDIT_PAGE_SIZE = 25;

export interface Paginated<T> {
  rows: T[];
  total: number;
  page: number;
  pageSize: number;
  pageCount: number;
}

/** Clamp a 1-based page number to the valid range for `total` rows. */
function resolvePage(requested: number | undefined, total: number, pageSize: number): number {
  const pageCount = Math.max(1, Math.ceil(total / pageSize));
  const value = requested && Number.isFinite(requested) ? Math.floor(requested) : 1;
  return Math.min(Math.max(1, value), pageCount);
}

// ---------------------------------------------------------------------------
// Users
// ---------------------------------------------------------------------------

export interface AdminUserFilters {
  search?: string;
  role?: Role;
  status?: AccountStatus;
  page?: number;
}

export interface AdminUserRow {
  id: string;
  username: string;
  fullName: string;
  email: string | null;
  avatarUrl: string | null;
  role: Role;
  status: AccountStatus;
  school: string | null;
  gradeLevel: string | null;
  xp: number;
  level: number;
  lastLoginAt: Date | null;
  createdAt: Date;
  /** `_count.enrollments` — classrooms the user belongs to as a student. */
  enrollmentCount: number;
}

export async function listUsers(
  filters: AdminUserFilters = {}
): Promise<Paginated<AdminUserRow>> {
  const search = filters.search?.trim();

  const where: Prisma.UserWhereInput = {};
  if (filters.role) where.role = filters.role;
  if (filters.status) where.status = filters.status;
  if (search) {
    where.OR = [
      { username: { contains: search, mode: "insensitive" } },
      { fullName: { contains: search, mode: "insensitive" } },
      { email: { contains: search, mode: "insensitive" } },
    ];
  }

  const total = await prisma.user.count({ where });
  const page = resolvePage(filters.page, total, USER_PAGE_SIZE);

  const users = await prisma.user.findMany({
    where,
    orderBy: [{ role: "asc" }, { fullName: "asc" }],
    skip: (page - 1) * USER_PAGE_SIZE,
    take: USER_PAGE_SIZE,
    select: {
      id: true,
      username: true,
      fullName: true,
      email: true,
      avatarUrl: true,
      role: true,
      status: true,
      school: true,
      gradeLevel: true,
      xp: true,
      level: true,
      lastLoginAt: true,
      createdAt: true,
      _count: { select: { enrollments: true } },
    },
  });

  return {
    rows: users.map((user) => ({
      id: user.id,
      username: user.username,
      fullName: user.fullName,
      email: user.email,
      avatarUrl: user.avatarUrl,
      role: user.role,
      status: user.status,
      school: user.school,
      gradeLevel: user.gradeLevel,
      xp: user.xp,
      level: user.level,
      lastLoginAt: user.lastLoginAt,
      createdAt: user.createdAt,
      enrollmentCount: user._count.enrollments,
    })),
    total,
    page,
    pageSize: USER_PAGE_SIZE,
    pageCount: Math.max(1, Math.ceil(total / USER_PAGE_SIZE)),
  };
}

export interface AdminUserSummary {
  total: number;
  active: number;
  suspended: number;
  pending: number;
  byRole: { role: Role; count: number }[];
}

/** Whole-directory counts for the header tiles, independent of the active filter. */
export async function getUserSummary(): Promise<AdminUserSummary> {
  const [total, statusGroups, roleGroups] = await Promise.all([
    prisma.user.count(),
    prisma.user.groupBy({ by: ["status"], _count: { _all: true } }),
    prisma.user.groupBy({ by: ["role"], _count: { _all: true } }),
  ]);

  const statusCount = (status: AccountStatus) =>
    statusGroups.find((group) => group.status === status)?._count._all ?? 0;

  const roleOrder: Role[] = ["ADMIN", "TEACHER", "STUDENT"];

  return {
    total,
    active: statusCount("ACTIVE"),
    suspended: statusCount("SUSPENDED"),
    pending: statusCount("PENDING"),
    byRole: roleOrder.map((role) => ({
      role,
      count: roleGroups.find((group) => group.role === role)?._count._all ?? 0,
    })),
  };
}

export interface AdminUserProfile {
  id: string;
  username: string;
  fullName: string;
  email: string | null;
  phone: string | null;
  bio: string | null;
  avatarUrl: string | null;
  role: Role;
  status: AccountStatus;
  school: string | null;
  gradeLevel: string | null;
  xp: number;
  level: number;
  lastLoginAt: Date | null;
  createdAt: Date;
  updatedAt: Date;
}

export interface AdminUserClassRow {
  id: string;
  name: string;
  code: string;
  status: EnrollmentStatus;
  enrolledAt: Date;
}

export interface AdminUserTaughtClassRow {
  id: string;
  name: string;
  code: string;
  studentCount: number;
}

export interface AdminUserCourseRow {
  id: string;
  title: string;
  status: PublishStatus;
  studentCount: number;
}

export interface AdminUserAuditRow {
  id: string;
  action: string;
  entity: string | null;
  entityId: string | null;
  createdAt: Date;
}

export interface AdminUserXpRow {
  id: string;
  amount: number;
  source: XpSource;
  reason: string;
  createdAt: Date;
}

export interface AdminUserSkillRow {
  id: string;
  name: string;
  icon: string;
  color: string;
  level: number;
  maxLevel: number;
  xp: number;
}

export interface AdminUserDetail {
  profile: AdminUserProfile;
  counts: {
    classes: number;
    taughtClasses: number;
    coursesTaught: number;
    courseEnrollments: number;
    submissions: number;
    assignmentsAuthored: number;
    achievements: number;
    xpEvents: number;
  };
  classes: AdminUserClassRow[];
  taughtClasses: AdminUserTaughtClassRow[];
  courses: AdminUserCourseRow[];
  auditLogs: AdminUserAuditRow[];
  xpEvents: AdminUserXpRow[];
  skills: AdminUserSkillRow[];
}

/** Deduplicated per request so `generateMetadata` and the page share one query. */
export const getUserDetail = cache(async (userId: string): Promise<AdminUserDetail | null> => {
  const user = await prisma.user.findUnique({
    where: { id: userId },
    select: {
      id: true,
      username: true,
      fullName: true,
      email: true,
      phone: true,
      bio: true,
      avatarUrl: true,
      role: true,
      status: true,
      school: true,
      gradeLevel: true,
      xp: true,
      level: true,
      lastLoginAt: true,
      createdAt: true,
      updatedAt: true,
      _count: {
        select: {
          enrollments: true,
          taughtClasses: true,
          createdCourses: true,
          courseEnrollments: true,
          submissions: true,
          createdAssignments: true,
          achievements: true,
          xpEvents: true,
        },
      },
      enrollments: {
        orderBy: { enrolledAt: "desc" },
        select: {
          status: true,
          enrolledAt: true,
          classroom: { select: { id: true, name: true, code: true } },
        },
      },
      taughtClasses: {
        orderBy: { name: "asc" },
        select: {
          id: true,
          name: true,
          code: true,
          _count: { select: { enrollments: true } },
        },
      },
      createdCourses: {
        orderBy: { title: "asc" },
        select: {
          id: true,
          title: true,
          status: true,
          _count: { select: { enrollments: true } },
        },
      },
      auditLogs: {
        orderBy: { createdAt: "desc" },
        take: 10,
        select: { id: true, action: true, entity: true, entityId: true, createdAt: true },
      },
      xpEvents: {
        orderBy: { createdAt: "desc" },
        take: 10,
        select: { id: true, amount: true, source: true, reason: true, createdAt: true },
      },
      skills: {
        orderBy: { xp: "desc" },
        select: {
          id: true,
          level: true,
          xp: true,
          skill: { select: { name: true, icon: true, color: true, maxLevel: true } },
        },
      },
    },
  });

  if (!user) return null;

  return {
    profile: {
      id: user.id,
      username: user.username,
      fullName: user.fullName,
      email: user.email,
      phone: user.phone,
      bio: user.bio,
      avatarUrl: user.avatarUrl,
      role: user.role,
      status: user.status,
      school: user.school,
      gradeLevel: user.gradeLevel,
      xp: user.xp,
      level: user.level,
      lastLoginAt: user.lastLoginAt,
      createdAt: user.createdAt,
      updatedAt: user.updatedAt,
    },
    counts: {
      classes: user._count.enrollments,
      taughtClasses: user._count.taughtClasses,
      coursesTaught: user._count.createdCourses,
      courseEnrollments: user._count.courseEnrollments,
      submissions: user._count.submissions,
      assignmentsAuthored: user._count.createdAssignments,
      achievements: user._count.achievements,
      xpEvents: user._count.xpEvents,
    },
    classes: user.enrollments.map((enrollment) => ({
      id: enrollment.classroom.id,
      name: enrollment.classroom.name,
      code: enrollment.classroom.code,
      status: enrollment.status,
      enrolledAt: enrollment.enrolledAt,
    })),
    taughtClasses: user.taughtClasses.map((classroom) => ({
      id: classroom.id,
      name: classroom.name,
      code: classroom.code,
      studentCount: classroom._count.enrollments,
    })),
    courses: user.createdCourses.map((course) => ({
      id: course.id,
      title: course.title,
      status: course.status,
      studentCount: course._count.enrollments,
    })),
    auditLogs: user.auditLogs,
    xpEvents: user.xpEvents,
    skills: user.skills.map((entry) => ({
      id: entry.id,
      name: entry.skill.name,
      icon: entry.skill.icon,
      color: entry.skill.color,
      level: entry.level,
      maxLevel: entry.skill.maxLevel,
      xp: entry.xp,
    })),
  };
});

// ---------------------------------------------------------------------------
// Audit trail
// ---------------------------------------------------------------------------

export interface AuditLogFilters {
  action?: string;
  actorId?: string;
  entity?: string;
  page?: number;
}

export interface AuditLogRow {
  id: string;
  action: string;
  entity: string | null;
  entityId: string | null;
  metadata: Prisma.JsonValue | null;
  ipAddress: string | null;
  createdAt: Date;
  actorId: string | null;
  actorName: string | null;
  actorUsername: string | null;
}

export async function listAuditLogs(
  filters: AuditLogFilters = {}
): Promise<Paginated<AuditLogRow>> {
  const where: Prisma.AuditLogWhereInput = {};
  if (filters.action) where.action = filters.action;
  if (filters.actorId) where.actorId = filters.actorId;
  if (filters.entity) where.entity = filters.entity;

  const total = await prisma.auditLog.count({ where });
  const page = resolvePage(filters.page, total, AUDIT_PAGE_SIZE);

  const logs = await prisma.auditLog.findMany({
    where,
    orderBy: { createdAt: "desc" },
    skip: (page - 1) * AUDIT_PAGE_SIZE,
    take: AUDIT_PAGE_SIZE,
    select: {
      id: true,
      action: true,
      entity: true,
      entityId: true,
      metadata: true,
      ipAddress: true,
      createdAt: true,
      actorId: true,
      actor: { select: { fullName: true, username: true } },
    },
  });

  return {
    rows: logs.map((log) => ({
      id: log.id,
      action: log.action,
      entity: log.entity,
      entityId: log.entityId,
      metadata: log.metadata,
      ipAddress: log.ipAddress,
      createdAt: log.createdAt,
      actorId: log.actorId,
      actorName: log.actor?.fullName ?? null,
      actorUsername: log.actor?.username ?? null,
    })),
    total,
    page,
    pageSize: AUDIT_PAGE_SIZE,
    pageCount: Math.max(1, Math.ceil(total / AUDIT_PAGE_SIZE)),
  };
}

export interface AuditFacet {
  value: string;
  count: number;
}

export interface AuditActorFacet {
  id: string;
  name: string;
  username: string;
  count: number;
}

export interface AuditFacets {
  actions: AuditFacet[];
  entities: AuditFacet[];
  actors: AuditActorFacet[];
  totalEntries: number;
  distinctActors: number;
  entriesToday: number;
}

export async function getAuditFacets(): Promise<AuditFacets> {
  const startOfToday = new Date();
  startOfToday.setHours(0, 0, 0, 0);

  const [actionGroups, entityGroups, actorGroups, totalEntries, entriesToday] = await Promise.all([
    prisma.auditLog.groupBy({ by: ["action"], _count: { _all: true } }),
    prisma.auditLog.groupBy({
      by: ["entity"],
      where: { entity: { not: null } },
      _count: { _all: true },
    }),
    prisma.auditLog.groupBy({
      by: ["actorId"],
      where: { actorId: { not: null } },
      _count: { _all: true },
    }),
    prisma.auditLog.count(),
    prisma.auditLog.count({ where: { createdAt: { gte: startOfToday } } }),
  ]);

  const actions = actionGroups
    .map((group) => ({ value: group.action, count: group._count._all }))
    .sort((a, b) => b.count - a.count || a.value.localeCompare(b.value));

  const entities = entityGroups
    .map((group) => ({ value: group.entity ?? "—", count: group._count._all }))
    .sort((a, b) => b.count - a.count || a.value.localeCompare(b.value));

  const topActorGroups = [...actorGroups]
    .sort((a, b) => b._count._all - a._count._all)
    .slice(0, 10);

  const topActorIds = topActorGroups
    .map((group) => group.actorId)
    .filter((id): id is string => Boolean(id));

  const actorUsers = await prisma.user.findMany({
    where: { id: { in: topActorIds } },
    select: { id: true, fullName: true, username: true },
  });
  const userById = new Map(actorUsers.map((user) => [user.id, user]));

  const actors = topActorGroups
    .map((group) => {
      const user = group.actorId ? userById.get(group.actorId) : undefined;
      if (!user) return null;
      return {
        id: user.id,
        name: user.fullName,
        username: user.username,
        count: group._count._all,
      };
    })
    .filter((actor): actor is AuditActorFacet => actor !== null);

  return {
    actions,
    entities,
    actors,
    totalEntries,
    distinctActors: actorGroups.length,
    entriesToday,
  };
}

// ---------------------------------------------------------------------------
// Platform report
// ---------------------------------------------------------------------------

export interface ReportScope {
  userId: string;
  role: Role;
}

export interface ClassReportRow {
  id: string;
  name: string;
  code: string;
  teacherName: string;
  studentCount: number;
  /** PRESENT + LATE over every attendance record. Null when no records exist. */
  attendanceRate: number | null;
  /** Mean percentage of graded submissions by this class's students. */
  averageScore: number | null;
  /** Completed enrolments over all enrolments, 0–100. */
  completionPercent: number;
}

export interface CourseReportRow {
  id: string;
  title: string;
  enrolledCount: number;
  lessonCount: number;
  publishedAssignments: number;
  /** Received submissions over (enrolled students × published assignments). */
  submissionRate: number | null;
  averageScore: number | null;
}

export interface ScoreBucket {
  label: string;
  /** Inclusive lower bound of the bucket, for labelling and tone selection. */
  min: number;
  count: number;
  percent: number;
}

export interface AttendanceBreakdown {
  present: number;
  late: number;
  absent: number;
  excused: number;
  total: number;
  presentPercent: number;
  latePercent: number;
  absentPercent: number;
  excusedPercent: number;
  /** PRESENT + LATE over all records, 0–100. */
  attendanceRate: number;
}

export interface PlatformReport {
  role: Role;
  generatedAt: Date;
  headline: {
    totalStudents: number;
    totalClasses: number;
    totalCourses: number;
    totalAssignments: number;
    publishedAssignments: number;
    submissionsReceived: number;
    gradedSubmissions: number;
    gradingCompletionPercent: number | null;
    overallAverageScore: number | null;
  };
  classes: ClassReportRow[];
  courses: CourseReportRow[];
  scoreDistribution: ScoreBucket[];
  attendance: AttendanceBreakdown;
}

const round = (value: number) => Math.round(value * 10) / 10;

const mean = (values: number[]) =>
  values.length === 0 ? null : round(values.reduce((sum, value) => sum + value, 0) / values.length);

export async function getPlatformReport(scope: ReportScope): Promise<PlatformReport> {
  const isAdmin = scope.role === "ADMIN";

  const [classes, courses] = await Promise.all([
    prisma.classroom.findMany({
      where: { archivedAt: null, ...(isAdmin ? {} : { teacherId: scope.userId }) },
      orderBy: { name: "asc" },
      select: {
        id: true,
        name: true,
        code: true,
        teacher: { select: { fullName: true } },
        _count: { select: { enrollments: true } },
      },
    }),
    prisma.course.findMany({
      where: isAdmin
        ? {}
        : { OR: [{ teacherId: scope.userId }, { classroom: { teacherId: scope.userId } }] },
      orderBy: { title: "asc" },
      select: {
        id: true,
        title: true,
        classroomId: true,
        _count: { select: { enrollments: true, lessons: true } },
      },
    }),
  ]);

  const classIds = classes.map((classroom) => classroom.id);
  const courseIds = courses.map((course) => course.id);

  const [classEnrollments, courseEnrollments, assignments, sessions] = await Promise.all([
    prisma.classEnrollment.findMany({
      where: { classId: { in: classIds } },
      select: { classId: true, studentId: true, status: true },
    }),
    prisma.courseEnrollment.findMany({
      where: { courseId: { in: courseIds } },
      select: { courseId: true, studentId: true },
    }),
    prisma.assignment.findMany({
      where: { courseId: { in: courseIds } },
      select: { id: true, courseId: true, status: true },
    }),
    prisma.attendanceSession.findMany({
      where: { classId: { in: classIds } },
      select: { id: true, classId: true },
    }),
  ]);

  const [submissions, attendanceGroups] = await Promise.all([
    prisma.submission.findMany({
      where: { assignment: { courseId: { in: courseIds } } },
      select: {
        id: true,
        studentId: true,
        status: true,
        score: true,
        assignment: { select: { courseId: true, maxScore: true } },
      },
    }),
    prisma.attendanceRecord.groupBy({
      by: ["sessionId", "status"],
      where: { sessionId: { in: sessions.map((session) => session.id) } },
      _count: { _all: true },
    }),
  ]);

  // --- scores -------------------------------------------------------------
  const received = submissions.filter((submission) => submission.status !== "DRAFT");
  const graded = received.filter((submission) => submission.score !== null);
  const scores = graded.map((submission) =>
    Math.min(
      100,
      Math.max(0, ((submission.score ?? 0) / Math.max(1, submission.assignment.maxScore)) * 100)
    )
  );

  const gradingCompletionPercent =
    received.length === 0 ? null : round((graded.length / received.length) * 100);
  const overallAverageScore = mean(scores);

  // --- per-class aggregates ----------------------------------------------
  const classEnrollmentStats = new Map<string, { total: number; completed: number }>();
  const classIdsByStudent = new Map<string, string[]>();
  for (const enrollment of classEnrollments) {
    const stats = classEnrollmentStats.get(enrollment.classId) ?? { total: 0, completed: 0 };
    stats.total += 1;
    if (enrollment.status === "COMPLETED") stats.completed += 1;
    classEnrollmentStats.set(enrollment.classId, stats);

    const list = classIdsByStudent.get(enrollment.studentId) ?? [];
    list.push(enrollment.classId);
    classIdsByStudent.set(enrollment.studentId, list);
  }

  const classScores = new Map<string, number[]>();
  const courseScores = new Map<string, number[]>();
  const classroomByCourse = new Map(
    courses.map((course) => [course.id, course.classroomId])
  );
  graded.forEach((submission, index) => {
    const value = scores[index];
    const courseId = submission.assignment.courseId;
    const courseList = courseScores.get(courseId) ?? [];
    courseList.push(value);
    courseScores.set(courseId, courseList);

    // A course attached to a class feeds that class; an unattached course
    // falls back to the classes its students actually belong to.
    const owningClass = classroomByCourse.get(courseId);
    const targetClassIds = owningClass
      ? [owningClass]
      : (classIdsByStudent.get(submission.studentId) ?? []);
    for (const classId of targetClassIds) {
      const classList = classScores.get(classId) ?? [];
      classList.push(value);
      classScores.set(classId, classList);
    }
  });

  // --- attendance ---------------------------------------------------------
  const classIdBySession = new Map(sessions.map((session) => [session.id, session.classId]));
  const attendanceTotals = { present: 0, late: 0, absent: 0, excused: 0 };
  const attendanceByClass = new Map<
    string,
    { present: number; late: number; absent: number; excused: number }
  >();

  for (const group of attendanceGroups) {
    const classId = classIdBySession.get(group.sessionId);
    if (!classId) continue;
    const bucket = attendanceByClass.get(classId) ?? { present: 0, late: 0, absent: 0, excused: 0 };
    const count = group._count._all;

    switch (group.status) {
      case "PRESENT":
        bucket.present += count;
        attendanceTotals.present += count;
        break;
      case "LATE":
        bucket.late += count;
        attendanceTotals.late += count;
        break;
      case "ABSENT":
        bucket.absent += count;
        attendanceTotals.absent += count;
        break;
      case "EXCUSED":
        bucket.excused += count;
        attendanceTotals.excused += count;
        break;
    }

    attendanceByClass.set(classId, bucket);
  }

  // --- rows ---------------------------------------------------------------
  const classRows: ClassReportRow[] = classes.map((classroom) => {
    const stats = classEnrollmentStats.get(classroom.id) ?? { total: 0, completed: 0 };
    const attendance = attendanceByClass.get(classroom.id);
    const attendanceTotal = attendance
      ? attendance.present + attendance.late + attendance.absent + attendance.excused
      : 0;
    const present = attendance?.present ?? 0;
    const late = attendance?.late ?? 0;

    return {
      id: classroom.id,
      name: classroom.name,
      code: classroom.code,
      teacherName: classroom.teacher.fullName,
      studentCount: classroom._count.enrollments,
      attendanceRate:
        attendanceTotal === 0 ? null : round(((present + late) / attendanceTotal) * 100),
      averageScore: mean(classScores.get(classroom.id) ?? []),
      completionPercent: stats.total === 0 ? 0 : round((stats.completed / stats.total) * 100),
    };
  });

  const enrolledByCourse = new Map<string, number>();
  for (const enrollment of courseEnrollments) {
    enrolledByCourse.set(enrollment.courseId, (enrolledByCourse.get(enrollment.courseId) ?? 0) + 1);
  }

  const publishedByCourse = new Map<string, number>();
  for (const assignment of assignments) {
    if (assignment.status !== "PUBLISHED") continue;
    publishedByCourse.set(
      assignment.courseId,
      (publishedByCourse.get(assignment.courseId) ?? 0) + 1
    );
  }

  const receivedByCourse = new Map<string, number>();
  for (const submission of received) {
    const courseId = submission.assignment.courseId;
    receivedByCourse.set(courseId, (receivedByCourse.get(courseId) ?? 0) + 1);
  }

  const courseRows: CourseReportRow[] = courses.map((course) => {
    const enrolled = enrolledByCourse.get(course.id) ?? 0;
    const published = publishedByCourse.get(course.id) ?? 0;
    const expected = enrolled * published;
    const receivedCount = receivedByCourse.get(course.id) ?? 0;

    return {
      id: course.id,
      title: course.title,
      enrolledCount: enrolled,
      lessonCount: course._count.lessons,
      publishedAssignments: published,
      submissionRate:
        expected === 0 ? null : round(Math.min(100, (receivedCount / expected) * 100)),
      averageScore: mean(courseScores.get(course.id) ?? []),
    };
  });

  const bucketDefinitions = [
    { label: "0–59", min: 0 },
    { label: "60–69", min: 60 },
    { label: "70–79", min: 70 },
    { label: "80–89", min: 80 },
    { label: "90–100", min: 90 },
  ];

  // Assign by upper bound so a fractional score (e.g. 59.5 from 119/200)
  // lands in exactly one bucket instead of falling between two.
  const bucketUpperBounds = [60, 70, 80, 90, 101];
  const scoreDistribution: ScoreBucket[] = bucketDefinitions.map((bucket, index) => {
    const upper = bucketUpperBounds[index];
    const lower = index === 0 ? -Infinity : bucketUpperBounds[index - 1];
    const count = scores.filter((score) => score >= lower && score < upper).length;
    return {
      ...bucket,
      count,
      percent: scores.length === 0 ? 0 : round((count / scores.length) * 100),
    };
  });

  const attendanceTotal =
    attendanceTotals.present +
    attendanceTotals.late +
    attendanceTotals.absent +
    attendanceTotals.excused;

  const attendance: AttendanceBreakdown = {
    ...attendanceTotals,
    total: attendanceTotal,
    presentPercent: attendanceTotal === 0 ? 0 : round((attendanceTotals.present / attendanceTotal) * 100),
    latePercent: attendanceTotal === 0 ? 0 : round((attendanceTotals.late / attendanceTotal) * 100),
    absentPercent: attendanceTotal === 0 ? 0 : round((attendanceTotals.absent / attendanceTotal) * 100),
    excusedPercent: attendanceTotal === 0 ? 0 : round((attendanceTotals.excused / attendanceTotal) * 100),
    attendanceRate:
      attendanceTotal === 0
        ? 0
        : round(((attendanceTotals.present + attendanceTotals.late) / attendanceTotal) * 100),
  };

  const totalStudents = new Set([
    ...classEnrollments.map((enrollment) => enrollment.studentId),
    ...courseEnrollments.map((enrollment) => enrollment.studentId),
  ]).size;

  return {
    role: scope.role,
    generatedAt: new Date(),
    headline: {
      totalStudents,
      totalClasses: classes.length,
      totalCourses: courses.length,
      totalAssignments: assignments.length,
      publishedAssignments: assignments.filter((assignment) => assignment.status === "PUBLISHED")
        .length,
      submissionsReceived: received.length,
      gradedSubmissions: graded.length,
      gradingCompletionPercent,
      overallAverageScore,
    },
    classes: classRows,
    courses: courseRows,
    scoreDistribution,
    attendance,
  };
}
