import "server-only";
import { prisma } from "@/lib/db";
import type { XpSource } from "@prisma/client";
import { levelForXp } from "@/lib/level";

export {
  levelForXp,
  levelTitle,
  xpRequiredForLevel,
  describeLevel,
} from "@/lib/level";
export type { LevelProgress } from "@/lib/level";

/**
 * XP, levelling and skill progression.
 *
 * The level curve itself lives in `lib/level.ts` (client-safe, no database) and
 * is re-exported below. Everything in *this* module touches the database, so it
 * stays behind `server-only`. All XP mutations go through `awardXp` so the
 * ledger (`XpEvent`) always reconciles with the denormalised `User.xp` counter.
 */

export interface AwardXpInput {
  userId: string;
  amount: number;
  source: XpSource;
  reason: string;
  refType?: string;
  refId?: string;
  /** When true, silently no-op if this exact ref was already rewarded. */
  idempotent?: boolean;
}

export interface AwardXpResult {
  awarded: number;
  totalXp: number;
  level: number;
  leveledUp: boolean;
  previousLevel: number;
}

/**
 * Credit XP to a user and recompute their level.
 *
 * When `idempotent` is set the call checks the ledger for an identical
 * (source, refType, refId) entry first, so re-submitting or re-opening a lesson
 * cannot farm XP.
 */
export async function awardXp(input: AwardXpInput): Promise<AwardXpResult> {
  const { userId, amount, source, reason, refType, refId, idempotent } = input;

  if (amount <= 0) {
    const current = await prisma.user.findUniqueOrThrow({
      where: { id: userId },
      select: { xp: true, level: true },
    });
    return {
      awarded: 0,
      totalXp: current.xp,
      level: current.level,
      leveledUp: false,
      previousLevel: current.level,
    };
  }

  if (idempotent && refId) {
    const existing = await prisma.xpEvent.findFirst({
      where: { userId, source, refType: refType ?? null, refId },
      select: { id: true },
    });
    if (existing) {
      const current = await prisma.user.findUniqueOrThrow({
        where: { id: userId },
        select: { xp: true, level: true },
      });
      return {
        awarded: 0,
        totalXp: current.xp,
        level: current.level,
        leveledUp: false,
        previousLevel: current.level,
      };
    }
  }

  return prisma.$transaction(async (tx) => {
    const before = await tx.user.findUniqueOrThrow({
      where: { id: userId },
      select: { xp: true, level: true },
    });

    await tx.xpEvent.create({
      data: { userId, amount, source, reason, refType, refId },
    });

    const totalXp = before.xp + amount;
    const level = levelForXp(totalXp);

    await tx.user.update({
      where: { id: userId },
      data: { xp: totalXp, level },
    });

    return {
      awarded: amount,
      totalXp,
      level,
      leveledUp: level > before.level,
      previousLevel: before.level,
    };
  });
}

export interface SkillGrantInput {
  userId: string;
  skillSlug: string;
  xp: number;
}

export interface SkillGrantResult {
  skillName: string;
  level: number;
  leveledUp: boolean;
  previousLevel: number;
}

/**
 * Grant skill XP, rolling the skill level up every 100 XP.
 * Returns null when the skill slug does not exist.
 */
export async function grantSkillXp(
  input: SkillGrantInput
): Promise<SkillGrantResult | null> {
  const skill = await prisma.skill.findUnique({
    where: { slug: input.skillSlug },
    select: { id: true, name: true, maxLevel: true },
  });
  if (!skill) return null;

  return prisma.$transaction(async (tx) => {
    const existing = await tx.userSkill.findUnique({
      where: { userId_skillId: { userId: input.userId, skillId: skill.id } },
    });

    const previousXp = existing?.xp ?? 0;
    const previousLevel = existing?.level ?? 0;
    const nextXp = previousXp + input.xp;
    const nextLevel = Math.min(
      skill.maxLevel,
      Math.max(1, Math.floor(nextXp / 100) + 1)
    );

    await tx.userSkill.upsert({
      where: { userId_skillId: { userId: input.userId, skillId: skill.id } },
      create: {
        userId: input.userId,
        skillId: skill.id,
        xp: nextXp,
        level: nextLevel,
      },
      update: { xp: nextXp, level: nextLevel },
    });

    return {
      skillName: skill.name,
      level: nextLevel,
      leveledUp: nextLevel > previousLevel,
      previousLevel,
    };
  });
}

