import "server-only";
import { prisma } from "@/lib/db";
import { describeLevel, type LevelProgress } from "@/lib/level";
import { COURSE_ORDER } from "@/lib/queries/courses";
import type { LessonProgressStatus, Prisma, Role, XpSource } from "@prisma/client";

/**
 * Read-only learner queries: progress, skills and achievements.
 *
 * Every figure is derived from live relational data — nothing is hardcoded.
 *
 * Scope rules mirror the course vertical:
 *   • STUDENT — their own enrolments, activity and gamification rows.
 *   • TEACHER — learners enrolled in the courses they author (class-wide
 *               aggregates); the personal skills/achievement grids always read
 *               the signed-in user's own rows.
 *   • ADMIN   — every course and every student.
 */

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

/** Clamp any percentage to a whole number inside 0–100. */
function clampPercent(value: number): number {
  if (!Number.isFinite(value)) return 0;
  return Math.max(0, Math.min(100, Math.round(value)));
}

interface ResolvedScope {
  isStudent: boolean;
  userId: string;
  /** Learners whose rows feed the aggregates. */
  studentIds: string[];
  /** Courses whose rows feed the aggregates. */
  courseIds: string[];
  attendanceWhere: Prisma.AttendanceRecordWhereInput;
}

async function resolveScope(scope: ProgressScope): Promise<ResolvedScope> {
  if (scope.role === "STUDENT") {
    const enrollments = await prisma.courseEnrollment.findMany({
      where: { studentId: scope.userId },
      select: { courseId: true },
    });
    return {
      isStudent: true,
      userId: scope.userId,
      studentIds: [scope.userId],
      courseIds: enrollments.map((enrollment) => enrollment.courseId),
      attendanceWhere: { studentId: scope.userId },
    };
  }

  if (scope.role === "ADMIN") {
    const [courses, students] = await Promise.all([
      prisma.course.findMany({ select: { id: true } }),
      prisma.user.findMany({ where: { role: "STUDENT" }, select: { id: true } }),
    ]);
    return {
      isStudent: false,
      userId: scope.userId,
      studentIds: students.map((student) => student.id),
      courseIds: courses.map((course) => course.id),
      attendanceWhere: {},
    };
  }

  const courses = await prisma.course.findMany({
    where: { teacherId: scope.userId },
    select: { id: true },
  });
  const courseIds = courses.map((course) => course.id);
  const enrollments = await prisma.courseEnrollment.findMany({
    where: { courseId: { in: courseIds } },
    select: { studentId: true },
  });

  return {
    isStudent: false,
    userId: scope.userId,
    studentIds: [...new Set(enrollments.map((enrollment) => enrollment.studentId))],
    courseIds,
    attendanceWhere: { session: { classroom: { teacherId: scope.userId } } },
  };
}

// ---------------------------------------------------------------------------
// Learning overview
// ---------------------------------------------------------------------------

export interface LearningOverview {
  /** The signed-in user's XP total. */
  xp: number;
  /** Level curve position for the signed-in user's XP. */
  level: LevelProgress;
  lessonsCompleted: number;
  lessonsTotal: number;
  assignmentsSubmitted: number;
  assignmentsGraded: number;
  /** Weighted by each assignment's `maxScore`, expressed as a percentage. */
  averageScore: number | null;
  attendance: {
    present: number;
    late: number;
    absent: number;
    excused: number;
    total: number;
    rate: number;
  };
  codingProjectsPassed: number;
  simulatorChallengesCleared: number;
  skillsUnlocked: number;
  achievementsUnlocked: number;
}

