import "server-only";
import { prisma } from "@/lib/db";
import type { AttendanceStatus, EnrollmentStatus, Role } from "@prisma/client";

/**
 * Classroom, enrolment and attendance reads.
 *
 * A teacher sees only the classes they teach; an admin sees every class; a
 * student sees the classes they belong to.
 */

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

/** Prisma fragment: classrooms the actor may read. */
function classAccessFilter(scope: ClassScope) {
  if (scope.role === "ADMIN") return {};
  if (scope.role === "TEACHER") return { teacherId: scope.userId };
  return { enrollments: { some: { studentId: scope.userId, status: "ACTIVE" as const } } };
}

export interface ClassListItem {
  id: string;
  name: string;
  code: string;
  joinCode: string;
  description: string | null;
  academicYear: string;
  gradeLevel: string | null;
  room: string | null;
  teacherName: string;
  studentCount: number;
  courseCount: number;
  attendanceRate: number | null;
  archived: boolean;
  createdAt: Date;
}

export async function listClassrooms(
  scope: ClassScope,
  filters: { search?: string; includeArchived?: boolean } = {}
): Promise<ClassListItem[]> {
  const classrooms = await prisma.classroom.findMany({
    where: {
      AND: [
        classAccessFilter(scope),
        filters.includeArchived ? {} : { archivedAt: null },
        filters.search
          ? {
              OR: [
                { name: { contains: filters.search, mode: "insensitive" as const } },
                { code: { contains: filters.search, mode: "insensitive" as const } },
              ],
            }
          : {},
      ],
    },
    orderBy: [{ archivedAt: "asc" }, { name: "asc" }],
    select: {
      id: true,
      name: true,
      code: true,
      joinCode: true,
      description: true,
      academicYear: true,
      gradeLevel: true,
      room: true,
      archivedAt: true,
      createdAt: true,
      teacher: { select: { fullName: true } },
      _count: { select: { enrollments: true, courses: true } },
      attendance: {
        select: {
          records: { select: { status: true } },
        },
      },
    },
  });

  return classrooms.map((classroom) => {
    const records = classroom.attendance.flatMap((session) => session.records);
    const present = records.filter(
      (record) => record.status === "PRESENT" || record.status === "LATE"
    ).length;

    return {
      id: classroom.id,
      name: classroom.name,
      code: classroom.code,
      joinCode: classroom.joinCode,
      description: classroom.description,
      academicYear: classroom.academicYear,
      gradeLevel: classroom.gradeLevel,
      room: classroom.room,
      teacherName: classroom.teacher.fullName,
      studentCount: classroom._count.enrollments,
      courseCount: classroom._count.courses,
      attendanceRate:
        records.length === 0 ? null : Math.round((present / records.length) * 100),
      archived: classroom.archivedAt !== null,
      createdAt: classroom.createdAt,
    };
  });
}

export interface ClassStudent {
  enrollmentId: string;
  studentId: string;
  fullName: string;
  username: string;
  avatarUrl: string | null;
  gradeLevel: string | null;
  status: EnrollmentStatus;
  enrolledAt: Date;
  attendanceRate: number | null;
  courseProgress: number | null;
}

export interface ClassDetail {
  id: string;
  name: string;
  code: string;
  joinCode: string;
  description: string | null;
  academicYear: string;
  gradeLevel: string | null;
  room: string | null;
  archived: boolean;
  createdAt: Date;
  teacher: { id: string; fullName: string; username: string };
  canManage: boolean;
  stats: {
    studentCount: number;
    activeStudentCount: number;
    courseCount: number;
    attendanceSessionCount: number;
    attendanceRate: number | null;
  };
  courses: {
    id: string;
    title: string;
    coverColor: string;
    status: string;
    lessonCount: number;
    studentCount: number;
  }[];
  students: ClassStudent[];
}