export interface AchievementCheckResult {
  code: string;
  name: string;
  icon: string;
  xpReward: number;
}

/**
 * Evaluate a user's live statistics against every achievement definition and
 * unlock the ones they now qualify for. Returns only newly unlocked items.
 */
export async function evaluateAchievements(userId: string): Promise<AchievementCheckResult[]> {
  const [definitions, unlocked, stats] = await Promise.all([
    prisma.achievement.findMany(),
    prisma.userAchievement.findMany({
      where: { userId },
      select: { achievementId: true },
    }),
    collectUserStats(userId),
  ]);

  const unlockedIds = new Set(unlocked.map((row) => row.achievementId));
  const newlyUnlocked: AchievementCheckResult[] = [];

  for (const definition of definitions) {
    if (unlockedIds.has(definition.id)) continue;
    if (!meetsCriteria(definition.code, stats)) continue;

    await prisma.userAchievement.create({
      data: { userId, achievementId: definition.id },
    });
    await awardXp({
      userId,
      amount: definition.xpReward,
      source: "ACHIEVEMENT",
      reason: `Unlocked achievement: ${definition.name}`,
      refType: "achievement",
      refId: definition.id,
      idempotent: true,
    });
    newlyUnlocked.push({
      code: definition.code,
      name: definition.name,
      icon: definition.icon,
      xpReward: definition.xpReward,
    });
  }

  return newlyUnlocked;
}

interface UserStats {
  lessonsCompleted: number;
  assignmentsSubmitted: number;
  assignmentsGraded: number;
  perfectScores: number;
  codingPassed: number;
  simulatorCleared: number;
  skillsUnlocked: number;
  coursesCompleted: number;
  level: number;
  attendancePresent: number;
}

async function collectUserStats(userId: string): Promise<UserStats> {
  const [
    lessonsCompleted,
    assignmentsSubmitted,
    assignmentsGraded,
    perfectScores,
    codingPassed,
    simulatorCleared,
    skillsUnlocked,
    coursesCompleted,
    user,
    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.submission.count({ where: { studentId: userId, status: { in: ["GRADED", "RETURNED"] } } }),
    prisma.submission.count({
      where: { studentId: userId, score: { not: null }, assignment: { maxScore: { gt: 0 } } },
    }),
    prisma.codingSubmission.count({
      where: { studentId: userId, status: "PASSED" },
    }),
    prisma.simulatorAttempt.count({ where: { userId, success: true } }),
    prisma.userSkill.count({ where: { userId } }),
    prisma.courseEnrollment.count({ where: { studentId: userId, status: "COMPLETED" } }),
    prisma.user.findUniqueOrThrow({ where: { id: userId }, select: { level: true } }),
    prisma.attendanceRecord.count({ where: { studentId: userId, status: { in: ["PRESENT", "LATE"] } } }),
  ]);

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

function meetsCriteria(code: string, stats: UserStats): boolean {
  switch (code) {
    case "first-steps":
      return stats.lessonsCompleted >= 1;
    case "lesson-enthusiast":
      return stats.lessonsCompleted >= 10;
    case "lesson-master":
      return stats.lessonsCompleted >= 30;
    case "first-submission":
      return stats.assignmentsSubmitted >= 1;
    case "consistent-worker":
      return stats.assignmentsSubmitted >= 15;
    case "first-code":
      return stats.codingPassed >= 1;
    case "code-warrior":
      return stats.codingPassed >= 10;
    case "robot-whisperer":
      return stats.simulatorCleared >= 5;
    case "skill-collector":
      return stats.skillsUnlocked >= 5;
    case "level-5":
      return stats.level >= 5;
    case "level-10":
      return stats.level >= 10;
    case "course-complete":
      return stats.coursesCompleted >= 1;
    case "perfect-attendance":
      return stats.attendancePresent >= 20;
    default:
      return false;
  }
}