export async function getLearningOverview(scope: ProgressScope): Promise<LearningOverview> {
  const resolved = await resolveScope(scope);
  const { studentIds, courseIds } = resolved;

  const [
    user,
    courseCounts,
    lessonsCompleted,
    assignmentsSubmitted,
    assignmentsGraded,
    gradedScores,
    attendanceGroups,
    passedProjects,
    clearedChallenges,
    skillsUnlocked,
    achievementsUnlocked,
  ] = await Promise.all([
    prisma.user.findUniqueOrThrow({
      where: { id: resolved.userId },
      select: { xp: true },
    }),
    prisma.course.findMany({
      where: { id: { in: courseIds } },
      select: { _count: { select: { lessons: true, enrollments: true } } },
    }),
    prisma.lessonProgress.count({
      where: {
        studentId: { in: studentIds },
        status: "COMPLETED",
        lesson: { courseId: { in: courseIds } },
      },
    }),
    prisma.submission.count({
      where: {
        studentId: { in: studentIds },
        status: { in: ["SUBMITTED", "LATE", "GRADED", "RETURNED"] },
        assignment: { courseId: { in: courseIds } },
      },
    }),
    prisma.submission.count({
      where: {
        studentId: { in: studentIds },
        status: { in: ["GRADED", "RETURNED"] },
        assignment: { courseId: { in: courseIds } },
      },
    }),
    prisma.submission.findMany({
      where: {
        studentId: { in: studentIds },
        score: { not: null },
        assignment: { courseId: { in: courseIds } },
      },
      select: { score: true, assignment: { select: { maxScore: true } } },
    }),
    prisma.attendanceRecord.groupBy({
      by: ["status"],
      where: resolved.attendanceWhere,
      _count: { _all: true },
    }),
    prisma.codingSubmission.findMany({
      where: { studentId: { in: studentIds }, status: "PASSED" },
      distinct: ["projectId"],
      select: { projectId: true },
    }),
    prisma.simulatorAttempt.findMany({
      where: { userId: { in: studentIds }, success: true },
      distinct: ["challengeId"],
      select: { challengeId: true },
    }),
    prisma.userSkill.count({ where: { userId: { in: studentIds } } }),
    prisma.userAchievement.count({ where: { userId: { in: studentIds } } }),
  ]);

  // Students compare their completions against the curriculum; staff compare
  // every completion in their classes against every possible completion.
  const lessonsTotal = resolved.isStudent
    ? courseCounts.reduce((sum, course) => sum + course._count.lessons, 0)
    : courseCounts.reduce(
        (sum, course) => sum + course._count.lessons * course._count.enrollments,
        0
      );

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

  // --- weighted average score --------------------------------------------
  let scoreSum = 0;
  let maxScoreSum = 0;
  for (const row of gradedScores) {
    if (row.score === null || row.assignment.maxScore <= 0) continue;
    scoreSum += row.score;
    maxScoreSum += row.assignment.maxScore;
  }
  const averageScore = maxScoreSum === 0 ? null : clampPercent((scoreSum / maxScoreSum) * 100);

  return {
    xp: user.xp,
    level: describeLevel(user.xp),
    lessonsCompleted,
    lessonsTotal,
    assignmentsSubmitted,
    assignmentsGraded,
    averageScore,
    attendance: { ...attendance, total: attendanceTotal, rate: attendanceRate },
    codingProjectsPassed: passedProjects.length,
    simulatorChallengesCleared: clearedChallenges.length,
    skillsUnlocked,
    achievementsUnlocked,
  };
}

// ---------------------------------------------------------------------------
// Per-course progress
// ---------------------------------------------------------------------------

export interface CourseProgressItem {
  id: string;
  title: string;
  coverColor: string;
  teacherName: string;
  lessonCount: number;
  completedLessons: number;
  /** Completion percentage, 0–100. */
  progress: number;
  averageScore: number | null;
  lastActivityAt: Date | null;
  studentCount: number;
}

/** Fold the newest timestamp for a course into a running map. */
function bumpActivity(map: Map<string, number>, courseId: string, at: Date | null): void {
  if (!at) return;
  const value = at.getTime();
  const current = map.get(courseId) ?? 0;
  if (value > current) map.set(courseId, value);
}

