/* College & University (campus) demo seed — idempotent.
 *
 * Creates two ACTIVE demo institutions with full campus-module data:
 *  - Dhaka Imperial College (CL-2002, college@campus.demo …) — HSC (Science)
 *    under the Dhaka board (GPA-5 scale, board roll) + BBA Honours under the
 *    National University (GPA-4, registration no), with a finished +
 *    published Test Examination and semester final.
 *  - Bangladesh Global University (UN-3001) — B.Sc. (Hons) in CSE on the UGC
 *    credit-semester system: published 1st-semester final (with marks →
 *    transcript/CGPA), a mid-term, and an upcoming 2nd-semester final with a
 *    published routine.
 *
 * Skips everything when the institutions already exist.
 */
import bcrypt from "bcryptjs";
import { Prisma, PrismaClient } from "@prisma/client";

function iso(d: string): Date {
  return new Date(`${d}T00:00:00Z`);
}

/** deterministic marks: 55–94, with a chosen failing course & an absent one */
function marksFor(i: number, j: number, pass: number): { marks: number | null; absent: boolean } {
  // student 1 (index 1) is absent in the 3rd course; student 3 fails course 2
  if (i === 1 && j === 2) return { marks: null, absent: true };
  if (i === 3 && j === 1) return { marks: Math.max(10, pass - 12), absent: false };
  const v = 55 + ((i * 7 + j * 13) % 40);
  return { marks: v, absent: false };
}

type CourseSeed = { code: string; name: string; nameBn: string; credits: number; type: string; termSeq: number; full?: number; pass?: number };

export async function seedCampus(prisma: Prisma.TransactionClient | PrismaClient) {
  await seedCollege(prisma);
  await seedUniversity(prisma);
}

/* ------------------------------ college ------------------------------ */