export async function getClassroom(
  scope: ClassScope,
  classId: string
): Promise<ClassDetail | null> {
  const classroom = await prisma.classroom.findFirst({
    where: { AND: [{ id: classId }, classAccessFilter(scope)] },
    select: {
      id: true,
      name: true,
      code: true,
      joinCode: true,
      description: true,
      academicYear: true,
      gradeLevel: true,
      room: true,
      archivedAt: true,
      createdAt: true,
      teacherId: true,
      teacher: { select: { id: true, fullName: true, username: true } },
      courses: {
        orderBy: { title: "asc" },
        select: {
          id: true,
          title: true,
          coverColor: true,
          status: true,
          _count: { select: { lessons: true, enrollments: true } },
        },
      },
      enrollments: {
        orderBy: { enrolledAt: "asc" },
        select: {
          id: true,
          status: true,
          enrolledAt: true,
          student: {
            select: {
              id: true,
              fullName: true,
              username: true,
              avatarUrl: true,
              gradeLevel: true,
            },
          },
        },
      },
      attendance: {
        orderBy: { date: "desc" },
        select: {
          id: true,
          date: true,
          topic: true,
          records: { select: { studentId: true, status: true } },
        },
      },
    },
  });

  if (!classroom) return null;

  const allRecords = classroom.attendance.flatMap((session) => session.records);
  const presentRecords = allRecords.filter(
    (record) => record.status === "PRESENT" || record.status === "LATE"
  ).length;

  // Per-student attendance: count their own present/late over their own records.
  const attendanceByStudent = new Map<string, { present: number; total: number }>();
  for (const record of allRecords) {
    const entry = attendanceByStudent.get(record.studentId) ?? { present: 0, total: 0 };
    entry.total += 1;
    if (record.status === "PRESENT" || record.status === "LATE") entry.present += 1;
    attendanceByStudent.set(record.studentId, entry);
  }

  // Course progress is averaged across the class's courses.
  const courseIds = classroom.courses.map((course) => course.id);
  const progressRows = courseIds.length
    ? await prisma.courseEnrollment.findMany({
        where: { courseId: { in: courseIds } },
        select: { studentId: true, progress: true },
      })
    : [];
  const progressByStudent = new Map<string, { sum: number; count: number }>();
  for (const row of progressRows) {
    const entry = progressByStudent.get(row.studentId) ?? { sum: 0, count: 0 };
    entry.sum += row.progress;
    entry.count += 1;
    progressByStudent.set(row.studentId, entry);
  }

  const students: ClassStudent[] = classroom.enrollments.map((enrollment) => {
    const attendance = attendanceByStudent.get(enrollment.student.id);
    const progress = progressByStudent.get(enrollment.student.id);
    return {
      enrollmentId: enrollment.id,
      studentId: enrollment.student.id,
      fullName: enrollment.student.fullName,
      username: enrollment.student.username,
      avatarUrl: enrollment.student.avatarUrl,
      gradeLevel: enrollment.student.gradeLevel,
      status: enrollment.status,
      enrolledAt: enrollment.enrolledAt,
      attendanceRate:
        !attendance || attendance.total === 0
          ? null
          : Math.round((attendance.present / attendance.total) * 100),
      courseProgress:
        !progress || progress.count === 0 ? null : Math.round(progress.sum / progress.count),
    };
  });

  const activeStudentCount = students.filter((student) => student.status === "ACTIVE").length;

  return {
    id: classroom.id,
    name: classroom.name,
    code: classroom.code,
    joinCode: classroom.joinCode,
    description: classroom.description,
    academicYear: classroom.academicYear,
    gradeLevel: classroom.gradeLevel,
    room: classroom.room,
    archived: classroom.archivedAt !== null,
    createdAt: classroom.createdAt,
    teacher: classroom.teacher,
    canManage: scope.role === "ADMIN" || classroom.teacherId === scope.userId,
    stats: {
      studentCount: students.length,
      activeStudentCount,
      courseCount: classroom.courses.length,
      attendanceSessionCount: classroom.attendance.length,
      attendanceRate:
        allRecords.length === 0 ? null : Math.round((presentRecords / allRecords.length) * 100),
    },
    courses: classroom.courses.map((course) => ({
      id: course.id,
      title: course.title,
      coverColor: course.coverColor,
      status: course.status,
      lessonCount: course._count.lessons,
      studentCount: course._count.enrollments,
    })),
    students,
  };
}

export interface ClassOption {
  id: string;
  name: string;
  joinCode: string;
  studentCount: number;
}

/** Classes the actor can pick in a form. */
export async function listClassOptions(scope: ClassScope): Promise<ClassOption[]> {
  const classrooms = await prisma.classroom.findMany({
    where: { AND: [classAccessFilter(scope), { archivedAt: null }] },
    orderBy: { name: "asc" },
    select: {
      id: true,
      name: true,
      joinCode: true,
      _count: { select: { enrollments: true } },
    },
  });

  return classrooms.map((classroom) => ({
    id: classroom.id,
    name: classroom.name,
    joinCode: classroom.joinCode,
    studentCount: classroom._count.enrollments,
  }));
}

// ---------------------------------------------------------------------------
// Attendance
// ---------------------------------------------------------------------------

export interface AttendanceSessionRow {
  id: string;
  date: Date;
  topic: string | null;
  note: string | null;
  classId: string;
  className: string;
  courseTitle: string | null;
  createdByName: string;
  present: number;
  late: number;
  absent: number;
  excused: number;
  total: number;
  rate: number;
}

