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

/**
 * Lesson reader and "my teaching" reads.
 */

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

export interface LessonDetail {
  id: string;
  title: string;
  slug: string;
  summary: string | null;
  content: string;
  type: string;
  videoUrl: string | null;
  attachmentUrl: string | null;
  durationMinutes: number;
  isPreview: boolean;
  status: string;
  objectives: string[];
  orderIndex: number;
  moduleTitle: string | null;
  course: { id: string; title: string; coverColor: string };
  canManage: boolean;
  /** Student-only progress. */
  progress: { status: string; percent: number; timeSpentSeconds: number; completedAt: Date | null } | null;
  /** Sibling lessons for prev/next navigation, ordered. */
  siblings: { id: string; title: string; orderIndex: number }[];
  assignments: { id: string; title: string; type: string; dueAt: Date | null; maxScore: number }[];
  /** Coding projects linked to this course, for a code-lab lesson. */
  projects: { id: string; title: string; difficulty: string }[];
  /** Classmates' discussion, if any. */
  comments: { id: string; body: string; authorName: string; createdAt: Date }[];
}

/** Prisma fragment: lessons the actor may read. */
function lessonAccessFilter(scope: LessonScope) {
  if (scope.role === "ADMIN") return {};
  if (scope.role === "TEACHER") {
    return {
      course: {
        OR: [{ teacherId: scope.userId }, { classroom: { teacherId: scope.userId } }],
      },
    };
  }
  return {
    status: "PUBLISHED" as const,
    OR: [
      { isPreview: true },
      {
        course: {
          OR: [
            { enrollments: { some: { studentId: scope.userId } } },
            {
              classroom: {
                enrollments: { some: { studentId: scope.userId, status: "ACTIVE" as const } },
              },
            },
          ],
        },
      },
    ],
  };
}

export async function getLesson(
  scope: LessonScope,
  lessonId: string
): Promise<LessonDetail | null> {
  const lesson = await prisma.lesson.findFirst({
    where: { AND: [{ id: lessonId }, lessonAccessFilter(scope)] },
    select: {
      id: true,
      title: true,
      slug: true,
      summary: true,
      content: true,
      type: true,
      videoUrl: true,
      attachmentUrl: true,
      durationMinutes: true,
      isPreview: true,
      status: true,
      objectives: true,
      orderIndex: true,
      courseId: true,
      module: { select: { title: true } },
      course: {
        select: {
          id: true,
          title: true,
          coverColor: true,
          teacherId: true,
          classroom: { select: { teacherId: true } },
        },
      },
      progress: {
        where: { studentId: scope.userId },
        select: {
          status: true,
          progressPercent: true,
          timeSpentSeconds: true,
          completedAt: true,
        },
        take: 1,
      },
      assignments: {
        where: scope.role === "STUDENT" ? { status: "PUBLISHED" } : {},
        orderBy: { dueAt: "asc" },
        select: { id: true, title: true, type: true, dueAt: true, maxScore: true },
      },
    },
  });

  if (!lesson) return null;

  const ownerIds = [
    lesson.course.teacherId,
    lesson.course.classroom?.teacherId,
  ].filter(Boolean) as string[];

  const [siblings, projects, comments] = await Promise.all([
    prisma.lesson.findMany({
      where: {
        courseId: lesson.courseId,
        ...(scope.role === "STUDENT" ? { status: "PUBLISHED" as const } : {}),
      },
      orderBy: [{ orderIndex: "asc" }],
      select: { id: true, title: true, orderIndex: true },
    }),
    prisma.codingProject.findMany({
      where: {
        courseId: lesson.courseId,
        ...(scope.role === "STUDENT" ? { status: "PUBLISHED" as const } : {}),
      },
      orderBy: { orderIndex: "asc" },
      select: { id: true, title: true, difficulty: true },
    }),
    prisma.comment.findMany({
      where: { lessonId: lesson.id },
      orderBy: { createdAt: "asc" },
      take: 50,
      select: {
        id: true,
        body: true,
        createdAt: true,
        author: { select: { fullName: true } },
      },
    }),
  ]);

  const own = lesson.progress[0];

  return {
    id: lesson.id,
    title: lesson.title,
    slug: lesson.slug,
    summary: lesson.summary,
    content: lesson.content,
    type: lesson.type,
    videoUrl: lesson.videoUrl,
    attachmentUrl: lesson.attachmentUrl,
    durationMinutes: lesson.durationMinutes,
    isPreview: lesson.isPreview,
    status: lesson.status,
    objectives: lesson.objectives,
    orderIndex: lesson.orderIndex,
    moduleTitle: lesson.module?.title ?? null,
    course: {
      id: lesson.course.id,
      title: lesson.course.title,
      coverColor: lesson.course.coverColor,
    },
    canManage: scope.role === "ADMIN" || ownerIds.includes(scope.userId),
    progress: own
      ? {
          status: own.status,
          percent: own.progressPercent,
          timeSpentSeconds: own.timeSpentSeconds,
          completedAt: own.completedAt,
        }
      : null,
    siblings,
    assignments: lesson.assignments,
    projects,
    comments: comments.map((comment) => ({
      id: comment.id,
      body: comment.body,
      authorName: comment.author.fullName,
      createdAt: comment.createdAt,
    })),
  };
}