export async function getCourseProgress(scope: ProgressScope): Promise<CourseProgressItem[]> {
  const resolved = await resolveScope(scope);
  const { courseIds } = resolved;

  const courses = await prisma.course.findMany({
    where: { id: { in: courseIds } },
    orderBy: COURSE_ORDER,
    select: {
      id: true,
      title: true,
      coverColor: true,
      teacher: { select: { fullName: true } },
      _count: { select: { lessons: true, enrollments: true } },
    },
  });

  const courseIdSet = new Set(courses.map((course) => course.id));

  const [lessonRows, submissions, enrollments] = await Promise.all([
    prisma.lessonProgress.findMany({
      where: {
        ...(resolved.isStudent ? { studentId: resolved.userId } : {}),
        lesson: { courseId: { in: courseIds } },
      },
      select: {
        status: true,
        updatedAt: true,
        completedAt: true,
        lesson: { select: { courseId: true } },
      },
    }),
    prisma.submission.findMany({
      where: {
        ...(resolved.isStudent ? { studentId: resolved.userId } : {}),
        assignment: { courseId: { in: courseIds } },
      },
      select: {
        score: true,
        submittedAt: true,
        assignment: { select: { maxScore: true, courseId: true } },
      },
    }),
    prisma.courseEnrollment.findMany({
      where: { courseId: { in: courseIds } },
      select: { courseId: true, progress: true },
    }),
  ]);

  const completedByCourse = new Map<string, number>();
  const activityByCourse = new Map<string, number>();

  for (const row of lessonRows) {
    const courseId = row.lesson.courseId;
    if (!courseIdSet.has(courseId)) continue;
    if (row.status === "COMPLETED") {
      completedByCourse.set(courseId, (completedByCourse.get(courseId) ?? 0) + 1);
    }
    bumpActivity(activityByCourse, courseId, row.updatedAt);
    bumpActivity(activityByCourse, courseId, row.completedAt);
  }

  const scoreTotals = new Map<string, { score: number; max: number }>();
  for (const row of submissions) {
    const courseId = row.assignment.courseId;
    if (!courseIdSet.has(courseId)) continue;
    bumpActivity(activityByCourse, courseId, row.submittedAt);
    if (row.score === null || row.assignment.maxScore <= 0) continue;
    const totals = scoreTotals.get(courseId) ?? { score: 0, max: 0 };
    totals.score += row.score;
    totals.max += row.assignment.maxScore;
    scoreTotals.set(courseId, totals);
  }

  const enrollmentProgress = new Map<string, { sum: number; count: number }>();
  for (const row of enrollments) {
    if (!courseIdSet.has(row.courseId)) continue;
    const entry = enrollmentProgress.get(row.courseId) ?? { sum: 0, count: 0 };
    entry.sum += row.progress;
    entry.count += 1;
    enrollmentProgress.set(row.courseId, entry);
  }

  return courses.map((course) => {
    const lessonCount = course._count.lessons;
    const rawCompleted = completedByCourse.get(course.id) ?? 0;
    const studentCount = course._count.enrollments;

    // Teachers see class averages; students see their own totals.
    const completedLessons = resolved.isStudent
      ? rawCompleted
      : studentCount === 0
        ? 0
        : Math.round(rawCompleted / studentCount);

    const totals = enrollmentProgress.get(course.id);
    const classAverage = totals && totals.count > 0 ? totals.sum / totals.count : 0;
    const progress =
      lessonCount > 0
        ? clampPercent((completedLessons / lessonCount) * 100)
        : clampPercent(classAverage);

    const scoreTotal = scoreTotals.get(course.id);
    const averageScore =
      scoreTotal && scoreTotal.max > 0 ? clampPercent((scoreTotal.score / scoreTotal.max) * 100) : null;

    const lastActivity = activityByCourse.get(course.id);

    return {
      id: course.id,
      title: course.title,
      coverColor: course.coverColor,
      teacherName: course.teacher.fullName,
      lessonCount,
      completedLessons,
      progress,
      averageScore,
      lastActivityAt: lastActivity ? new Date(lastActivity) : null,
      studentCount,
    };
  });
}

// ---------------------------------------------------------------------------
// Recent lesson activity
// ---------------------------------------------------------------------------

export interface LessonActivityItem {
  id: string;
  lessonId: string;
  courseId: string;
  lessonTitle: string;
  courseTitle: string;
  studentName: string;
  status: LessonProgressStatus;
  completedAt: Date | null;
  updatedAt: Date;
}