export async function listAttendanceSessions(
  scope: ClassScope,
  filters: { classId?: string; from?: Date; to?: Date } = {}
): Promise<AttendanceSessionRow[]> {
  const sessions = await prisma.attendanceSession.findMany({
    where: {
      AND: [
        { classroom: classAccessFilter(scope) },
        filters.classId ? { classId: filters.classId } : {},
        filters.from || filters.to
          ? {
              date: {
                ...(filters.from ? { gte: filters.from } : {}),
                ...(filters.to ? { lte: filters.to } : {}),
              },
            }
          : {},
      ],
    },
    orderBy: { date: "desc" },
    select: {
      id: true,
      date: true,
      topic: true,
      note: true,
      classId: true,
      classroom: { select: { name: true } },
      course: { select: { title: true } },
      createdBy: { select: { fullName: true } },
      records: { select: { status: true } },
    },
  });

  return sessions.map((session) => {
    const count = (status: AttendanceStatus) =>
      session.records.filter((record) => record.status === status).length;

    const present = count("PRESENT");
    const late = count("LATE");
    const absent = count("ABSENT");
    const excused = count("EXCUSED");
    const total = session.records.length;

    return {
      id: session.id,
      date: session.date,
      topic: session.topic,
      note: session.note,
      classId: session.classId,
      className: session.classroom.name,
      courseTitle: session.course?.title ?? null,
      createdByName: session.createdBy.fullName,
      present,
      late,
      absent,
      excused,
      total,
      rate: total === 0 ? 0 : Math.round(((present + late) / total) * 100),
    };
  });
}

export interface AttendanceRecordRow {
  studentId: string;
  fullName: string;
  username: string;
  avatarUrl: string | null;
  gradeLevel: string | null;
  status: AttendanceStatus | null;
  note: string | null;
}

export interface AttendanceSessionDetail {
  id: string;
  date: Date;
  topic: string | null;
  note: string | null;
  classId: string;
  className: string;
  courseId: string | null;
  courseTitle: string | null;
  canManage: boolean;
  records: AttendanceRecordRow[];
}

export async function getAttendanceSession(
  scope: ClassScope,
  sessionId: string
): Promise<AttendanceSessionDetail | null> {
  const session = await prisma.attendanceSession.findFirst({
    where: { AND: [{ id: sessionId }, { classroom: classAccessFilter(scope) }] },
    select: {
      id: true,
      date: true,
      topic: true,
      note: true,
      classId: true,
      courseId: true,
      classroom: { select: { name: true, teacherId: true } },
      course: { select: { title: true } },
      records: {
        select: {
          studentId: true,
          status: true,
          note: true,
          student: {
            select: {
              fullName: true,
              username: true,
              avatarUrl: true,
              gradeLevel: true,
            },
          },
        },
      },
    },
  });

  if (!session) return null;

  const enrolled = await prisma.classEnrollment.findMany({
    where: { classId: session.classId, status: "ACTIVE" },
    orderBy: { enrolledAt: "asc" },
    select: {
      student: {
        select: {
          id: true,
          fullName: true,
          username: true,
          avatarUrl: true,
          gradeLevel: true,
        },
      },
    },
  });

  const byStudent = new Map(session.records.map((record) => [record.studentId, record]));

  const records: AttendanceRecordRow[] = enrolled.map((enrollment) => {
    const record = byStudent.get(enrollment.student.id);
    return {
      studentId: enrollment.student.id,
      fullName: enrollment.student.fullName,
      username: enrollment.student.username,
      avatarUrl: enrollment.student.avatarUrl,
      gradeLevel: enrollment.student.gradeLevel,
      status: record?.status ?? null,
      note: record?.note ?? null,
    };
  });

  return {
    id: session.id,
    date: session.date,
    topic: session.topic,
    note: session.note,
    classId: session.classId,
    className: session.classroom.name,
    courseId: session.courseId,
    courseTitle: session.course?.title ?? null,
    canManage: scope.role === "ADMIN" || session.classroom.teacherId === scope.userId,
    records,
  };
}

export interface StudentAttendanceSummary {
  present: number;
  late: number;
  absent: number;
  excused: number;
  total: number;
  rate: number;
  byClass: { classId: string; className: string; rate: number; total: number }[];
  recent: { id: string; date: Date; status: AttendanceStatus; topic: string | null; className: string }[];
}