async function seedCollege(prisma: Prisma.TransactionClient | PrismaClient) {
  const exists = await prisma.institution.findUnique({ where: { code: "CL-2002" } });
  if (exists) return;

  const inst = await prisma.institution.create({
    data: {
      name: "Dhaka Imperial College",
      code: "CL-2002",
      type: "COLLEGE_AND_UNIVERSITY",
      email: "campus.college@demo.com",
      phone: "+8801710000301",
      address: "Dhanmondi 27, Dhaka 1209",
      district: "Dhaka",
      subDistrict: "Dhanmondi",
      status: "ACTIVE",
      educationBoard: "DHAKA",
      boardCode: "DHK-1123",
      establishedYear: 1985,
    },
  });
  const password = await bcrypt.hash("Demo@123", 10);
  await prisma.user.create({
    data: {
      name: "College Admin",
      email: "campus.college@demo.com",
      passwordHash: password,
      role: "INSTITUTION_ADMIN",
      institutionId: inst.id,
    },
  });
  console.log("  ✔ Dhaka Imperial College: campus.college@demo.com / Demo@123");

  // a few teachers for offerings
  const teacherIds: number[] = [];
  for (const [i, name] of ["Md. Anwar Hossain", "Dr. Salma Khatun", "Nusrat Jahan"].entries()) {
    const st = await prisma.staff.create({
      data: {
        institutionId: inst.id,
        employeeCode: `T-${i + 1}`,
        name,
        designation: i === 1 ? "Associate Professor" : "Assistant Professor",
        department: i === 1 ? "Chemistry" : "Physics",
        phone: "+880170000030" + (i + 1),
        joinDate: iso("2018-01-10"),
      },
    });
    teacherIds.push(st.id);
  }

  /* ---- Program 1: HSC (Science) — board GPA-5 ---- */
  const hsc = await prisma.cuProgram.create({
    data: {
      institutionId: inst.id,
      name: "HSC (Science)",
      nameBn: "এইচএসসি (বিজ্ঞান)",
      code: "HSC-SCI",
      degreeLevel: "HSC",
      faculty: "Higher Secondary",
      department: "Science",
      durationYears: 2,
      totalCredits: 0,
      gradeScale: "GPA5",
    },
  });
  const hscTerms = [
    await prisma.cuTerm.create({ data: { institutionId: inst.id, programId: hsc.id, name: "HSC 1st Year", nameBn: "এইচএসসি ১ম বর্ষ", sequence: 1, startDate: iso("2025-07-01"), endDate: iso("2025-12-31") } }),
    await prisma.cuTerm.create({ data: { institutionId: inst.id, programId: hsc.id, name: "HSC 2nd Year", nameBn: "এইচএসসি ২য় বর্ষ", sequence: 2, startDate: iso("2026-01-01"), endDate: iso("2026-06-30") } }),
  ];

  const hscCourses: CourseSeed[] = [
    { code: "BAN-101", name: "Bangla", nameBn: "বাংলা", credits: 0, type: "THEORY", termSeq: 1, pass: 33 },
    { code: "ENG-101", name: "English", nameBn: "ইংরেজি", credits: 0, type: "THEORY", termSeq: 1, pass: 33 },
    { code: "PHY-101", name: "Physics", nameBn: "পদার্থবিজ্ঞান", credits: 0, type: "THEORY", termSeq: 1, pass: 33 },
    { code: "CHE-101", name: "Chemistry", nameBn: "রসায়ন", credits: 0, type: "THEORY", termSeq: 1, pass: 33 },
    { code: "MAT-101", name: "Higher Mathematics", nameBn: "উচ্চতর গণিত", credits: 0, type: "THEORY", termSeq: 1, pass: 33 },
  ];
  const hscCourseIds: number[] = [];
  for (const c of hscCourses) {
    const row = await prisma.cuCourse.create({
      data: {
        institutionId: inst.id, programId: hsc.id, termId: hscTerms[c.termSeq - 1].id,
        code: c.code, name: c.name, nameBn: c.nameBn, credits: c.credits,
        courseType: c.type, fullMarks: 100, passMarks: c.pass!,
      },
    });
    hscCourseIds.push(row.id);
  }

  // students + enrollments
  const hscNames = ["Rakib Hasan", "Sumaiya Akter", "Tanvir Ahmed", "Mehedi Hasan", "Farzana Yasmin", "Sabbir Rahman", "Nusrat Jahan", "Rifat Chowdhury", "Sadia Islam", "Jubayer Alam", "Mim Akter", "Shakil Khan"];
  const hscStudents: number[] = [];
  for (const [i, name] of hscNames.entries()) {
    const s = await prisma.cuStudent.create({
      data: {
        institutionId: inst.id,
        studentIdNo: `HSC-2025-${String(i + 1).padStart(2, "0")}`,
        name,
        nameBn: null,
        gender: /^(Sumaiya|Farzana|Nusrat|Sadia|Mim)/.test(name) ? "FEMALE" : "MALE",
        dob: iso(`200${8 + (i % 2)}-0${(i % 9) + 1}-1${i % 9}`),
        guardianName: "Md. Guardian " + name.split(" ")[0],
        guardianPhone: "+88018110003" + String(10 + i),
        phone: "+88019110003" + String(10 + i),
        address: "Dhanmondi, Dhaka",
        programId: hsc.id,
        sessionYear: "2025-26",
        currentTermId: hscTerms[1].id,
        boardRollNo: `DH-2026-${120000 + i}`,
        admissionDate: iso("2025-07-10"),
      },
    });
    hscStudents.push(s.id);
  }
  for (const [j, courseId] of hscCourseIds.entries()) {
    const off = await prisma.cuOffering.create({
      data: {
        institutionId: inst.id, courseId, sessionYear: "2025-26",
        section: j % 2 === 0 ? "A" : "B",
        staffId: teacherIds[j % teacherIds.length],
        maxSeats: 60,
      },
    });
    await prisma.cuEnrollment.createMany({
      data: hscStudents.map((sid) => ({ institutionId: inst.id, studentId: sid, offeringId: off.id })),
      skipDuplicates: true,
    });
  }

  // HSC Test Examination — finished, published routine + result, marks for all
  const testExam = await prisma.cuExam.create({
    data: {
      institutionId: inst.id, programId: hsc.id, termId: hscTerms[1].id,
      name: "HSC Test Examination 2026", nameBn: "এইচএসসি টেস্ট পরীক্ষা ২০২৬",
      examType: "PRELIMINARY", sessionYear: "2025-26",
      startDate: iso("2026-08-10"), endDate: iso("2026-08-20"),
      status: "FINISHED", schedulePublished: true, schedulePublishedAt: iso("2026-08-01"),
      resultPublished: true, resultPublishedAt: iso("2026-08-25"),
    },
  });
  const dayOffset = [0, 2, 4, 6, 8];
  for (const [j, courseId] of hscCourseIds.entries()) {
    const d = 10 + dayOffset[j % dayOffset.length];
    const sched = await prisma.cuExamSchedule.create({
      data: {
        institutionId: inst.id, examId: testExam.id, courseId,
        examDate: iso(`2026-08-${String(d).padStart(2, "0")}`),
        startTime: "10:00", endTime: "13:00",
        room: `Room ${301 + (j % 3)}`, fullMarks: 100, passMarks: 33,
      },
    });
    for (const [i, sid] of hscStudents.entries()) {
      const { marks, absent } = marksFor(i, j, 33);
      await prisma.cuExamMark.create({
        data: { institutionId: inst.id, scheduleId: sched.id, studentId: sid, marks, absent },
      });
    }
  }

  /* ---- Program 2: BBA (Honours) — National University GPA-4 ---- */
  const bba = await prisma.cuProgram.create({
    data: {
      institutionId: inst.id,
      name: "BBA (Honours)",
      nameBn: "বিবিএ (সম্মান)",
      code: "BBA-HONS",
      degreeLevel: "HONOURS",
      faculty: "Faculty of Business Studies",
      department: "Business Administration",
      durationYears: 4,
      totalCredits: 120,
      gradeScale: "GPA4",
    },
  });
  const bbaTerms = [
    await prisma.cuTerm.create({ data: { institutionId: inst.id, programId: bba.id, name: "1st Year 1st Semester", nameBn: "১ম বর্ষ ১ম সেমিস্টার", sequence: 1 } }),
    await prisma.cuTerm.create({ data: { institutionId: inst.id, programId: bba.id, name: "1st Year 2nd Semester", nameBn: "১ম বর্ষ ২য় সেমিস্টার", sequence: 2 } }),
  ];
  const bbaCourses: CourseSeed[] = [
    { code: "BUS-101", name: "Principles of Management", nameBn: "ব্যবস্থাপনার নীতি", credits: 3, type: "THEORY", termSeq: 1 },
    { code: "ECO-101", name: "Microeconomics", nameBn: "মাইক্রোইকোনমিক্স", credits: 3, type: "THEORY", termSeq: 1 },
    { code: "ACC-101", name: "Financial Accounting", nameBn: "আর্থিক হিসাববিজ্ঞান", credits: 3, type: "THEORY", termSeq: 1 },
    { code: "ENG-102", name: "Business English", nameBn: "ব্যবসায়িক ইংরেজি", credits: 3, type: "THEORY", termSeq: 1 },
  ];
  const bbaCourseIds: number[] = [];
  for (const c of bbaCourses) {
    const row = await prisma.cuCourse.create({
      data: {
        institutionId: inst.id, programId: bba.id, termId: bbaTerms[c.termSeq - 1].id,
        code: c.code, name: c.name, nameBn: c.nameBn, credits: c.credits,
        courseType: c.type, fullMarks: 100, passMarks: 40,
      },
    });
    bbaCourseIds.push(row.id);
  }
  const bbaNames = ["Ayesha Siddiqua", "Kamrul Islam", "Tahmina Begum", "Shahriar Kabir", "Rumana Parvin", "Asif Mahmud", "Nazmul Hasan", "Ishrat Jahan"];
  const bbaStudents: number[] = [];
  for (const [i, name] of bbaNames.entries()) {
    const s = await prisma.cuStudent.create({
      data: {
        institutionId: inst.id,
        studentIdNo: `BBA-2024-${String(i + 1).padStart(2, "0")}`,
        name,
        gender: /^(Ayesha|Tahmina|Rumana|Ishrat)/.test(name) ? "FEMALE" : "MALE",
        dob: iso(`200${5 + (i % 2)}-0${(i % 9) + 1}-0${(i % 8) + 1}`),
        guardianName: "Md. Guardian " + name.split(" ")[0],
        guardianPhone: "+88018110004" + String(10 + i),
        address: "Mohammadpur, Dhaka",
        programId: bba.id,
        sessionYear: "2024-25",
        currentTermId: bbaTerms[0].id,
        registrationNo: `NU-2024-1415${String(100 + i)}`,
        admissionDate: iso("2024-09-01"),
      },
    });
    bbaStudents.push(s.id);
  }
  for (const [j, courseId] of bbaCourseIds.entries()) {
    const off = await prisma.cuOffering.create({
      data: {
        institutionId: inst.id, courseId, sessionYear: "2024-25",
        staffId: teacherIds[j % teacherIds.length], maxSeats: 50,
      },
    });
    await prisma.cuEnrollment.createMany({
      data: bbaStudents.map((sid) => ({ institutionId: inst.id, studentId: sid, offeringId: off.id })),
      skipDuplicates: true,
    });
  }
  const bbaFinal = await prisma.cuExam.create({
    data: {
      institutionId: inst.id, programId: bba.id, termId: bbaTerms[0].id,
      name: "1st Semester Final Examination 2025",
      nameBn: "১ম সেমিস্টার ফাইনাল পরীক্ষা ২০২৫",
      examType: "SEMESTER_FINAL", sessionYear: "2024-25",
      startDate: iso("2025-04-01"), endDate: iso("2025-04-12"),
      status: "FINISHED", schedulePublished: true, schedulePublishedAt: iso("2025-03-20"),
      resultPublished: true, resultPublishedAt: iso("2025-04-20"),
    },
  });
  for (const [j, courseId] of bbaCourseIds.entries()) {
    const d = [1, 3, 5, 8][j % 4];
    const sched = await prisma.cuExamSchedule.create({
      data: {
        institutionId: inst.id, examId: bbaFinal.id, courseId,
        examDate: iso(`2025-04-0${d}`),
        startTime: "09:00", endTime: "12:00",
        room: `Room ${401 + (j % 2)}`, fullMarks: 100, passMarks: 40,
      },
    });
    for (const [i, sid] of bbaStudents.entries()) {
      const { marks, absent } = marksFor(i, j, 40);
      await prisma.cuExamMark.create({
        data: { institutionId: inst.id, scheduleId: sched.id, studentId: sid, marks, absent },
      });
    }
  }
  console.log("  ✔ College campus data: HSC (GPA-5) + BBA Honours (NU, GPA-4), published results");
}