export async function getLessonActivity(scope: ProgressScope): Promise<LessonActivityItem[]> {
  const resolved = await resolveScope(scope);

  const rows = await prisma.lessonProgress.findMany({
    where: {
      studentId: { in: resolved.studentIds },
      lesson: { courseId: { in: resolved.courseIds } },
    },
    orderBy: [{ updatedAt: "desc" }],
    take: 12,
    select: {
      id: true,
      status: true,
      completedAt: true,
      updatedAt: true,
      lesson: {
        select: {
          id: true,
          title: true,
          course: { select: { id: true, title: true } },
        },
      },
      student: { select: { fullName: true } },
    },
  });

  return rows.map((row) => ({
    id: row.id,
    lessonId: row.lesson.id,
    courseId: row.lesson.course.id,
    lessonTitle: row.lesson.title,
    courseTitle: row.lesson.course.title,
    studentName: row.student.fullName,
    status: row.status,
    completedAt: row.completedAt,
    updatedAt: row.updatedAt,
  }));
}

// ---------------------------------------------------------------------------
// XP history
// ---------------------------------------------------------------------------

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

export interface XpSourceBreakdown {
  source: XpSource;
  total: number;
  count: number;
  /** Share of the scope's total XP, 0–100. */
  percent: number;
}

export interface XpHistory {
  entries: XpHistoryEntry[];
  breakdown: XpSourceBreakdown[];
  totalXp: number;
}

export async function getXpHistory(scope: ProgressScope): Promise<XpHistory> {
  const resolved = await resolveScope(scope);
  const where = { userId: { in: resolved.studentIds } };

  const [entries, grouped, aggregate] = await Promise.all([
    prisma.xpEvent.findMany({
      where,
      orderBy: { createdAt: "desc" },
      take: 20,
      select: { id: true, amount: true, source: true, reason: true, createdAt: true },
    }),
    prisma.xpEvent.groupBy({
      by: ["source"],
      where,
      _sum: { amount: true },
      _count: { _all: true },
    }),
    prisma.xpEvent.aggregate({ where, _sum: { amount: true } }),
  ]);

  const totalXp = aggregate._sum.amount ?? 0;

  const breakdown: XpSourceBreakdown[] = grouped
    .map((group) => {
      const total = group._sum.amount ?? 0;
      return {
        source: group.source,
        total,
        count: group._count._all,
        percent: totalXp === 0 ? 0 : clampPercent((total / totalXp) * 100),
      };
    })
    .sort((a, b) => b.total - a.total);

  return { entries, breakdown, totalXp };
}

// ---------------------------------------------------------------------------
// Skills
// ---------------------------------------------------------------------------

export interface SkillWithProgress {
  id: string;
  name: string;
  slug: string;
  category: string;
  description: string | null;
  icon: string;
  color: string;
  maxLevel: number;
  unlocked: boolean;
  /** 0 when the skill is locked. */
  level: number;
  xp: number;
  unlockedAt: Date | null;
  /** XP earned inside the current level, 0–100. */
  progressPercent: number;
}

export async function listSkillsWithProgress(scope: ProgressScope): Promise<SkillWithProgress[]> {
  const skills = await prisma.skill.findMany({
    orderBy: [{ orderIndex: "asc" }, { name: "asc" }],
    select: {
      id: true,
      name: true,
      slug: true,
      category: true,
      description: true,
      icon: true,
      color: true,
      maxLevel: true,
      users: {
        where: { userId: scope.userId },
        select: { level: true, xp: true, unlockedAt: true },
        take: 1,
      },
    },
  });

  return skills.map((skill) => {
    const own = skill.users[0];
    const unlocked = Boolean(own);
    const level = own?.level ?? 0;
    const xp = own?.xp ?? 0;

    const progressPercent = !unlocked
      ? 0
      : level >= skill.maxLevel
        ? 100
        : clampPercent(xp % 100);

    return {
      id: skill.id,
      name: skill.name,
      slug: skill.slug,
      category: skill.category,
      description: skill.description,
      icon: skill.icon,
      color: skill.color,
      maxLevel: skill.maxLevel,
      unlocked,
      level,
      xp,
      unlockedAt: own?.unlockedAt ?? null,
      progressPercent,
    };
  });
}

