import "server-only";
import { prisma } from "@/lib/db";
import { describeLevel, type LevelProgress } from "@/lib/gamification";
import type { Role } from "@prisma/client";

/**
 * Dashboard aggregates.
 *
 * Each role sees a different dashboard, so the queries are grouped here rather
 * than scattered across page components. All figures are computed from live
 * relational data — nothing is hardcoded.
 */

export interface StudentDashboard {
  kind: "student";
  enrolledCourses: {
    id: string;
    title: string;
    slug: string;
    coverColor: string;
    level: string;
    progress: number;
    lessonCount: number;
    completedLessons: number;
    teacherName: string;
  }[];
  upcomingAssignments: {
    id: string;
    title: string;
    courseTitle: string;
    type: string;
    dueAt: Date | null;
    submitted: boolean;
    score: number | null;
    maxScore: number;
  }[];
  attendance: {
    present: number;
    late: number;
    absent: number;
    excused: number;
    total: number;
    rate: number;
  };
  progress: LevelProgress;
  stats: {
    coursesEnrolled: number;
    lessonsCompleted: number;
    assignmentsSubmitted: number;
    assignmentsPending: number;
    averageScore: number | null;
    codingPassed: number;
    simulatorCleared: number;
    skillsUnlocked: number;
    achievementsUnlocked: number;
  };
  recentActivity: {
    id: string;
    label: string;
    detail: string;
    at: Date;
    kind: "lesson" | "submission" | "coding" | "simulator" | "achievement";
  }[];
  skillHighlights: {
    name: string;
    icon: string;
    color: string;
    level: number;
    maxLevel: number;
    xp: number;
  }[];
}

export interface TeacherDashboard {
  kind: "teacher";
  classes: {
    id: string;
    name: string;
    code: string;
    joinCode: string;
    studentCount: number;
    room: string | null;
  }[];
  courses: {
    id: string;
    title: string;
    slug: string;
    coverColor: string;
    status: string;
    lessonCount: number;
    studentCount: number;
    averageProgress: number;
  }[];
  gradingQueue: {
    id: string;
    studentName: string;
    assignmentTitle: string;
    courseTitle: string;
    submittedAt: Date | null;
    isLate: boolean;
  }[];
  stats: {
    totalStudents: number;
    totalCourses: number;
    totalLessons: number;
    pendingGrading: number;
    publishedAssignments: number;
    averageScore: number | null;
    attendanceToday: number;
  };
  recentSubmissions: {
    id: string;
    studentName: string;
    assignmentTitle: string;
    submittedAt: Date | null;
    status: string;
  }[];
  coursePerformance: {
    courseTitle: string;
    coverColor: string;
    averageScore: number;
    submissionRate: number;
  }[];
}

export type DashboardData = StudentDashboard | TeacherDashboard;

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

// ---------------------------------------------------------------------------
// Student
// ---------------------------------------------------------------------------