/** A student's own attendance record. */
export async function getStudentAttendance(studentId: string): Promise<StudentAttendanceSummary> {
  const records = await prisma.attendanceRecord.findMany({
    where: { studentId },
    orderBy: { session: { date: "desc" } },
    select: {
      id: true,
      status: true,
      session: {
        select: { date: true, topic: true, classId: true, classroom: { select: { name: true } } },
      },
    },
  });

  const count = (status: AttendanceStatus) =>
    records.filter((record) => record.status === status).length;

  const byClassMap = new Map<string, { className: string; present: number; total: number }>();
  for (const record of records) {
    const key = record.session.classId;
    const entry = byClassMap.get(key) ?? {
      className: record.session.classroom.name,
      present: 0,
      total: 0,
    };
    entry.total += 1;
    if (record.status === "PRESENT" || record.status === "LATE") entry.present += 1;
    byClassMap.set(key, entry);
  }

  const present = count("PRESENT");
  const late = count("LATE");

  return {
    present,
    late,
    absent: count("ABSENT"),
    excused: count("EXCUSED"),
    total: records.length,
    rate: records.length === 0 ? 0 : Math.round(((present + late) / records.length) * 100),
    byClass: [...byClassMap.entries()].map(([classId, entry]) => ({
      classId,
      className: entry.className,
      total: entry.total,
      rate: entry.total === 0 ? 0 : Math.round((entry.present / entry.total) * 100),
    })),
    recent: records.slice(0, 20).map((record) => ({
      id: record.id,
      date: record.session.date,
      status: record.status,
      topic: record.session.topic,
      className: record.session.classroom.name,
    })),
  };
}

export interface AttendanceOverview {
  sessionsThisMonth: number;
  averageRate: number | null;
  atRiskStudents: {
    studentId: string;
    fullName: string;
    username: string;
    classId: string;
    className: string;
    rate: number;
    absent: number;
  }[];
  todaySessions: { classId: string; className: string; sessionId: string | null; topic: string | null }[];
}

/** Staff dashboard: who needs attention, and what still needs marking. */
export async function getAttendanceOverview(scope: ClassScope): Promise<AttendanceOverview> {
  const startOfMonth = new Date();
  startOfMonth.setDate(1);
  startOfMonth.setHours(0, 0, 0, 0);

  const startOfToday = new Date();
  startOfToday.setHours(0, 0, 0, 0);
  const endOfToday = new Date();
  endOfToday.setHours(23, 59, 59, 999);

  const [sessions, classes] = await Promise.all([
    prisma.attendanceSession.findMany({
      where: { classroom: classAccessFilter(scope) },
      select: {
        id: true,
        date: true,
        topic: true,
        classId: true,
        classroom: { select: { name: true } },
        records: {
          select: {
            status: true,
            studentId: true,
            student: { select: { fullName: true, username: true } },
          },
        },
      },
      orderBy: { date: "desc" },
    }),
    prisma.classroom.findMany({
      where: { AND: [classAccessFilter(scope), { archivedAt: null }] },
      orderBy: { name: "asc" },
      select: { id: true, name: true },
    }),
  ]);

  const thisMonth = sessions.filter((session) => session.date >= startOfMonth);
  const allRecords = sessions.flatMap((session) => session.records);
  const presentRecords = allRecords.filter(
    (record) => record.status === "PRESENT" || record.status === "LATE"
  ).length;

  // Per-student-per-class attendance, to surface at-risk learners.
  const buckets = new Map<
    string,
    {
      studentId: string;
      fullName: string;
      username: string;
      classId: string;
      className: string;
      present: number;
      total: number;
      absent: number;
    }
  >();

  for (const session of sessions) {
    for (const record of session.records) {
      const key = `${session.classId}:${record.studentId}`;
      const entry =
        buckets.get(key) ??
        {
          studentId: record.studentId,
          fullName: record.student.fullName,
          username: record.student.username,
          classId: session.classId,
          className: session.classroom.name,
          present: 0,
          total: 0,
          absent: 0,
        };
      entry.total += 1;
      if (record.status === "PRESENT" || record.status === "LATE") entry.present += 1;
      if (record.status === "ABSENT") entry.absent += 1;
      buckets.set(key, entry);
    }
  }

  const atRiskStudents = [...buckets.values()]
    .filter((entry) => entry.total >= 3 && entry.present / entry.total < 0.75)
    .map((entry) => ({
      studentId: entry.studentId,
      fullName: entry.fullName,
      username: entry.username,
      classId: entry.classId,
      className: entry.className,
      rate: Math.round((entry.present / entry.total) * 100),
      absent: entry.absent,
    }))
    .sort((a, b) => a.rate - b.rate)
    .slice(0, 10);

  const todaySessions = classes.map((classroom) => {
    const session = sessions.find(
      (row) =>
        row.classId === classroom.id &&
        row.date >= startOfToday &&
        row.date <= endOfToday
    );
    return {
      classId: classroom.id,
      className: classroom.name,
      sessionId: session?.id ?? null,
      topic: session?.topic ?? null,
    };
  });

  return {
    sessionsThisMonth: thisMonth.length,
    averageRate:
      allRecords.length === 0 ? null : Math.round((presentRecords / allRecords.length) * 100),
    atRiskStudents,
    todaySessions,
  };
}