export interface TeachingCourseRow {
  id: string;
  title: string;
  coverColor: string;
  status: string;
  level: string;
  lessonCount: number;
  assignmentCount: number;
  studentCount: number;
  averageProgress: number;
  submissionRate: number;
  averageScore: number | null;
  classroomName: string | null;
  updatedAt: Date;
}

export interface TeachingOverview {
  courses: TeachingCourseRow[];
  totals: {
    courses: number;
    publishedCourses: number;
    students: number;
    lessons: number;
    assignments: number;
    pendingGrading: number;
  };
}

/** The staff "my teaching" workspace. */
export async function getTeachingOverview(scope: LessonScope): Promise<TeachingOverview> {
  const courseFilter =
    scope.role === "ADMIN"
      ? {}
      : { OR: [{ teacherId: scope.userId }, { classroom: { teacherId: scope.userId } }] };

  const courses = await prisma.course.findMany({
    where: courseFilter,
    orderBy: [{ status: "asc" }, { title: "asc" }],
    select: {
      id: true,
      title: true,
      coverColor: true,
      status: true,
      level: true,
      updatedAt: true,
      classroom: { select: { name: true } },
      _count: { select: { lessons: true, assignments: true, enrollments: true } },
      enrollments: { select: { studentId: true, progress: true } },
      assignments: {
        select: {
          id: true,
          _count: { select: { submissions: true } },
          submissions: { select: { score: true, status: true } },
        },
      },
    },
  });

  const rows: TeachingCourseRow[] = courses.map((course) => {
    const progresses = course.enrollments.map((enrollment) => enrollment.progress);
    const averageProgress =
      progresses.length === 0
        ? 0
        : Math.round(progresses.reduce((a, b) => a + b, 0) / progresses.length);

    const assignmentIds = course.assignments.map((assignment) => assignment.id);
    const scored = course.assignments.flatMap((assignment) =>
      assignment.submissions
        .filter((submission) => submission.score !== null)
        .map((submission) => submission.score as number)
    );

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

    return {
      id: course.id,
      title: course.title,
      coverColor: course.coverColor,
      status: course.status,
      level: course.level,
      lessonCount: course._count.lessons,
      assignmentCount: course._count.assignments,
      studentCount: course._count.enrollments,
      averageProgress,
      submissionRate:
        possibleSubmissions === 0
          ? 0
          : Math.round((actualSubmissions / possibleSubmissions) * 100),
      averageScore:
        scored.length === 0
          ? null
          : Math.round((scored.reduce((a, b) => a + b, 0) / scored.length) * 10) / 10,
      classroomName: course.classroom?.name ?? null,
      updatedAt: course.updatedAt,
    };
  });

  const courseIds = rows.map((row) => row.id);

  const pendingGrading = await prisma.submission.count({
    where: {
      status: { in: ["SUBMITTED", "LATE"] },
      assignment: { courseId: { in: courseIds } },
    },
  });

  return {
    courses: rows,
    totals: {
      courses: rows.length,
      publishedCourses: rows.filter((row) => row.status === "PUBLISHED").length,
      students: new Set(courses.flatMap((course) => course.enrollments.map((row) => row.studentId)))
        .size,
      lessons: rows.reduce((sum, row) => sum + row.lessonCount, 0),
      assignments: rows.reduce((sum, row) => sum + row.assignmentCount, 0),
      pendingGrading,
    },
  };
}