export interface SkillCategoryRollup {
  category: string;
  unlocked: number;
  total: number;
}

export interface SkillSummary {
  unlocked: number;
  total: number;
  highestLevel: number;
  /** XP banked across every unlocked skill. */
  skillXp: number;
  categories: SkillCategoryRollup[];
}

export async function getSkillSummary(scope: ProgressScope): Promise<SkillSummary> {
  const [skills, owned] = await Promise.all([
    prisma.skill.findMany({ select: { id: true, category: true } }),
    prisma.userSkill.findMany({
      where: { userId: scope.userId },
      select: { skillId: true, level: true, xp: true },
    }),
  ]);

  const ownedIds = new Set(owned.map((row) => row.skillId));
  const categoryMap = new Map<string, SkillCategoryRollup>();

  for (const skill of skills) {
    const entry = categoryMap.get(skill.category) ?? {
      category: skill.category,
      unlocked: 0,
      total: 0,
    };
    entry.total += 1;
    if (ownedIds.has(skill.id)) entry.unlocked += 1;
    categoryMap.set(skill.category, entry);
  }

  return {
    unlocked: owned.length,
    total: skills.length,
    highestLevel: owned.reduce((max, row) => Math.max(max, row.level), 0),
    skillXp: owned.reduce((sum, row) => sum + row.xp, 0),
    categories: [...categoryMap.values()].sort((a, b) => a.category.localeCompare(b.category)),
  };
}

// ---------------------------------------------------------------------------
// Achievements
// ---------------------------------------------------------------------------

export interface AchievementProgress {
  current: number;
  target: number;
  percent: number;
}

export interface AchievementWithProgress {
  id: string;
  code: string;
  name: string;
  description: string;
  icon: string;
  xpReward: number;
  tier: string;
  unlockedAt: Date | null;
  /** Null when the achievement has no computable metric. */
  progress: AchievementProgress | null;
}

interface AchievementMetrics {
  lessonsCompleted: number;
  assignmentsSubmitted: number;
  codingPassed: number;
  simulatorCleared: number;
  skillsUnlocked: number;
  level: number;
  coursesCompleted: number;
  attendancePresent: number;
}

/**
 * How each achievement code maps onto a live metric. Mirrors the evaluation
 * rules in `lib/gamification.ts` so the displayed progress matches the unlock.
 */
const ACHIEVEMENT_TARGETS: Record<string, { metric: keyof AchievementMetrics; target: number }> = {
  "first-steps": { metric: "lessonsCompleted", target: 1 },
  "lesson-enthusiast": { metric: "lessonsCompleted", target: 10 },
  "lesson-master": { metric: "lessonsCompleted", target: 30 },
  "first-submission": { metric: "assignmentsSubmitted", target: 1 },
  "consistent-worker": { metric: "assignmentsSubmitted", target: 15 },
  "first-code": { metric: "codingPassed", target: 1 },
  "code-warrior": { metric: "codingPassed", target: 10 },
  "robot-whisperer": { metric: "simulatorCleared", target: 5 },
  "skill-collector": { metric: "skillsUnlocked", target: 5 },
  "level-5": { metric: "level", target: 5 },
  "level-10": { metric: "level", target: 10 },
  "course-complete": { metric: "coursesCompleted", target: 1 },
  "perfect-attendance": { metric: "attendancePresent", target: 20 },
};

const TIER_ORDER = ["bronze", "silver", "gold", "platinum"];