async function buildStudentDashboard(userId: string, xp: number): Promise<StudentDashboard> {
  const [
    enrollments,
    submissions,
    attendanceGroups,
    lessonProgressRows,
    codingPassed,
    simulatorCleared,
    skills,
    achievementsUnlocked,
    completedLessonCount,
    xpEvents,
  ] = await Promise.all([
    prisma.courseEnrollment.findMany({
      where: { studentId: userId },
      orderBy: { enrolledAt: "desc" },
      select: {
        progress: true,
        course: {
          select: {
            id: true,
            title: true,
            slug: true,
            coverColor: true,
            level: true,
            teacher: { select: { fullName: true } },
            _count: { select: { lessons: true } },
          },
        },
      },
    }),
    prisma.submission.findMany({
      where: { studentId: userId },
      select: {
        id: true,
        score: true,
        status: true,
        submittedAt: true,
        assignment: {
          select: {
            id: true,
            title: true,
            type: true,
            dueAt: true,
            maxScore: true,
            course: { select: { title: true } },
          },
        },
      },
    }),
    prisma.attendanceRecord.groupBy({
      by: ["status"],
      where: { studentId: userId },
      _count: { _all: true },
    }),
    prisma.lessonProgress.findMany({
      where: { studentId: userId },
      select: { lessonId: true, status: true, lesson: { select: { courseId: true } } },
    }),
    prisma.codingSubmission.count({ where: { studentId: userId, status: "PASSED" } }),
    prisma.simulatorAttempt.count({ where: { userId, success: true } }),
    prisma.userSkill.findMany({
      where: { userId },
      orderBy: { xp: "desc" },
      take: 6,
      select: {
        level: true,
        xp: true,
        skill: { select: { name: true, icon: true, color: true, maxLevel: true } },
      },
    }),
    prisma.userAchievement.count({ where: { userId } }),
    prisma.lessonProgress.count({ where: { studentId: userId, status: "COMPLETED" } }),
    prisma.xpEvent.findMany({
      where: { userId },
      orderBy: { createdAt: "desc" },
      take: 8,
      select: { id: true, reason: true, amount: true, source: true, createdAt: true },
    }),
  ]);

  // --- attendance ---------------------------------------------------------
  const attendanceCounts = { present: 0, late: 0, absent: 0, excused: 0 };
  for (const group of attendanceGroups) {
    const key = group.status.toLowerCase() as keyof typeof attendanceCounts;
    attendanceCounts[key] = group._count._all;
  }
  const attendanceTotal =
    attendanceCounts.present + attendanceCounts.late + attendanceCounts.absent + attendanceCounts.excused;
  const attendanceRate =
    attendanceTotal === 0
      ? 0
      : round(((attendanceCounts.present + attendanceCounts.late) / attendanceTotal) * 100);

  // --- courses ------------------------------------------------------------
  const completedByCourse = new Map<string, number>();
  for (const row of lessonProgressRows) {
    if (row.status !== "COMPLETED") continue;
    const key = row.lesson.courseId;
    completedByCourse.set(key, (completedByCourse.get(key) ?? 0) + 1);
  }

  const enrolledCourses = enrollments.map((enrollment) => ({
    id: enrollment.course.id,
    title: enrollment.course.title,
    slug: enrollment.course.slug,
    coverColor: enrollment.course.coverColor,
    level: enrollment.course.level,
    progress: enrollment.progress,
    lessonCount: enrollment.course._count.lessons,
    completedLessons: completedByCourse.get(enrollment.course.id) ?? 0,
    teacherName: enrollment.course.teacher.fullName,
  }));

  // --- assignments --------------------------------------------------------
  const submissionByAssignment = new Map(
    submissions.map((submission) => [submission.assignment.id, submission])
  );

  const gradedScores = submissions
    .filter((submission) => submission.score !== null)
    .map((submission) => ({
      percent: (submission.score! / Math.max(1, submission.assignment.maxScore)) * 100,
    }));
  const averageScore =
    gradedScores.length === 0
      ? null
      : round(gradedScores.reduce((sum, item) => sum + item.percent, 0) / gradedScores.length);

  const now = new Date();
  const upcomingAssignments = submissions
    .map((submission) => submission.assignment)
    .filter((assignment, index, all) => all.findIndex((a) => a.id === assignment.id) === index)
    .filter((assignment) => {
      const submission = submissionByAssignment.get(assignment.id);
      if (submission && submission.status !== "DRAFT") return false;
      if (!assignment.dueAt) return false;
      return assignment.dueAt.getTime() > now.getTime() - 7 * 24 * 60 * 60 * 1000;
    })
    .sort((a, b) => (a.dueAt!.getTime() - b.dueAt!.getTime()))
    .slice(0, 6)
    .map((assignment) => {
      const submission = submissionByAssignment.get(assignment.id);
      return {
        id: assignment.id,
        title: assignment.title,
        courseTitle: assignment.course.title,
        type: assignment.type,
        dueAt: assignment.dueAt,
        submitted: Boolean(submission && submission.status !== "DRAFT"),
        score: submission?.score ?? null,
        maxScore: assignment.maxScore,
      };
    });

  // --- recent activity ----------------------------------------------------
  const recentActivity: StudentDashboard["recentActivity"] = [];

  const [recentLessons, recentSubmissions, recentCoding, recentSim, recentAchievements] =
    await Promise.all([
      prisma.lessonProgress.findMany({
        where: { studentId: userId, status: "COMPLETED" },
        orderBy: { completedAt: "desc" },
        take: 4,
        select: { id: true, completedAt: true, lesson: { select: { title: true } } },
      }),
      prisma.submission.findMany({
        where: { studentId: userId, submittedAt: { not: null } },
        orderBy: { submittedAt: "desc" },
        take: 4,
        select: {
          id: true,
          submittedAt: true,
          assignment: { select: { title: true } },
        },
      }),
      prisma.codingSubmission.findMany({
        where: { studentId: userId },
        orderBy: { createdAt: "desc" },
        take: 3,
        select: { id: true, createdAt: true, status: true, project: { select: { title: true } } },
      }),
      prisma.simulatorAttempt.findMany({
        where: { userId },
        orderBy: { createdAt: "desc" },
        take: 3,
        select: { id: true, createdAt: true, success: true, challenge: { select: { title: true } } },
      }),
      prisma.userAchievement.findMany({
        where: { userId },
        orderBy: { unlockedAt: "desc" },
        take: 3,
        select: { id: true, unlockedAt: true, achievement: { select: { name: true } } },
      }),
    ]);

  for (const row of recentLessons) {
    if (!row.completedAt) continue;
    recentActivity.push({
      id: `lesson-${row.id}`,
      label: "Menyelesaikan pelajaran",
      detail: row.lesson.title,
      at: row.completedAt,
      kind: "lesson",
    });
  }
  for (const row of recentSubmissions) {
    if (!row.submittedAt) continue;
    recentActivity.push({
      id: `submission-${row.id}`,
      label: "Mengumpulkan tugas",
      detail: row.assignment.title,
      at: row.submittedAt,
      kind: "submission",
    });
  }
  for (const row of recentCoding) {
    recentActivity.push({
      id: `coding-${row.id}`,
      label: row.status === "PASSED" ? "Lulus tantangan coding" : "Mencoba tantangan coding",
      detail: row.project.title,
      at: row.createdAt,
      kind: "coding",
    });
  }
  for (const row of recentSim) {
    recentActivity.push({
      id: `sim-${row.id}`,
      label: row.success ? "Menuntaskan simulator" : "Mencoba simulator",
      detail: row.challenge.title,
      at: row.createdAt,
      kind: "simulator",
    });
  }
  for (const row of recentAchievements) {
    recentActivity.push({
      id: `ach-${row.id}`,
      label: "Membuka pencapaian",
      detail: row.achievement.name,
      at: row.unlockedAt,
      kind: "achievement",
    });
  }
  for (const event of xpEvents) {
    recentActivity.push({
      id: `xp-${event.id}`,
      label: `+${event.amount} XP`,
      detail: event.reason,
      at: event.createdAt,
      kind: "achievement",
    });
  }

  recentActivity.sort((a, b) => b.at.getTime() - a.at.getTime());

  const submittedCount = submissions.filter((s) => s.status !== "DRAFT").length;

  return {
    kind: "student",
    enrolledCourses,
    upcomingAssignments,
    attendance: { ...attendanceCounts, total: attendanceTotal, rate: attendanceRate },
    progress: describeLevel(xp),
    stats: {
      coursesEnrolled: enrolledCourses.length,
      lessonsCompleted: completedLessonCount,
      assignmentsSubmitted: submittedCount,
      assignmentsPending: upcomingAssignments.filter((item) => !item.submitted).length,
      averageScore,
      codingPassed,
      simulatorCleared,
      skillsUnlocked: skills.length,
      achievementsUnlocked,
    },
    recentActivity: recentActivity.slice(0, 8),
    skillHighlights: skills.map((row) => ({
      name: row.skill.name,
      icon: row.skill.icon,
      color: row.skill.color,
      level: row.level,
      maxLevel: row.skill.maxLevel,
      xp: row.xp,
    })),
  };
}