/* ----------------------------- university ----------------------------- */

async function seedUniversity(prisma: Prisma.TransactionClient | PrismaClient) {
  const exists = await prisma.institution.findUnique({ where: { code: "UN-3001" } });
  if (exists) return;

  const inst = await prisma.institution.create({
    data: {
      name: "Bangladesh Global University",
      code: "UN-3001",
      type: "COLLEGE_AND_UNIVERSITY",
      email: "campus.university@demo.com",
      phone: "+8801710000401",
      address: "Permanent Campus, Bashundhara R/A, Dhaka",
      district: "Dhaka",
      subDistrict: "Khilkhet",
      status: "ACTIVE",
      establishedYear: 2004,
    },
  });
  const password = await bcrypt.hash("Demo@123", 10);
  await prisma.user.create({
    data: {
      name: "University Admin",
      email: "campus.university@demo.com",
      passwordHash: password,
      role: "INSTITUTION_ADMIN",
      institutionId: inst.id,
    },
  });
  console.log("  ✔ Bangladesh Global University: campus.university@demo.com / Demo@123");

  const teacherIds: number[] = [];
  for (const [i, name] of ["Dr. Mahmudul Hasan", "Dr. Sabrina Sharmin", "Arif Chowdhury"].entries()) {
    const st = await prisma.staff.create({
      data: {
        institutionId: inst.id,
        employeeCode: `F-${i + 1}`,
        name,
        designation: i === 2 ? "Lecturer" : "Associate Professor",
        department: "Computer Science & Engineering",
        phone: "+880170000040" + (i + 1),
        joinDate: iso("2015-03-01"),
      },
    });
    teacherIds.push(st.id);
  }

  const cse = await prisma.cuProgram.create({
    data: {
      institutionId: inst.id,
      name: "B.Sc. (Hons) in Computer Science & Engineering",
      nameBn: "সিএসই-তে বিএসসি (সম্মান)",
      code: "CSE-HONS",
      degreeLevel: "BACHELORS",
      faculty: "Faculty of Science & Engineering",
      department: "Computer Science & Engineering",
      durationYears: 4,
      totalCredits: 140,
      gradeScale: "GPA4",
    },
  });
  const terms = [
    await prisma.cuTerm.create({ data: { institutionId: inst.id, programId: cse.id, name: "1st Year 1st Semester", nameBn: "১ম বর্ষ ১ম সেমিস্টার", sequence: 1, startDate: iso("2024-09-01"), endDate: iso("2025-01-15") } }),
    await prisma.cuTerm.create({ data: { institutionId: inst.id, programId: cse.id, name: "1st Year 2nd Semester", nameBn: "১ম বর্ষ ২য় সেমিস্টার", sequence: 2, startDate: iso("2025-02-01"), endDate: iso("2025-06-30") } }),
  ];
  const courses: CourseSeed[] = [
    { code: "CSE-101", name: "Structured Programming", nameBn: "স্ট্রাকচার্ড প্রোগ্রামিং", credits: 3, type: "THEORY", termSeq: 1 },
    { code: "CSE-101L", name: "Structured Programming Lab", nameBn: "প্রোগ্রামিং ল্যাব", credits: 1.5, type: "LAB", termSeq: 1 },
    { code: "MAT-101", name: "Differential Calculus", nameBn: "অন্তরীকলন গণিত", credits: 3, type: "THEORY", termSeq: 1 },
    { code: "PHY-101", name: "Physics I", nameBn: "পদার্থবিজ্ঞান ১", credits: 3, type: "THEORY", termSeq: 1 },
    { code: "ENG-101", name: "Communicative English", nameBn: "কমিউনিকেটিভ ইংরেজি", credits: 3, type: "THEORY", termSeq: 1 },
    { code: "CSE-201", name: "Object Oriented Programming", nameBn: "অবজেক্ট ওরিয়েন্টেড প্রোগ্রামিং", credits: 3, type: "THEORY", termSeq: 2 },
    { code: "CSE-201L", name: "OOP Lab", nameBn: "ওওপি ল্যাব", credits: 1.5, type: "LAB", termSeq: 2 },
    { code: "MAT-201", name: "Discrete Mathematics", nameBn: "অসমতাল গণিত", credits: 3, type: "THEORY", termSeq: 2 },
  ];
  const courseIds: number[] = [];
  for (const c of courses) {
    const row = await prisma.cuCourse.create({
      data: {
        institutionId: inst.id, programId: cse.id, termId: terms[c.termSeq - 1].id,
        code: c.code, name: c.name, nameBn: c.nameBn, credits: c.credits,
        courseType: c.type, fullMarks: 100, passMarks: 40,
      },
    });
    courseIds.push(row.id);
  }

  const names = ["Nafis Iqbal", "Tasnim Rahman", "Sajid Karim", "Mehnaz Chowdhury", "Raisul Islam", "Anika Tabassum", "Fahim Shahriar", "Lamia Akter", "Zubair Ahmed", "Sanjida Hoque"];
  const students: number[] = [];
  for (const [i, name] of names.entries()) {
    const s = await prisma.cuStudent.create({
      data: {
        institutionId: inst.id,
        studentIdNo: `CSE-2024-${String(i + 1).padStart(3, "0")}`,
        name,
        gender: /^(Tasnim|Mehnaz|Anika|Lamia|Sanjida)/.test(name) ? "FEMALE" : "MALE",
        dob: iso(`200${5 + (i % 2)}-0${(i % 9) + 1}-0${(i % 8) + 1}`),
        guardianName: "Md. Guardian " + name.split(" ")[0],
        guardianPhone: "+88018110005" + String(10 + i),
        email: `cse2024${String(i + 1).padStart(3, "0")}@bgu.edu.bd`,
        address: "Bashundhara R/A, Dhaka",
        programId: cse.id,
        sessionYear: "2024-25",
        currentTermId: terms[1].id,
        admissionDate: iso("2024-08-25"),
      },
    });
    students.push(s.id);
  }

  // offerings: all courses for the cohort; enroll everyone in their term's courses
  const offeringIdByCourse = new Map<number, number>();
  for (const [j, courseId] of courseIds.entries()) {
    const off = await prisma.cuOffering.create({
      data: {
        institutionId: inst.id, courseId,
        sessionYear: j < 5 ? "2024-25" : "2024-25",
        section: j % 2 === 0 ? "A" : "B",
        staffId: teacherIds[j % teacherIds.length],
        maxSeats: 40,
      },
    });
    offeringIdByCourse.set(courseId, off.id);
  }
  for (const [j, courseId] of courseIds.entries()) {
    await prisma.cuEnrollment.createMany({
      data: students.map((sid) => ({ institutionId: inst.id, studentId: sid, offeringId: offeringIdByCourse.get(courseId)! })),
      skipDuplicates: true,
    });
  }

  /* 1st semester: mid-term (finished, marks, unpublished result) */
  const midterm = await prisma.cuExam.create({
    data: {
      institutionId: inst.id, programId: cse.id, termId: terms[0].id,
      name: "1st Semester Mid-Term Examination 2024",
      examType: "MIDTERM", sessionYear: "2024-25",
      startDate: iso("2024-11-10"), endDate: iso("2024-11-15"),
      status: "FINISHED",
    },
  });
  for (const [j, courseId] of courseIds.slice(0, 5).entries()) {
    const sched = await prisma.cuExamSchedule.create({
      data: {
        institutionId: inst.id, examId: midterm.id, courseId,
        examDate: iso(`2024-11-1${j}`), startTime: "10:00", endTime: "11:30",
        room: `Room ${501 + (j % 2)}`, fullMarks: 30, passMarks: 12,
      },
    });
    for (const [i, sid] of students.entries()) {
      const v = 15 + ((i * 5 + j * 3) % 14); // 15–28 of 30
      await prisma.cuExamMark.create({
        data: { institutionId: inst.id, scheduleId: sched.id, studentId: sid, marks: v, absent: false },
      });
    }
  }

  /* 1st semester final — finished + published routine/result (feeds the transcript) */
  const final1 = await prisma.cuExam.create({
    data: {
      institutionId: inst.id, programId: cse.id, termId: terms[0].id,
      name: "1st Semester Final Examination 2025",
      nameBn: "১ম সেমিস্টার ফাইনাল পরীক্ষা ২০২৫",
      examType: "SEMESTER_FINAL", sessionYear: "2024-25",
      startDate: iso("2025-01-05"), endDate: iso("2025-01-15"),
      status: "FINISHED", schedulePublished: true, schedulePublishedAt: iso("2024-12-20"),
      resultPublished: true, resultPublishedAt: iso("2025-01-30"),
    },
  });
  for (const [j, courseId] of courseIds.slice(0, 5).entries()) {
    const sched = await prisma.cuExamSchedule.create({
      data: {
        institutionId: inst.id, examId: final1.id, courseId,
        examDate: iso(`2025-01-0${j + 5}`), startTime: "09:00", endTime: "12:00",
        room: `Room ${501 + (j % 2)}`, fullMarks: 100, passMarks: 40,
      },
    });
    for (const [i, sid] of students.entries()) {
      const { marks, absent } = marksFor(i, j, 40);
      await prisma.cuExamMark.create({
        data: { institutionId: inst.id, scheduleId: sched.id, studentId: sid, marks, absent },
      });
    }
  }

  /* 2nd semester final — upcoming with a published routine (marks not entered) */
  const final2 = await prisma.cuExam.create({
    data: {
      institutionId: inst.id, programId: cse.id, termId: terms[1].id,
      name: "2nd Semester Final Examination 2025",
      nameBn: "২য় সেমিস্টার ফাইনাল পরীক্ষা ২০২৫",
      examType: "SEMESTER_FINAL", sessionYear: "2024-25",
      startDate: iso("2025-06-10"), endDate: iso("2025-06-18"),
      status: "UPCOMING", schedulePublished: true, schedulePublishedAt: iso("2025-05-30"),
    },
  });
  for (const [j, courseId] of courseIds.slice(5).entries()) {
    await prisma.cuExamSchedule.create({
      data: {
        institutionId: inst.id, examId: final2.id, courseId,
        examDate: iso(`2025-06-1${j}`), startTime: "09:00", endTime: "12:00",
        room: `Room ${503 + (j % 2)}`, fullMarks: 100, passMarks: 40,
      },
    });
  }
  console.log("  ✔ University campus data: CSE credit semesters, published result + transcript, upcoming final");
}

// Standalone execution: npx tsx prisma/seed-campus.ts
const invokedDirectly = process.argv[1] ? process.argv[1].split("\\").pop()?.includes("seed-campus") : false;
if (invokedDirectly) {
  const prisma = new PrismaClient();
  seedCampus(prisma)
    .then(() => {
      console.log("🌱 Campus (College & University) seed complete.");
    })
    .catch((e) => {
      console.error(e);
      process.exitCode = 1;
    })
    .finally(() => prisma.$disconnect());
}