async function collectAchievementMetrics(userId: string): Promise<AchievementMetrics> {
  const [
    lessonsCompleted,
    assignmentsSubmitted,
    codingPassed,
    simulatorCleared,
    skillsUnlocked,
    user,
    coursesCompleted,
    attendancePresent,
  ] = await Promise.all([
    prisma.lessonProgress.count({ where: { studentId: userId, status: "COMPLETED" } }),
    prisma.submission.count({
      where: { studentId: userId, status: { in: ["SUBMITTED", "LATE", "GRADED", "RETURNED"] } },
    }),
    prisma.codingSubmission.findMany({
      where: { studentId: userId, status: "PASSED" },
      distinct: ["projectId"],
      select: { projectId: true },
    }),
    prisma.simulatorAttempt.findMany({
      where: { userId, success: true },
      distinct: ["challengeId"],
      select: { challengeId: true },
    }),
    prisma.userSkill.count({ where: { userId } }),
    prisma.user.findUniqueOrThrow({ where: { id: userId }, select: { level: true } }),
    prisma.courseEnrollment.count({ where: { studentId: userId, status: "COMPLETED" } }),
    prisma.attendanceRecord.count({
      where: { studentId: userId, status: { in: ["PRESENT", "LATE"] } },
    }),
  ]);

  return {
    lessonsCompleted,
    assignmentsSubmitted,
    codingPassed: codingPassed.length,
    simulatorCleared: simulatorCleared.length,
    skillsUnlocked,
    level: user.level,
    coursesCompleted,
    attendancePresent,
  };
}

async function loadAchievements(userId: string): Promise<AchievementWithProgress[]> {
  const [definitions, unlocked, metrics] = await Promise.all([
    prisma.achievement.findMany({
      select: {
        id: true,
        code: true,
        name: true,
        description: true,
        icon: true,
        xpReward: true,
        tier: true,
      },
    }),
    prisma.userAchievement.findMany({
      where: { userId },
      select: { achievementId: true, unlockedAt: true },
    }),
    collectAchievementMetrics(userId),
  ]);

  const unlockedById = new Map(unlocked.map((row) => [row.achievementId, row.unlockedAt]));

  return definitions
    .map((definition) => {
      const unlockedAt = unlockedById.get(definition.id) ?? null;
      const target = ACHIEVEMENT_TARGETS[definition.code];
      const progress: AchievementProgress | null = target
        ? {
            current: metrics[target.metric],
            target: target.target,
            percent: clampPercent((metrics[target.metric] / Math.max(1, target.target)) * 100),
          }
        : null;

      return {
        id: definition.id,
        code: definition.code,
        name: definition.name,
        description: definition.description,
        icon: definition.icon,
        xpReward: definition.xpReward,
        tier: definition.tier,
        unlockedAt,
        progress,
      };
    })
    .sort((a, b) => {
      const tierDelta = TIER_ORDER.indexOf(a.tier) - TIER_ORDER.indexOf(b.tier);
      if (tierDelta !== 0) return tierDelta;
      return a.name.localeCompare(b.name, "id");
    });
}

export async function listAchievements(scope: ProgressScope): Promise<AchievementWithProgress[]> {
  return loadAchievements(scope.userId);
}

export interface AchievementSummary {
  unlocked: number;
  total: number;
  /** XP credited through the ACHIEVEMENT ledger source. */
  achievementXp: number;
  nextClosest: {
    code: string;
    name: string;
    icon: string;
    tier: string;
    current: number;
    target: number;
    percent: number;
  } | null;
}

export async function getAchievementSummary(scope: ProgressScope): Promise<AchievementSummary> {
  const [items, aggregate] = await Promise.all([
    loadAchievements(scope.userId),
    prisma.xpEvent.aggregate({
      where: { userId: scope.userId, source: "ACHIEVEMENT" },
      _sum: { amount: true },
    }),
  ]);

  const unlockedCount = items.filter((item) => item.unlockedAt !== null).length;

  const closest = items
    .filter((item) => item.unlockedAt === null && item.progress !== null)
    .reduce<AchievementWithProgress | null>((best, item) => {
      if (!best) return item;
      return (item.progress?.percent ?? 0) > (best.progress?.percent ?? 0) ? item : best;
    }, null);

  return {
    unlocked: unlockedCount,
    total: items.length,
    achievementXp: aggregate._sum.amount ?? 0,
    nextClosest:
      closest && closest.progress
        ? {
            code: closest.code,
            name: closest.name,
            icon: closest.icon,
            tier: closest.tier,
            current: closest.progress.current,
            target: closest.progress.target,
            percent: closest.progress.percent,
          }
        : null,
  };
}