// ---------------------------------------------------------------------------
// Teacher / admin
// ---------------------------------------------------------------------------

async function buildTeacherDashboard(userId: string, isAdmin: boolean): Promise<TeacherDashboard> {
  const classFilter = isAdmin ? {} : { teacherId: userId };
  const courseFilter = isAdmin ? {} : { teacherId: userId };

  const [classes, courses, pendingSubmissions, recentSubmissions, todayAttendance] =
    await Promise.all([
      prisma.classroom.findMany({
        where: { ...classFilter, archivedAt: null },
        orderBy: { createdAt: "desc" },
        select: {
          id: true,
          name: true,
          code: true,
          joinCode: true,
          room: true,
          _count: { select: { enrollments: true } },
        },
      }),
      prisma.course.findMany({
        where: courseFilter,
        orderBy: { createdAt: "desc" },
        select: {
          id: true,
          title: true,
          slug: true,
          coverColor: true,
          status: true,
          _count: { select: { lessons: true, enrollments: true } },
        },
      }),
      prisma.submission.findMany({
        where: {
          status: { in: ["SUBMITTED", "LATE"] },
          assignment: { course: courseFilter },
        },
        orderBy: { submittedAt: "asc" },
        take: 10,
        select: {
          id: true,
          submittedAt: true,
          isLate: true,
          student: { select: { fullName: true } },
          assignment: {
            select: { title: true, course: { select: { title: true } } },
          },
        },
      }),
      prisma.submission.findMany({
        where: { assignment: { course: courseFilter } },
        orderBy: { submittedAt: "desc" },
        take: 6,
        select: {
          id: true,
          submittedAt: true,
          status: true,
          student: { select: { fullName: true } },
          assignment: { select: { title: true } },
        },
      }),
      prisma.attendanceSession.count({
        where: {
          date: { gte: new Date(new Date().setHours(0, 0, 0, 0)) },
          classroom: classFilter,
        },
      }),
    ]);

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

  const [totalLessons, publishedAssignments, scoreAggregate, submissionStats, progressStats] =
    await Promise.all([
      prisma.lesson.count({ where: { courseId: { in: courseIds } } }),
      prisma.assignment.count({ where: { courseId: { in: courseIds }, status: "PUBLISHED" } }),
      prisma.submission.findMany({
        where: {
          score: { not: null },
          assignment: { courseId: { in: courseIds } },
        },
        select: { score: true, assignment: { select: { maxScore: true } } },
      }),
      prisma.submission.groupBy({
        by: ["assignmentId"],
        where: { assignment: { courseId: { in: courseIds } } },
        _count: { _all: true },
      }),
      prisma.courseEnrollment.findMany({
        where: { courseId: { in: courseIds } },
        select: { courseId: true, progress: true },
      }),
    ]);

  const studentIds = new Set<string>();
  const enrollmentCounts = await prisma.courseEnrollment.findMany({
    where: { courseId: { in: courseIds } },
    select: { studentId: true, courseId: true },
  });
  for (const row of enrollmentCounts) studentIds.add(row.studentId);

  const averageScore =
    scoreAggregate.length === 0
      ? null
      : round(
          scoreAggregate.reduce(
            (sum, row) => sum + (row.score! / Math.max(1, row.assignment.maxScore)) * 100,
            0
          ) / scoreAggregate.length
        );

  const submissionCountByAssignment = new Map(
    submissionStats.map((row) => [row.assignmentId, row._count._all])
  );

  const coursePerformance = await Promise.all(
    courses.slice(0, 6).map(async (course) => {
      const [scores, assignmentIds] = await Promise.all([
        prisma.submission.findMany({
          where: { score: { not: null }, assignment: { courseId: course.id } },
          select: { score: true, assignment: { select: { maxScore: true } } },
        }),
        prisma.assignment.findMany({
          where: { courseId: course.id, status: "PUBLISHED" },
          select: { id: true },
        }),
        prisma.courseEnrollment.findMany({
          where: { courseId: course.id },
          select: { progress: true },
        }),
      ]);

      const avgScore =
        scores.length === 0
          ? 0
          : round(
              scores.reduce(
                (sum, row) => sum + (row.score! / Math.max(1, row.assignment.maxScore)) * 100,
                0
              ) / scores.length
            );

      const possibleSubmissions = assignmentIds.length * Math.max(1, course._count.enrollments);
      const actualSubmissions = assignmentIds.reduce(
        (sum, assignment) => sum + (submissionCountByAssignment.get(assignment.id) ?? 0),
        0
      );

      return {
        courseTitle: course.title,
        coverColor: course.coverColor,
        averageScore: avgScore,
        submissionRate:
          possibleSubmissions === 0
            ? 0
            : round((actualSubmissions / possibleSubmissions) * 100),
      };
    })
  );

  const progressByCourse = new Map<string, number[]>();
  for (const row of progressStats) {
    const list = progressByCourse.get(row.courseId) ?? [];
    list.push(row.progress);
    progressByCourse.set(row.courseId, list);
  }

  return {
    kind: "teacher",
    classes: classes.map((classroom) => ({
      id: classroom.id,
      name: classroom.name,
      code: classroom.code,
      joinCode: classroom.joinCode,
      studentCount: classroom._count.enrollments,
      room: classroom.room,
    })),
    courses: courses.map((course) => {
      const progresses = progressByCourse.get(course.id) ?? [];
      return {
        id: course.id,
        title: course.title,
        slug: course.slug,
        coverColor: course.coverColor,
        status: course.status,
        lessonCount: course._count.lessons,
        studentCount: course._count.enrollments,
        averageProgress:
          progresses.length === 0
            ? 0
            : Math.round(progresses.reduce((sum, value) => sum + value, 0) / progresses.length),
      };
    }),
    gradingQueue: pendingSubmissions.map((submission) => ({
      id: submission.id,
      studentName: submission.student.fullName,
      assignmentTitle: submission.assignment.title,
      courseTitle: submission.assignment.course.title,
      submittedAt: submission.submittedAt,
      isLate: submission.isLate,
    })),
    stats: {
      totalStudents: studentIds.size,
      totalCourses: courses.length,
      totalLessons,
      pendingGrading: pendingSubmissions.length,
      publishedAssignments,
      averageScore,
      attendanceToday: todayAttendance,
    },
    recentSubmissions: recentSubmissions.map((submission) => ({
      id: submission.id,
      studentName: submission.student.fullName,
      assignmentTitle: submission.assignment.title,
      submittedAt: submission.submittedAt,
      status: submission.status,
    })),
    coursePerformance,
  };
}

export async function getDashboardData(
  userId: string,
  role: Role,
  xp: number
): Promise<DashboardData> {
  if (role === "STUDENT") {
    return buildStudentDashboard(userId, xp);
  }
  return buildTeacherDashboard(userId, role === "ADMIN");
}
