/**
 * RoboLearn database seed.
 *
 * Produces a realistic, fully-interlinked academic dataset: staff and student
 * accounts, classrooms, courses with modules and lessons, assignments with a
 * real auto-scored quiz, submissions and grades, attendance history, coding
 * projects with executable test suites, robot-grid challenges, skills,
 * achievements, XP history, announcements and notifications.
 *
 * Idempotent: safe to re-run. Existing rows are matched by natural keys and
 * updated rather than duplicated.
 *
 * Run:  npm run db:seed
 */
import { PrismaClient, type Prisma } from "@prisma/client";
import { hashPassword } from "../src/lib/auth/password";
import { BUNDLED_ENTRIES } from "../src/lib/ai/knowledge";
import { ensureCertificateForCourse } from "@/lib/certificates";

const prisma = new PrismaClient();

const SEED_PASSWORD = process.env.SEED_DEFAULT_PASSWORD || "Qweasd123!";

// ---------------------------------------------------------------------------
// Deterministic pseudo-random helpers (stable seeds → reproducible demo data)
// ---------------------------------------------------------------------------

let seedState = 987654321;
function random(): number {
  seedState = (seedState * 1103515245 + 12345) % 2147483648;
  return seedState / 2147483648;
}

function pick<T>(items: readonly T[]): T {
  return items[Math.floor(random() * items.length)];
}

function randomInt(min: number, max: number): number {
  return Math.floor(random() * (max - min + 1)) + min;
}

/**
 * Stable pseudo-random decision derived from a natural key.
 *
 * The global `random()` stream advances by a different amount on every run
 * (earlier loops iterate over database rows), so `random() < p` would select a
 * *different* subset each time and the seed would keep inserting new rows.
 * Hashing the key makes the decision identical across runs, which — combined
 * with the existence guards — is what makes re-seeding truly idempotent.
 */
function hashChance(key: string, probability: number): boolean {
  let h = 2166136261;
  for (let i = 0; i < key.length; i += 1) {
    h ^= key.charCodeAt(i);
    h = Math.imul(h, 16777619);
  }
  return ((h >>> 0) % 100000) / 100000 < probability;
}

/** Stable integer in [min, max] derived from a natural key. */
function hashInt(key: string, min: number, max: number): number {
  let h = 2166136261;
  for (let i = 0; i < key.length; i += 1) {
    h ^= key.charCodeAt(i);
    h = Math.imul(h, 16777619);
  }
  return min + ((h >>> 0) % (max - min + 1));
}

function daysAgo(days: number, hour = 9): Date {
  const date = new Date();
  date.setDate(date.getDate() - days);
  date.setHours(hour, hashInt(`minute|${days}|${hour}`, 0, 59), 0, 0);
  return date;
}

/**
 * What a seeded student chose on one question.
 *
 * A correct answer stores the real key. A wrong one stores a plausible
 * alternative rather than the key, because the review screen marks the stored
 * response as "jawabanmu" — reusing the key there would show every student a
 * perfect paper and make the explanation column meaningless.
 */
function seededResponse(
  question: { type: string; options: unknown; correctAnswer: unknown; id: string },
  correct: boolean,
  key: string
): unknown {
  const options = Array.isArray(question.options) ? question.options : [];
  const answer = question.correctAnswer;

  if (correct) return answer;

  if (question.type === "MULTIPLE_CHOICE" || question.type === "TRUE_FALSE") {
    if (options.length === 0 || typeof answer !== "number") return answer;
    // Pick any option other than the key.
    const others = options.map((_, index) => index).filter((index) => index !== answer);
    return others.length > 0 ? others[hashInt(key, 0, others.length - 1)] : answer;
  }

  if (question.type === "MULTI_SELECT") {
    if (!Array.isArray(answer) || answer.length === 0) return answer;
    // Drop one correct option, so the set is wrong but recognisably attempted.
    const dropped = answer.slice(0, -1);
    return dropped.length > 0 ? dropped : answer;
  }

  if (question.type === "SHORT_ANSWER") {
    // A wrong free-text answer, clearly not the key.
    const wrong = ["algoritma", "pola", "dekomposisi", "variabel", "fungsi"];
    const candidates = wrong.filter((value) => value !== answer);
    return candidates[hashInt(key, 0, candidates.length - 1)] ?? "jawaban saya";
  }

  return answer;
}

function daysAhead(days: number, hour = 23): Date {
  const date = new Date();
  date.setDate(date.getDate() + days);
  date.setHours(hour, 59, 0, 0);
  return date;
}

function slugify(input: string): string {
  return input
    .toLowerCase()
    .replace(/[^a-z0-9\s-]/g, "")
    .trim()
    .replace(/\s+/g, "-")
    .slice(0, 60);
}

// ---------------------------------------------------------------------------
// Seed data definitions
// ---------------------------------------------------------------------------

const STAFF = [
  {
    username: "waloonnn",
    fullName: "Nadia Prameswari",
    email: "nadia.prameswari@robolearn.sch.id",
    role: "ADMIN" as const,
    school: "SMP Negeri 1 Bandung",
    bio: "Administrator platform RoboLearn dan koordinator kurikulum robotika.",
  },
  {
    username: "budi.santoso",
    fullName: "Budi Santoso",
    email: "budi.santoso@robolearn.sch.id",
    role: "TEACHER" as const,
    school: "SMP Negeri 1 Bandung",
    bio: "Guru robotika dan pemrograman. Fokus pada Arduino dan dasar elektronika.",
  },
  {
    username: "sari.dewi",
    fullName: "Sari Dewi Lestari",
    email: "sari.dewi@robolearn.sch.id",
    role: "TEACHER" as const,
    school: "SMP Negeri 1 Bandung",
    bio: "Pengajar Computational Thinking dan Python untuk pemula.",
  },
  {
    username: "agus.wijaya",
    fullName: "Agus Wijaya",
    email: "agus.wijaya@robolearn.sch.id",
    role: "TEACHER" as const,
    school: "SMP Negeri 1 Bandung",
    bio: "Guru fisika dan mentor tim olimpiade robotik sekolah.",
  },
];

const STUDENTS = [
  ["andi.pratama", "Andi Pratama", "7A"],
  ["bella.kusuma", "Bella Kusuma", "7A"],
  ["cahyo.nugroho", "Cahyo Nugroho", "7A"],
  ["dinda.permata", "Dinda Permata", "7A"],
  ["eko.saputra", "Eko Saputra", "7B"],
  ["fajar.ramadhan", "Fajar Ramadhan", "7B"],
  ["gita.anggraini", "Gita Anggraini", "7B"],
  ["hana.safitri", "Hana Safitri", "7B"],
  ["irfan.maulana", "Irfan Maulana", "8A"],
  ["joko.susilo", "Joko Susilo", "8A"],
  ["kartika.sari", "Kartika Sari", "8A"],
  ["lisa.amelia", "Lisa Amelia", "8A"],
  ["mira.setiawan", "Mira Setiawan", "8B"],
  ["naufal.hakim", "Naufal Hakim", "8B"],
  ["oki.prasetyo", "Oki Prasetyo", "8B"],
  ["putri.handayani", "Putri Handayani", "8B"],
] as const;

interface LessonSeed {
  title: string;
  type: "TEXT" | "VIDEO" | "INTERACTIVE" | "CODE_LAB" | "QUIZ";
  minutes: number;
  summary: string;
  objectives: string[];
  content: string;
}

interface ModuleSeed {
  title: string;
  description: string;
  lessons: LessonSeed[];
}

interface CourseSeed {
  title: string;
  summary: string;
  description: string;
  level: "BEGINNER" | "INTERMEDIATE" | "ADVANCED";
  language: "JAVASCRIPT" | "PYTHON" | "ROBOT";
  hours: number;
  color: string;
  tags: string[];
  teacher: string;
  modules: ModuleSeed[];
}

const COURSES: CourseSeed[] = [
  {
    title: "Dasar Computational Thinking",
    summary: "Fondasi berpikir komputasional: dekomposisi, pola, abstraksi, dan algoritma.",
    description:
      "Mata pelajaran pengantar yang membangun cara berpikir sistematis sebelum menulis kode. Siswa belajar memecah masalah besar menjadi langkah kecil, mengenali pola, dan menyusun algoritma yang dapat diuji.",
    level: "BEGINNER",
    language: "JAVASCRIPT",
    hours: 12,
    color: "#6366f1",
    tags: ["computational-thinking", "algoritma", "logika"],
    teacher: "sari.dewi",
    modules: [
      {
        title: "Berpikir Seperti Komputer",
        description: "Empat pilar computational thinking dan penerapannya sehari-hari.",
        lessons: [
          {
            title: "Apa itu Computational Thinking?",
            type: "TEXT",
            minutes: 25,
            summary: "Mengenal empat pilar: dekomposisi, pengenalan pola, abstraksi, dan algoritma.",
            objectives: [
              "Menjelaskan definisi computational thinking",
              "Menyebutkan empat pilar computational thinking",
              "Mengidentifikasi penerapan computational thinking dalam aktivitas harian",
            ],
            content: `## Berpikir Sistematis

**Computational thinking** adalah cara menyelesaikan masalah dengan memformulasikannya sehingga komputer (atau manusia) dapat mengerjakannya secara efisien.

### Empat Pilar

1. **Dekomposisi** — memecah masalah besar menjadi bagian-bagian kecil yang lebih mudah diselesaikan.
2. **Pengenalan Pola** — menemukan kesamaan atau keteraturan antar masalah.
3. **Abstraksi** — menyaring detail yang tidak perlu dan fokus pada informasi penting.
4. **Algoritma** — menyusun langkah penyelesaian yang berurutan dan jelas.

### Contoh Nyata

Bayangkan kamu diminta merapikan perpustakaan sekolah.

- *Dekomposisi*: pisahkan buku fiksi dan non-fiksi, lalu kelompokkan per genre.
- *Pengenalan pola*: setiap buku punya label kode yang mengikuti aturan tertentu.
- *Abstraksi*: kamu tidak perlu tahu isi buku, cukup kode dan lokasinya.
- *Algoritma*: ambil buku → baca kode → cari rak yang sesuai → letakkan → ulangi.

### Latihan

Tuliskan langkah algoritma untuk membuat teh manis. Bandingkan dengan temanmu — apakah urutannya sama? Apakah urutan berpengaruh pada hasil?`,
          },
          {
            title: "Dekomposisi Masalah",
            type: "TEXT",
            minutes: 30,
            summary: "Teknik memecah masalah kompleks menjadi sub-masalah yang dapat dikelola.",
            objectives: [
              "Memecah satu masalah kompleks menjadi minimal tiga sub-masalah",
              "Menjelaskan mengapa dekomposisi mempermudah pengerjaan",
            ],
            content: `## Memecah Masalah Besar

Masalah besar terasa mustahil sampai kita membaginya menjadi bagian yang cukup kecil untuk dikerjakan.

### Studi Kasus: Aplikasi Absensi Sekolah

Sebuah aplikasi absensi bisa dipecah menjadi:

| Sub-masalah | Pertanyaan kunci |
| --- | --- |
| Data siswa | Siapa saja yang terdaftar? |
| Pencatatan | Bagaimana status kehadiran disimpan? |
| Rekap | Bagaimana laporan per bulan dibuat? |
| Notifikasi | Kapan orang tua dihubungi? |

Setiap sub-masalah bisa dikerjakan oleh orang berbeda secara paralel.

### Aturan Praktis

- Jika sebuah tugas butuh lebih dari satu halaman penjelasan, pecah lagi.
- Setiap bagian harus punya **hasil yang bisa diperiksa**.
- Urutkan dari yang paling mendasar.

### Latihan

Pecah tugas "membuat robot line follower" menjadi minimal lima sub-masalah.`,
          },
          {
            title: "Menyusun Algoritma",
            type: "INTERACTIVE",
            minutes: 35,
            summary: "Menulis algoritma dengan pseudocode dan flowchart.",
            objectives: [
              "Menulis pseudocode untuk masalah sederhana",
              "Menggambar flowchart dengan simbol yang benar",
            ],
            content: `## Dari Ide ke Langkah

Algoritma adalah resep: urutan langkah yang, bila diikuti, menghasilkan hasil yang diinginkan.

### Pseudocode

Pseudocode adalah bahasa manusia dengan struktur program.

\`\`\`text
MULAI
  siapkan cangkir
  didihkan air
  SELAMA air belum mendidih:
    tunggu 10 detik
  tuang air ke cangkir
  tambahkan teh
  tunggu 3 menit
  SAJIKAN
SELESAI
\`\`\`

### Simbol Flowchart

- **Oval** — mulai / selesai
- **Persegi panjang** — proses
- **Jajar genjang** — input / output
- **Belah ketupat** — keputusan (ya / tidak)
- **Panah** — arah alur

### Latihan

Buat flowchart untuk menentukan apakah seorang siswa lulus berdasarkan nilai rata-rata minimal 75.`,
          },
          {
            title: "Kuis: Pilar Computational Thinking",
            type: "QUIZ",
            minutes: 15,
            summary: "Uji pemahaman tentang empat pilar computational thinking.",
            objectives: ["Mengukur pemahaman konsep dasar"],
            content: "Kerjakan kuis berikut untuk mengukur pemahamanmu tentang empat pilar computational thinking.",
          },
        ],
      },
      {
        title: "Logika dan Pengambilan Keputusan",
        description: "Operator logika, kondisi, dan alur keputusan.",
        lessons: [
          {
            title: "Nilai Benar dan Salah",
            type: "TEXT",
            minutes: 25,
            summary: "Memahami boolean, operator perbandingan, dan logika dasar.",
            objectives: [
              "Menggunakan operator perbandingan",
              "Menyusun ekspresi logika dengan AND, OR, NOT",
            ],
            content: `## Dunia Dua Nilai

Komputer mengambil keputusan berdasarkan nilai **benar** (\`true\`) atau **salah** (\`false\`).

### Operator Perbandingan

| Operator | Arti | Contoh | Hasil |
| --- | --- | --- | --- |
| \`>\` | lebih besar | \`7 > 5\` | true |
| \`<\` | lebih kecil | \`7 < 5\` | false |
| \`===\` | sama dengan | \`"a" === "a"\` | true |
| \`!==\` | tidak sama | \`3 !== 4\` | true |

### Operator Logika

- \`&&\` (AND) — benar hanya jika **keduanya** benar
- \`||\` (OR) — benar jika **salah satu** benar
- \`!\` (NOT) — membalik nilai

### Contoh

\`\`\`javascript
const nilai = 82;
const hadir = true;

const lulus = nilai >= 75 && hadir;
console.log(lulus); // true
\`\`\`

### Latihan

Tentukan hasil dari: \`(10 > 5) && !(3 === 4) || false\``,
          },
          {
            title: "Percabangan if-else",
            type: "CODE_LAB",
            minutes: 40,
            summary: "Mengendalikan alur program dengan kondisi.",
            objectives: [
              "Menulis struktur if / else if / else",
              "Menyelesaikan masalah bertingkat dengan percabangan",
            ],
            content: `## Membuat Program Mengambil Keputusan

Struktur percabangan memungkinkan program memilih jalur berbeda.

\`\`\`javascript
const suhu = 38.5;

if (suhu >= 38) {
  console.log("Demam tinggi — istirahat di rumah");
} else if (suhu >= 37.5) {
  console.log("Suhu naik — minum air putih");
} else {
  console.log("Suhu normal");
}
\`\`\`

### Urutan Itu Penting

Kondisi diperiksa dari atas ke bawah. Kondisi pertama yang benar akan dijalankan, sisanya dilewati. Karena itu, letakkan kondisi paling spesifik di atas.

### Latihan Praktis

Buat fungsi \`kategoriNilai(angka)\` yang mengembalikan:

- \`"A"\` untuk 90–100
- \`"B"\` untuk 80–89
- \`"C"\` untuk 70–79
- \`"D"\` untuk 60–69
- \`"E"\` untuk di bawah 60`,
          },
        ],
      },
    ],
  },
  {
    title: "Pemrograman JavaScript untuk Pemula",
    summary: "Variabel, tipe data, fungsi, dan struktur data dengan JavaScript.",
    description:
      "Kursus praktik menulis kode JavaScript dari nol. Setiap konsep langsung diterapkan pada latihan yang dijalankan di dalam browser.",
    level: "BEGINNER",
    language: "JAVASCRIPT",
    hours: 20,
    color: "#f59e0b",
    tags: ["javascript", "coding", "web"],
    teacher: "sari.dewi",
    modules: [
      {
        title: "Variabel dan Tipe Data",
        description: "Menyimpan dan mengelola nilai dalam program.",
        lessons: [
          {
            title: "Menyimpan Data dengan Variabel",
            type: "TEXT",
            minutes: 30,
            summary: "Menggunakan let, const, dan tipe data dasar.",
            objectives: [
              "Membedakan let dan const",
              "Mengenali tipe data string, number, dan boolean",
            ],
            content: `## Variabel: Kotak Penyimpanan

Variabel memberi nama pada sebuah nilai agar bisa dipakai berulang kali.

\`\`\`javascript
const namaSekolah = "SMP Negeri 1 Bandung";
let jumlahSiswa = 32;
jumlahSiswa = jumlahSiswa + 1; // boleh, karena let
\`\`\`

### const vs let

- \`const\` — nilainya tidak boleh diubah setelah ditetapkan. **Gunakan ini secara default.**
- \`let\` — nilainya boleh berubah. Gunakan hanya bila memang perlu.

### Tipe Data Dasar

| Tipe | Contoh | Kegunaan |
| --- | --- | --- |
| string | \`"Halo"\` | teks |
| number | \`42\`, \`3.14\` | angka |
| boolean | \`true\` | benar / salah |
| array | \`[1, 2, 3]\` | daftar nilai |
| object | \`{ nama: "Andi" }\` | kumpulan data berlabel |

### Latihan

Buat variabel untuk menyimpan data dirimu: nama, kelas, dan hobi. Cetak semuanya dengan \`console.log\`.`,
          },
          {
            title: "Latihan: Kalkulator Sederhana",
            type: "CODE_LAB",
            minutes: 45,
            summary: "Membuat kalkulator dengan fungsi dan operator aritmetika.",
            objectives: [
              "Menggunakan operator aritmetika",
              "Membuat dan memanggil fungsi",
            ],
            content: `## Fungsi: Blok Kode yang Bisa Dipakai Ulang

\`\`\`javascript
function tambah(a, b) {
  return a + b;
}

console.log(tambah(3, 4)); // 7
\`\`\`

### Aturan Fungsi yang Baik

1. Nama menjelaskan **apa yang dilakukan**, bukan bagaimana.
2. Satu fungsi mengerjakan **satu hal**.
3. Selalu \`return\` hasilnya agar bisa dipakai di tempat lain.

### Tugas

Lengkapi fungsi berikut sehingga kalkulator dapat berjalan:

- \`tambah(a, b)\`
- \`kurang(a, b)\`
- \`kali(a, b)\`
- \`bagi(a, b)\` — kembalikan \`null\` jika \`b\` bernilai 0

Jalankan kode untuk memastikan semua benar.`,
          },
          {
            title: "Kuis: Dasar JavaScript",
            type: "QUIZ",
            minutes: 20,
            summary: "Kuis pilihan ganda tentang variabel, tipe data, dan fungsi.",
            objectives: ["Memverifikasi pemahaman sintaks dasar"],
            content: "Kerjakan kuis untuk memastikan pemahamanmu tentang dasar JavaScript sudah kuat.",
          },
        ],
      },
      {
        title: "Struktur Data dan Perulangan",
        description: "Array, objek, dan pengulangan untuk mengolah banyak data.",
        lessons: [
          {
            title: "Array dan Objek",
            type: "TEXT",
            minutes: 35,
            summary: "Mengelompokkan data dengan array dan objek.",
            objectives: [
              "Mengakses elemen array dengan indeks",
              "Membaca properti objek",
              "Menggabungkan array dan objek",
            ],
            content: `## Mengelompokkan Data

### Array — Daftar Berurutan

\`\`\`javascript
const nilai = [88, 92, 75, 60];
console.log(nilai[0]);      // 88  (indeks dimulai dari 0)
console.log(nilai.length);  // 4
\`\`\`

### Objek — Data Berlabel

\`\`\`javascript
const siswa = {
  nama: "Bella Kusuma",
  kelas: "7A",
  nilai: [88, 92, 75],
};

console.log(siswa.nama);        // Bella Kusuma
console.log(siswa.nilai[1]);    // 92
\`\`\`

### Menggabungkan Keduanya

\`\`\`javascript
const kelas = [
  { nama: "Andi", nilai: 88 },
  { nama: "Bella", nilai: 92 },
];
\`\`\`

Inilah bentuk data yang paling sering kamu temui di dunia nyata.

### Latihan

Buat array berisi tiga objek siswa, lalu cetak nama siswa dengan nilai tertinggi.`,
          },
          {
            title: "Perulangan for dan while",
            type: "CODE_LAB",
            minutes: 40,
            summary: "Mengulang pekerjaan tanpa menulis kode berulang kali.",
            objectives: [
              "Menulis perulangan for dan while",
              "Menghindari infinite loop",
            ],
            content: `## Mengulang Tanpa Menyalin

\`\`\`javascript
for (let i = 1; i <= 5; i++) {
  console.log("Putaran ke-" + i);
}
\`\`\`

### Anatomi Perulangan for

\`for (inisialisasi; kondisi; langkah)\`

1. **Inisialisasi** — dijalankan sekali di awal.
2. **Kondisi** — diperiksa sebelum setiap putaran.
3. **Langkah** — dijalankan setelah setiap putaran.

### while — Ketika Jumlah Putaran Tidak Diketahui

\`\`\`javascript
let bensin = 5;
while (bensin > 0) {
  console.log("Robot bergerak, sisa bensin: " + bensin);
  bensin--;
}
\`\`\`

> ⚠️ **Hati-hati:** jika kondisi tidak pernah menjadi salah, program akan berputar selamanya.

### Tugas

Cetak semua angka genap dari 1 sampai 50, lalu hitung berapa banyak jumlahnya.`,
          },
        ],
      },
    ],
  },
  {
    title: "Robotika Dasar: Sensor dan Aktuator",
    summary: "Mengenal komponen robot, sensor, aktuator, dan cara kerjanya.",
    description:
      "Pengenalan perangkat keras robotika. Siswa mempelajari bagaimana robot membaca lingkungan melalui sensor dan bertindak melalui aktuator, lalu menyimulasikannya di grid simulator.",
    level: "BEGINNER",
    language: "ROBOT",
    hours: 16,
    color: "#10b981",
    tags: ["robotika", "sensor", "hardware"],
    teacher: "budi.santoso",
    modules: [
      {
        title: "Anatomi Robot",
        description: "Komponen penyusun robot dan fungsinya.",
        lessons: [
          {
            title: "Sensor: Indra Sebuah Robot",
            type: "TEXT",
            minutes: 30,
            summary: "Jenis-jenis sensor dan prinsip kerjanya.",
            objectives: [
              "Menyebutkan minimal lima jenis sensor",
              "Menjelaskan fungsi sensor pada robot",
            ],
            content: `## Bagaimana Robot "Melihat"

Robot tidak punya mata, tetapi punya **sensor** — perangkat yang mengubah kondisi fisik menjadi sinyal listrik.

### Sensor yang Umum

| Sensor | Mengukur | Contoh Pemakaian |
| --- | --- | --- |
| Ultrasonik | jarak | menghindari dinding |
| Inframerah | pantulan cahaya | mengikuti garis |
| LDR | intensitas cahaya | robot mengikuti sumber cahaya |
| Termistor | suhu | pemantau suhu ruang |
| Akselerometer | percepatan & kemiringan | menjaga keseimbangan |

### Cara Kerja Sensor Ultrasonik

Sensor mengirim pulsa suara, lalu mengukur waktu sampai pantulannya kembali.

\`\`\`text
jarak = (kecepatan suara × waktu tempuh) / 2
\`\`\`

Dibagi dua karena suara menempuh jarak **pergi dan pulang**.

### Simulator

Buka lab simulator di menu **Laboratorium → Simulator Robot** untuk mencoba logika sensor secara visual pada grid.`,
          },
          {
            title: "Aktuator: Otot Sebuah Robot",
            type: "TEXT",
            minutes: 30,
            summary: "Motor, servo, dan cara mengendalikan gerakan.",
            objectives: [
              "Membedakan motor DC, servo, dan stepper",
              "Menjelaskan fungsi driver motor",
            ],
            content: `## Mengubah Sinyal Menjadi Gerakan

**Aktuator** mengubah energi listrik menjadi gerakan.

### Jenis Aktuator

- **Motor DC** — berputar terus menerus. Cocok untuk roda robot.
- **Servo** — berputar ke sudut tertentu (0°–180°). Cocok untuk lengan robot.
- **Stepper** — berputar dalam langkah presisi. Cocok untuk printer 3D.

### Mengapa Perlu Driver Motor?

Pin mikrokontroler hanya mampu mengalirkan arus kecil (sekitar 20 mA), sedangkan motor membutuhkan ratusan miliampere hingga beberapa ampere. **Driver motor** (seperti L298N) berfungsi sebagai saklar bertenaga yang dikendalikan sinyal lemah dari mikrokontroler.

\`\`\`text
Mikrokontroler ──sinyal──> Driver Motor ──arus besar──> Motor
\`\`\`

### Latihan

Rancang robot sederhana yang dapat: (1) bergerak maju, (2) berbelok, dan (3) berhenti. Komponen apa saja yang dibutuhkan?`,
          },
          {
            title: "Lab: Navigasi Grid",
            type: "INTERACTIVE",
            minutes: 45,
            summary: "Memprogram robot untuk menavigasi grid dan mengambil bintang.",
            objectives: [
              "Menggunakan perintah move, turnLeft, turnRight",
              "Menggunakan repeat untuk efisiensi",
            ],
            content: `## Memprogram Robot di Grid

Di simulator, kamu menulis program yang mengendalikan robot pada grid dua dimensi.

### Perintah Dasar

\`\`\`text
move()        maju satu langkah
turnLeft()    berputar 90° ke kiri
turnRight()   berputar 90° ke kanan
pick()        ambil bintang di posisi ini
\`\`\`

### Perulangan

Daripada menulis \`move()\` empat kali, gunakan:

\`\`\`text
repeat(4) {
  move()
}
\`\`\`

### Kondisi

\`\`\`text
if (canMove()) {
  move()
} else {
  turnRight()
}
\`\`\`

### Tugas

Buka **Laboratorium → Simulator Robot**, pilih tantangan "Lorong Pertama", lalu tulis program agar robot mencapai bendera tujuan.`,
          },
        ],
      },
    ],
  },
  {
    title: "Python untuk Analisis Data",
    summary: "Dasar Python, list, dictionary, dan pengolahan data sederhana.",
    description:
      "Belajar Python sebagai bahasa kedua. Fokus pada pengolahan data, fungsi, dan penerapan pada proyek nyata seperti analisis nilai kelas.",
    level: "INTERMEDIATE",
    language: "PYTHON",
    hours: 18,
    color: "#3b82f6",
    tags: ["python", "data", "analisis"],
    teacher: "sari.dewi",
    modules: [
      {
        title: "Sintaks Python",
        description: "Perbedaan mendasar Python dibanding JavaScript.",
        lessons: [
          {
            title: "Variabel dan Indentasi di Python",
            type: "TEXT",
            minutes: 30,
            summary: "Sintaks Python yang bersih dan aturan indentasi.",
            objectives: [
              "Menulis variabel tanpa kata kunci",
              "Memahami peran indentasi sebagai blok kode",
            ],
            content: `## Python: Bersih dan Terbaca

\`\`\`python
nama = "Andi"
umur = 13
tinggi = 155.5
suka_robotika = True

print(f"{nama} berumur {umur} tahun")
\`\`\`

### Tidak Ada Kurung Kurawal

Di Python, **indentasi** menentukan blok kode. Empat spasi adalah konvensi standar.

\`\`\`python
nilai = 82

if nilai >= 75:
    print("Lulus")
    print("Selamat!")
else:
    print("Belum lulus")
\`\`\`

Indentasi yang salah akan menyebabkan \`IndentationError\`.

### f-string

\`\`\`python
print(f"Nilai akhir: {nilai * 0.4 + 60}")
\`\`\`

Tanda \`f\` di depan string memungkinkan menyisipkan nilai variabel langsung di dalam \`{ }\`.`,
          },
          {
            title: "Lab: Analisis Nilai Kelas",
            type: "CODE_LAB",
            minutes: 50,
            summary: "Menghitung rata-rata, nilai tertinggi, dan distribusi nilai.",
            objectives: [
              "Menggunakan list dan perulangan di Python",
              "Menghitung statistik dasar",
            ],
            content: `## Mengolah Data Nyata

\`\`\`python
nilai = [88, 92, 75, 60, 95, 70, 83]

rata_rata = sum(nilai) / len(nilai)
tertinggi = max(nilai)
terendah = min(nilai)

print(f"Rata-rata: {rata_rata:.1f}")
print(f"Tertinggi: {tertinggi}")
print(f"Terendah: {terendah}")
\`\`\`

### Tugas

Lengkapi program sehingga dapat:

1. Menghitung rata-rata kelas.
2. Menghitung berapa siswa yang nilainya di atas rata-rata.
3. Menampilkan nilai dalam urutan menurun.
4. Menghitung persentase siswa yang lulus (nilai ≥ 75).`,
          },
        ],
      },
    ],
  },
  {
    title: "Proyek Robot Line Follower",
    summary: "Proyek akhir: merancang, membangun, dan memprogram robot line follower.",
    description:
      "Proyek terpadu yang menggabungkan pemrograman, sensor, dan kerja tim. Siswa merancang robot yang mengikuti garis, menguji berulang kali, dan mempresentasikan hasilnya.",
    level: "ADVANCED",
    language: "ROBOT",
    hours: 24,
    color: "#ef4444",
    tags: ["proyek", "robotika", "line-follower"],
    teacher: "budi.santoso",
    modules: [
      {
        title: "Perancangan",
        description: "Spesifikasi, sketsa, dan pemilihan komponen.",
        lessons: [
          {
            title: "Menentukan Spesifikasi Robot",
            type: "TEXT",
            minutes: 35,
            summary: "Menyusun kebutuhan fungsional dan non-fungsional robot.",
            objectives: [
              "Menulis spesifikasi kebutuhan robot",
              "Memilih komponen berdasarkan spesifikasi",
            ],
            content: `## Mulai dari Kebutuhan

Sebelum membeli komponen, tentukan dulu apa yang robot harus lakukan.

### Kebutuhan Fungsional

- Robot harus mengikuti garis hitam di atas permukaan putih.
- Robot harus berhenti otomatis setelah melewati garis finis.
- Robot harus dapat berbelok pada tikungan tajam.

### Kebutuhan Non-Fungsional

- Berat maksimal 500 gram.
- Kecepatan rata-rata 20 cm/detik.
- Daya tahan minimal 30 menit dengan satu baterai.

### Memilih Komponen

| Kebutuhan | Komponen | Alasan |
| --- | --- | --- |
| Mendeteksi garis | 2× sensor inframerah | membedakan hitam/putih |
| Menggerakkan roda | 2× motor DC + driver | torsi cukup, mudah dikendalikan |
| Mengendalikan | Arduino Uno | pin cukup, mudah diprogram |

### Latihan

Susun spesifikasi untuk robot yang bertugas memindahkan barang di gudang.`,
          },
          {
            title: "Presentasi Proyek",
            type: "TEXT",
            minutes: 40,
            summary: "Panduan menyusun dan menyampaikan presentasi proyek robot.",
            objectives: [
              "Menyusun laporan proyek yang sistematis",
              "Menyampaikan hasil secara jelas",
            ],
            content: `## Menyampaikan Hasil Kerja

### Struktur Laporan

1. **Latar belakang** — masalah apa yang diselesaikan?
2. **Spesifikasi** — apa yang robot harus lakukan?
3. **Desain** — sketsa dan komponen yang dipilih.
4. **Implementasi** — bagaimana dibuat dan diprogram.
5. **Pengujian** — data hasil uji, termasuk kegagalan.
6. **Refleksi** — apa yang akan diperbaiki selanjutnya?

### Tips Presentasi

- Tunjukkan **demo langsung** bila memungkinkan.
- Sebutkan kegagalan dengan jujur — itu bagian dari proses engineering.
- Siapkan jawaban untuk pertanyaan "mengapa memilih komponen ini?"

### Penilaian

| Aspek | Bobot |
| --- | --- |
| Fungsi robot | 40% |
| Kualitas laporan | 25% |
| Presentasi | 20% |
| Kerja sama tim | 15% |`,
          },
        ],
      },
    ],
  },
  {
    title: "Algoritma dan Struktur Data",
    summary: "Pencarian, pengurutan, dan struktur data untuk masalah yang lebih kompleks.",
    description:
      "Melanjutkan kemampuan pemrograman ke tingkat lanjut: menganalisis efisiensi algoritma dan memilih struktur data yang tepat.",
    level: "ADVANCED",
    language: "JAVASCRIPT",
    hours: 22,
    color: "#8b5cf6",
    tags: ["algoritma", "struktur-data", "optimasi"],
    teacher: "agus.wijaya",
    modules: [
      {
        title: "Pencarian dan Pengurutan",
        description: "Algoritma klasik dan analisis efisiensinya.",
        lessons: [
          {
            title: "Pencarian Biner",
            type: "TEXT",
            minutes: 40,
            summary: "Mencari data jauh lebih cepat dengan membagi ruang pencarian.",
            objectives: [
              "Menjelaskan prinsip divide and conquer",
              "Mengimplementasikan binary search",
            ],
            content: `## Mencari dengan Cerdas

### Pencarian Linear — O(n)

Memeriksa satu per satu dari awal. Untuk 1.000.000 data, butuh sampai 1.000.000 pemeriksaan.

### Pencarian Biner — O(log n)

Data **harus sudah terurut**. Setiap langkah membuang separuh data.

\`\`\`javascript
function cariBiner(data, target) {
  let kiri = 0;
  let kanan = data.length - 1;

  while (kiri <= kanan) {
    const tengah = Math.floor((kiri + kanan) / 2);
    if (data[tengah] === target) return tengah;
    if (data[tengah] < target) kiri = tengah + 1;
    else kanan = tengah - 1;
  }
  return -1;
}
\`\`\`

Untuk 1.000.000 data, pencarian biner hanya butuh sekitar **20 pemeriksaan**.

### Perbandingan

| Jumlah data | Linear | Biner |
| --- | --- | --- |
| 100 | 100 | 7 |
| 10.000 | 10.000 | 14 |
| 1.000.000 | 1.000.000 | 20 |

### Latihan

Mengapa pencarian biner memerlukan data yang sudah terurut? Apa yang terjadi jika data tidak terurut?`,
          },
        ],
      },
    ],
  },
];

// ---------------------------------------------------------------------------
// Coding projects
// ---------------------------------------------------------------------------

const CODING_PROJECTS = [
  {
    title: "Hitung Luas Persegi Panjang",
    description: "Buat fungsi yang menghitung luas persegi panjang dari panjang dan lebar.",
    brief:
      "Fungsi `luasPersegiPanjang(panjang, lebar)` harus mengembalikan hasil perkalian kedua argumen.",
    language: "JAVASCRIPT" as const,
    difficulty: "BEGINNER" as const,
    xpReward: 40,
    starterCode: `// Lengkapi fungsi berikut
function luasPersegiPanjang(panjang, lebar) {
  // tulis kode di sini

}

console.log(luasPersegiPanjang(5, 3)); // seharusnya 15
`,
    solutionCode: `function luasPersegiPanjang(panjang, lebar) {
  return panjang * lebar;
}
`,
    hints: [
      "Gunakan operator perkalian (*).",
      "Jangan lupa kata kunci return agar hasilnya bisa dipakai.",
    ],
    tests: [
      { name: "Luas 5 × 3 = 15", test: "assertEqual(luasPersegiPanjang(5, 3), 15);" },
      { name: "Luas 10 × 10 = 100", test: "assertEqual(luasPersegiPanjang(10, 10), 100);" },
      { name: "Luas 1 × 7 = 7", test: "assertEqual(luasPersegiPanjang(1, 7), 7);" },
    ],
    skills: ["javascript-dasar", "problem-solving"],
  },
  {
    title: "Cek Bilangan Genap",
    description: "Tentukan apakah sebuah bilangan genap atau ganjil.",
    brief: "Fungsi `adalahGenap(angka)` mengembalikan `true` bila angka genap, `false` bila ganjil.",
    language: "JAVASCRIPT" as const,
    difficulty: "BEGINNER" as const,
    xpReward: 40,
    starterCode: `function adalahGenap(angka) {
  // gunakan operator modulo (%)

}

console.log(adalahGenap(4));  // true
console.log(adalahGenap(7));  // false
`,
    solutionCode: `function adalahGenap(angka) {
  return angka % 2 === 0;
}
`,
    hints: [
      "Operator % (modulo) menghasilkan sisa pembagian.",
      "Bilangan genap habis dibagi 2, artinya sisa baginya 0.",
    ],
    tests: [
      { name: "4 adalah genap", test: "assertEqual(adalahGenap(4), true);" },
      { name: "7 bukan genap", test: "assertEqual(adalahGenap(7), false);" },
      { name: "0 adalah genap", test: "assertEqual(adalahGenap(0), true);" },
      { name: "101 bukan genap", test: "assertEqual(adalahGenap(101), false);" },
    ],
    skills: ["javascript-dasar", "logika-boolean"],
  },
  {
    title: "Jumlahkan Semua Angka dalam Array",
    description: "Hitung total dari semua angka di dalam sebuah array.",
    brief: "Fungsi `jumlahkan(angka)` menerima array angka dan mengembalikan totalnya.",
    language: "JAVASCRIPT" as const,
    difficulty: "BEGINNER" as const,
    xpReward: 50,
    starterCode: `function jumlahkan(angka) {
  // gunakan perulangan untuk menjumlahkan

}

console.log(jumlahkan([1, 2, 3, 4])); // 10
`,
    solutionCode: `function jumlahkan(angka) {
  let total = 0;
  for (let i = 0; i < angka.length; i++) {
    total += angka[i];
  }
  return total;
}
`,
    hints: [
      "Siapkan variabel penampung dengan nilai awal 0.",
      "Tambahkan setiap elemen array ke variabel penampung.",
    ],
    tests: [
      { name: "[1,2,3,4] = 10", test: "assertEqual(jumlahkan([1, 2, 3, 4]), 10);" },
      { name: "Array kosong = 0", test: "assertEqual(jumlahkan([]), 0);" },
      { name: "Angka negatif", test: "assertEqual(jumlahkan([5, -3, 2]), 4);" },
      { name: "Nilai besar", test: "assertEqual(jumlahkan([100, 200, 300]), 600);" },
    ],
    skills: ["javascript-dasar", "array", "perulangan"],
  },
  {
    title: "Balik Sebuah Kata",
    description: "Balik urutan karakter dalam sebuah string.",
    brief: "Fungsi `balikKata(kata)` mengembalikan string dengan urutan karakter terbalik.",
    language: "JAVASCRIPT" as const,
    difficulty: "INTERMEDIATE" as const,
    xpReward: 60,
    starterCode: `function balikKata(kata) {
  // petunjuk: string bisa dipecah menjadi array karakter

}

console.log(balikKata("robot")); // "tobor"
`,
    solutionCode: `function balikKata(kata) {
  return kata.split("").reverse().join("");
}
`,
    hints: [
      "String bisa dipecah dengan .split('')",
      "Array bisa dibalik dengan .reverse() lalu disatukan lagi dengan .join('')",
    ],
    tests: [
      { name: "robot → tobor", test: 'assertEqual(balikKata("robot"), "tobor");' },
      { name: "kasur → rusak", test: 'assertEqual(balikKata("kasur"), "rusak");' },
      { name: "Satu huruf", test: 'assertEqual(balikKata("a"), "a");' },
      { name: "String kosong", test: 'assertEqual(balikKata(""), "");' },
    ],
    skills: ["javascript-dasar", "string"],
  },
  {
    title: "Cari Nilai Tertinggi",
    description: "Temukan angka terbesar dalam sebuah array tanpa menggunakan Math.max.",
    brief: "Fungsi `tertinggi(angka)` mengembalikan angka terbesar. Array dijamin tidak kosong.",
    language: "JAVASCRIPT" as const,
    difficulty: "INTERMEDIATE" as const,
    xpReward: 60,
    starterCode: `function tertinggi(angka) {
  // anggap elemen pertama sebagai kandidat terbesar,
  // lalu bandingkan dengan sisanya

}

console.log(tertinggi([3, 9, 2, 7])); // 9
`,
    solutionCode: `function tertinggi(angka) {
  let max = angka[0];
  for (let i = 1; i < angka.length; i++) {
    if (angka[i] > max) max = angka[i];
  }
  return max;
}
`,
    hints: [
      "Mulai dari elemen pertama sebagai nilai tertinggi sementara.",
      "Bandingkan setiap elemen berikutnya; ganti bila lebih besar.",
    ],
    tests: [
      { name: "[3,9,2,7] = 9", test: "assertEqual(tertinggi([3, 9, 2, 7]), 9);" },
      { name: "Satu elemen", test: "assertEqual(tertinggi([42]), 42);" },
      { name: "Semua negatif", test: "assertEqual(tertinggi([-5, -1, -9]), -1);" },
      { name: "Nilai terbesar di akhir", test: "assertEqual(tertinggi([1, 2, 3, 100]), 100);" },
    ],
    skills: ["array", "perulangan", "problem-solving"],
  },
  {
    title: "Deret Fibonacci",
    description: "Hasilkan deret Fibonacci sebanyak n angka.",
    brief: "Fungsi `fibonacci(n)` mengembalikan array berisi n angka pertama deret Fibonacci.",
    language: "JAVASCRIPT" as const,
    difficulty: "INTERMEDIATE" as const,
    xpReward: 70,
    starterCode: `function fibonacci(n) {
  // deret: 0, 1, 1, 2, 3, 5, 8, ...
  // setiap angka adalah jumlah dua angka sebelumnya

}

console.log(fibonacci(6)); // [0, 1, 1, 2, 3, 5]
`,
    solutionCode: `function fibonacci(n) {
  const hasil = [];
  for (let i = 0; i < n; i++) {
    if (i < 2) hasil.push(i);
    else hasil.push(hasil[i - 1] + hasil[i - 2]);
  }
  return hasil;
}
`,
    hints: [
      "Dua angka pertama adalah 0 dan 1.",
      "Angka ke-i adalah jumlah angka ke-(i-1) dan ke-(i-2).",
    ],
    tests: [
      { name: "6 angka pertama", test: "assertEqual(fibonacci(6), [0,1,1,2,3,5]);" },
      { name: "1 angka", test: "assertEqual(fibonacci(1), [0]);" },
      { name: "2 angka", test: "assertEqual(fibonacci(2), [0,1]);" },
      { name: "10 angka", test: "assertEqual(fibonacci(10), [0,1,1,2,3,5,8,13,21,34]);" },
    ],
    skills: ["perulangan", "array", "algoritma"],
  },
  {
    title: "Deteksi Palindrom",
    description: "Periksa apakah sebuah kata merupakan palindrom.",
    brief:
      "Fungsi `isPalindrom(kata)` mengembalikan `true` bila kata dibaca sama dari depan maupun belakang. Abaikan perbedaan huruf besar/kecil.",
    language: "JAVASCRIPT" as const,
    difficulty: "INTERMEDIATE" as const,
    xpReward: 70,
    starterCode: `function isPalindrom(kata) {
  // ubah ke huruf kecil dulu agar "Kasur" dan "kasur" dianggap sama

}

console.log(isPalindrom("kasur rusak")); // true
`,
    solutionCode: `function isPalindrom(kata) {
  const bersih = kata.toLowerCase();
  const terbalik = bersih.split("").reverse().join("");
  return bersih === terbalik;
}
`,
    hints: [
      "Gunakan .toLowerCase() untuk menyeragamkan huruf.",
      "Bandingkan kata asli dengan versi terbaliknya.",
    ],
    tests: [
      { name: "kasur rusak", test: 'assertEqual(isPalindrom("kasur rusak"), true);' },
      { name: "robot", test: 'assertEqual(isPalindrom("robot"), false);' },
      { name: "Huruf besar", test: 'assertEqual(isPalindrom("Katak"), true);' },
      { name: "satu huruf", test: 'assertEqual(isPalindrom("a"), true);' },
    ],
    skills: ["string", "logika-boolean"],
  },
  {
    title: "Konversi Suhu",
    description: "Konversi Celsius ke Fahrenheit dan Kelvin.",
    brief:
      "Buat `celsiusKeFahrenheit(c)` dan `celsiusKeKelvin(c)`. Bulatkan hasil Kelvin ke bilangan bulat terdekat.",
    language: "PYTHON" as const,
    difficulty: "BEGINNER" as const,
    xpReward: 50,
    starterCode: `def celsius_ke_fahrenheit(c):
    # rumus: (c * 9/5) + 32
    pass

def celsius_ke_kelvin(c):
    # rumus: c + 273.15, bulatkan dengan round()
    pass

print(celsius_ke_fahrenheit(100))  # 212.0
print(celsius_ke_kelvin(100))      # 373
`,
    solutionCode: `def celsius_ke_fahrenheit(c):
    return (c * 9 / 5) + 32

def celsius_ke_kelvin(c):
    return round(c + 273.15)
`,
    hints: ["Gunakan round() untuk membulatkan.", "Perhatikan urutan operasi matematika."],
    tests: [
      { name: "100°C = 212°F", test: "assertEqual(celsius_ke_fahrenheit(100), 212.0)" },
      { name: "0°C = 32°F", test: "assertEqual(celsius_ke_fahrenheit(0), 32.0)" },
      { name: "100°C = 373K", test: "assertEqual(celsius_ke_kelvin(100), 373)" },
      { name: "0°C = 273K", test: "assertEqual(celsius_ke_kelvin(0), 273)" },
    ],
    skills: ["python-dasar", "problem-solving"],
  },
  {
    title: "Hitung Huruf Vokal",
    description: "Hitung jumlah huruf vokal dalam sebuah kalimat.",
    brief:
      "Fungsi `hitung_vokal(teks)` mengembalikan jumlah huruf vokal (a, i, u, e, o) dalam teks.",
    language: "PYTHON" as const,
    difficulty: "INTERMEDIATE" as const,
    xpReward: 70,
    starterCode: `def hitung_vokal(teks):
    # vokal: a, i, u, e, o
    # ubah teks ke huruf kecil dulu

    return 0

print(hitung_vokal("robot pintar"))  # 4
`,
    solutionCode: `def hitung_vokal(teks):
    vokal = "aiueo"
    jumlah = 0
    for huruf in teks.lower():
        if huruf in vokal:
            jumlah += 1
    return jumlah
`,
    hints: [
      "Gunakan .lower() agar huruf besar ikut terhitung.",
      "Gunakan operator 'in' untuk memeriksa keanggotaan.",
    ],
    tests: [
      { name: "robot pintar = 4", test: 'assertEqual(hitung_vokal("robot pintar"), 4)' },
      { name: "kosong = 0", test: 'assertEqual(hitung_vokal(""), 0)' },
      { name: "huruf besar", test: 'assertEqual(hitung_vokal("AIUEO"), 5)' },
      { name: "tanpa vokal", test: 'assertEqual(hitung_vokal("xyz"), 0)' },
    ],
    skills: ["python-dasar", "string", "perulangan"],
  },
];

// ---------------------------------------------------------------------------
// Simulator challenges
// ---------------------------------------------------------------------------

const SIMULATOR_CHALLENGES = [
  {
    slug: "lorong-pertama",
    title: "Lorong Pertama",
    description:
      "Robot berada di ujung kiri sebuah lorong. Gerakkan robot lurus ke kanan sampai mencapai bendera tujuan.",
    difficulty: "BEGINNER" as const,
    gridWidth: 8,
    gridHeight: 5,
    walls: [] as [number, number][],
    startX: 0,
    startY: 2,
    startDir: "east",
    goalX: 7,
    goalY: 2,
    stars: [] as [number, number][],
    maxSteps: 30,
    xpReward: 30,
    starterCode: `// Gerakkan robot ke kanan sampai mencapai tujuan
// Gunakan repeat() agar lebih ringkas

move()
move()
`,
    solutionCode: `repeat(7) {
  move()
}`,
    hints: ["Jarak dari (0,2) ke (7,2) adalah 7 langkah.", "Gunakan repeat(7) { move() }."],
  },
  {
    slug: "tikungan-sederhana",
    title: "Tikungan Sederhana",
    description: "Robot harus berbelok untuk mencapai tujuan. Perhatikan arah hadap robot.",
    difficulty: "BEGINNER" as const,
    gridWidth: 8,
    gridHeight: 8,
    walls: [] as [number, number][],
    startX: 0,
    startY: 0,
    startDir: "east",
    goalX: 6,
    goalY: 5,
    stars: [] as [number, number][],
    maxSteps: 40,
    xpReward: 40,
    starterCode: `// Bergerak ke kanan, lalu berbelok dan bergerak ke bawah
move()
`,
    solutionCode: `repeat(6) {
  move()
}
turnRight()
repeat(5) {
  move()
}`,
    hints: [
      "Menghadap timur, robot perlu berputar ke selatan (turnRight).",
      "Total: 6 langkah ke kanan, lalu 5 langkah ke bawah.",
    ],
  },
  {
    slug: "ambil-bintang",
    title: "Ambil Bintang",
    description:
      "Ada dua bintang di sepanjang jalur. Robot harus mengambil keduanya sebelum mencapai tujuan.",
    difficulty: "INTERMEDIATE" as const,
    gridWidth: 9,
    gridHeight: 6,
    walls: [] as [number, number][],
    startX: 0,
    startY: 3,
    startDir: "east",
    goalX: 8,
    goalY: 3,
    stars: [
      [2, 3],
      [6, 3],
    ] as [number, number][],
    maxSteps: 40,
    xpReward: 60,
    starterCode: `// Gunakan pick() saat robot berada di atas bintang
move()
move()
pick()
`,
    solutionCode: `repeat(8) {
  move()
  if (starHere()) {
    pick()
  }
}`,
    hints: [
      "Gunakan if (starHere()) { pick() } agar aman di semua posisi.",
      "Robot hanya bisa mengambil bintang di posisi tempat ia berdiri.",
    ],
  },
  {
    slug: "hindari-dinding",
    title: "Hindari Dinding",
    description:
      "Sebuah dinding menghalangi jalur lurus. Robot harus memutari dinding untuk sampai ke tujuan.",
    difficulty: "INTERMEDIATE" as const,
    gridWidth: 9,
    gridHeight: 7,
    walls: [
      [4, 0],
      [4, 1],
      [4, 2],
      [4, 4],
      [4, 5],
      [4, 6],
    ] as [number, number][],
    startX: 0,
    startY: 3,
    startDir: "east",
    goalX: 8,
    goalY: 3,
    stars: [] as [number, number][],
    maxSteps: 50,
    xpReward: 70,
    starterCode: `// Ada celah di tengah dinding (baris 3)
repeat(4) {
  move()
}
`,
    solutionCode: `repeat(8) {
  if (canMove()) {
    move()
  } else {
    turnRight()
    move()
    turnLeft()
  }
}`,
    hints: [
      "Dinding di kolom 4 hanya terbuka di baris 3.",
      "Gunakan if (canMove()) untuk memeriksa jalur sebelum bergerak.",
    ],
  },
  {
    slug: "pola-zigzag",
    title: "Pola Zigzag",
    description:
      "Robot harus bergerak menyerupai tangga: maju, naik, maju, naik, sampai mencapai tujuan.",
    difficulty: "INTERMEDIATE" as const,
    gridWidth: 9,
    gridHeight: 9,
    walls: [] as [number, number][],
    startX: 0,
    startY: 0,
    startDir: "east",
    goalX: 8,
    goalY: 8,
    stars: [] as [number, number][],
    maxSteps: 60,
    xpReward: 70,
    starterCode: `// Pola: maju 1, turun 1, ulangi
// Hadap timur → berputar ke selatan = turnRight
`,
    solutionCode: `repeat(8) {
  move()
  turnRight()
  move()
  turnLeft()
}`,
    hints: [
      "Setelah maju ke kanan, robot perlu menghadap ke bawah.",
      "Jangan lupa mengembalikan arah hadap ke timur sebelum maju lagi.",
    ],
  },
  {
    slug: "kumpulkan-semua",
    title: "Kumpulkan Semua Bintang",
    description:
      "Empat bintang tersebar di grid. Gunakan kondisi dan perulangan untuk mengambil semuanya lalu menuju tujuan.",
    difficulty: "ADVANCED" as const,
    gridWidth: 10,
    gridHeight: 8,
    walls: [
      [3, 3],
      [3, 4],
      [6, 2],
      [6, 3],
    ] as [number, number][],
    startX: 0,
    startY: 0,
    startDir: "east",
    goalX: 9,
    goalY: 7,
    stars: [
      [2, 0],
      [5, 0],
      [2, 5],
      [8, 5],
    ] as [number, number][],
    maxSteps: 90,
    xpReward: 100,
    starterCode: `// Tantangan tersulit!
// Rencanakan rute: ambil bintang satu per satu
`,
    solutionCode: `repeat(2) {
  move()
}
pick()
repeat(3) {
  move()
}
pick()
turnRight()
repeat(5) {
  move()
}
turnLeft()
repeat(3) {
  move()
}
pick()
turnLeft()
repeat(6) {
  move()
}
turnRight()
repeat(3) {
  move()
}
pick()
repeat(2) {
  move()
}
turnRight()
repeat(2) {
  move()
}`,
    hints: [
      "Rencanakan rute di atas kertas terlebih dahulu.",
      "Gunakan pick() tepat saat robot berada di posisi bintang.",
      "Perhatikan dinding di kolom 3 dan 6.",
    ],
  },
];

// ---------------------------------------------------------------------------
// Skills & achievements
// ---------------------------------------------------------------------------

const SKILLS = [
  { name: "Dasar JavaScript", slug: "javascript-dasar", category: "programming", icon: "Braces", color: "#f59e0b", description: "Variabel, tipe data, fungsi, dan sintaks dasar JavaScript." },
  { name: "Python Dasar", slug: "python-dasar", category: "programming", icon: "FileCode2", color: "#3b82f6", description: "Sintaks Python, struktur kontrol, dan pengolahan data." },
  { name: "Struktur Data", slug: "array", category: "programming", icon: "List", color: "#8b5cf6", description: "Array, list, dan cara mengolah kumpulan data." },
  { name: "Perulangan", slug: "perulangan", category: "programming", icon: "Repeat", color: "#06b6d4", description: "for, while, dan teknik iterasi yang efisien." },
  { name: "Pengolahan Teks", slug: "string", category: "programming", icon: "Type", color: "#ec4899", description: "Manipulasi string, pencarian, dan transformasi teks." },
  { name: "Logika Boolean", slug: "logika-boolean", category: "computational-thinking", icon: "ToggleLeft", color: "#10b981", description: "Operator logika, perbandingan, dan pengambilan keputusan." },
  { name: "Pemecahan Masalah", slug: "problem-solving", category: "computational-thinking", icon: "Lightbulb", color: "#eab308", description: "Mengurai masalah kompleks menjadi langkah yang dapat diselesaikan." },
  { name: "Algoritma", slug: "algoritma", category: "computational-thinking", icon: "GitBranch", color: "#6366f1", description: "Perancangan langkah penyelesaian dan analisis efisiensi." },
  { name: "Robotika", slug: "robotika", category: "robotics", icon: "Bot", color: "#ef4444", description: "Sensor, aktuator, dan pengendalian robot." },
  { name: "Elektronika", slug: "elektronika", category: "robotics", icon: "CircuitBoard", color: "#14b8a6", description: "Rangkaian dasar, tegangan, arus, dan komponen elektronik." },
];

const ACHIEVEMENTS = [
  { code: "first-steps", name: "Langkah Pertama", description: "Menyelesaikan pelajaran pertamamu.", icon: "Footprints", xpReward: 50, tier: "bronze" },
  { code: "lesson-enthusiast", name: "Rajin Belajar", description: "Menyelesaikan 10 pelajaran.", icon: "BookOpen", xpReward: 150, tier: "silver" },
  { code: "lesson-master", name: "Master Pelajaran", description: "Menyelesaikan 30 pelajaran.", icon: "GraduationCap", xpReward: 400, tier: "gold" },
  { code: "first-submission", name: "Tugas Pertama", description: "Mengumpulkan tugas pertamamu.", icon: "Send", xpReward: 50, tier: "bronze" },
  { code: "consistent-worker", name: "Pekerja Konsisten", description: "Mengumpulkan 15 tugas.", icon: "ClipboardCheck", xpReward: 250, tier: "silver" },
  { code: "first-code", name: "Halo, Kode!", description: "Lulus tantangan coding pertamamu.", icon: "Code2", xpReward: 75, tier: "bronze" },
  { code: "code-warrior", name: "Pejuang Kode", description: "Lulus 10 tantangan coding.", icon: "Sword", xpReward: 350, tier: "gold" },
  { code: "robot-whisperer", name: "Pawang Robot", description: "Menuntaskan 5 tantangan simulator.", icon: "Bot", xpReward: 300, tier: "gold" },
  { code: "skill-collector", name: "Kolektor Keterampilan", description: "Membuka 5 keterampilan.", icon: "Sparkles", xpReward: 200, tier: "silver" },
  { code: "level-5", name: "Level 5", description: "Mencapai level 5.", icon: "Star", xpReward: 200, tier: "silver" },
  { code: "level-10", name: "Level 10", description: "Mencapai level 10.", icon: "Crown", xpReward: 500, tier: "platinum" },
  { code: "course-complete", name: "Tuntas Satu Kursus", description: "Menyelesaikan satu kursus penuh.", icon: "Trophy", xpReward: 400, tier: "gold" },
  { code: "perfect-attendance", name: "Hadir Terus", description: "Mencatat 20 kehadiran.", icon: "CalendarCheck", xpReward: 150, tier: "silver" },
];

// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------

async function main() {
  console.log("🌱 Seeding RoboLearn…\n");

  const passwordHash = await hashPassword(SEED_PASSWORD);
  console.log(`   password hash ready (Argon2id)`);

  // --- settings -----------------------------------------------------------
  await prisma.systemSetting.upsert({
    where: { key: "platform" },
    create: {
      key: "platform",
      value: {
        name: "RoboLearn",
        tagline: "Belajar robotika dan pemrograman dengan cara yang menyenangkan",
        academicYear: "2025/2026",
        defaultPassingScore: 75,
        xpPerLesson: 25,
      },
    },
    update: {},
  });

  // --- users --------------------------------------------------------------
  const users = new Map<string, string>();

  for (const staff of STAFF) {
    const user = await prisma.user.upsert({
      where: { username: staff.username },
      create: {
        username: staff.username,
        passwordHash,
        fullName: staff.fullName,
        email: staff.email,
        role: staff.role,
        status: "ACTIVE",
        school: staff.school,
        bio: staff.bio,
        xp: staff.role === "ADMIN" ? 4200 : 2800,
      },
      update: {
        fullName: staff.fullName,
        email: staff.email,
        role: staff.role,
        bio: staff.bio,
        // Kept in sync so changing SEED_DEFAULT_PASSWORD actually rotates the
        // password of an account that already exists.
        passwordHash,
      },
    });
    users.set(staff.username, user.id);
  }

  for (const [username, fullName, gradeLevel] of STUDENTS) {
    const user = await prisma.user.upsert({
      where: { username },
      create: {
        username,
        passwordHash,
        fullName,
        email: `${username}@siswa.robolearn.sch.id`,
        role: "STUDENT",
        status: "ACTIVE",
        school: "SMP Negeri 1 Bandung",
        gradeLevel,
      },
      update: { fullName, gradeLevel, passwordHash },
    });
    users.set(username, user.id);
  }

  console.log(`   ✓ ${users.size} pengguna`);

  // --- skills & achievements ---------------------------------------------
  const skillIds = new Map<string, string>();
  const achievementIds = new Map<string, string>();
  for (const [index, skill] of SKILLS.entries()) {
    const row = await prisma.skill.upsert({
      where: { slug: skill.slug },
      create: { ...skill, orderIndex: index },
      update: { name: skill.name, description: skill.description, icon: skill.icon, color: skill.color },
    });
    skillIds.set(skill.slug, row.id);
  }
  for (const achievement of ACHIEVEMENTS) {
    const row = await prisma.achievement.upsert({
      where: { code: achievement.code },
      create: achievement,
      update: {
        name: achievement.name,
        description: achievement.description,
        icon: achievement.icon,
        xpReward: achievement.xpReward,
        tier: achievement.tier,
      },
    });
    achievementIds.set(achievement.code, row.id);
  }
  console.log(`   ✓ ${SKILLS.length} keterampilan, ${ACHIEVEMENTS.length} pencapaian`);

  // --- classrooms ---------------------------------------------------------
  const classrooms = [
    { name: "Robotika 7A", code: "RBT-7A", joinCode: "RBT7A", teacher: "budi.santoso", gradeLevel: "7A", room: "Lab Komputer 1" },
    { name: "Robotika 7B", code: "RBT-7B", joinCode: "RBT7B", teacher: "budi.santoso", gradeLevel: "7B", room: "Lab Komputer 1" },
    { name: "Coding 8A", code: "CDG-8A", joinCode: "CDG8A", teacher: "sari.dewi", gradeLevel: "8A", room: "Lab Komputer 2" },
    { name: "Coding 8B", code: "CDG-8B", joinCode: "CDG8B", teacher: "sari.dewi", gradeLevel: "8B", room: "Lab Komputer 2" },
  ];

  const classIds = new Map<string, string>();
  for (const classroom of classrooms) {
    const row = await prisma.classroom.upsert({
      where: { code: classroom.code },
      create: {
        name: classroom.name,
        code: classroom.code,
        joinCode: classroom.joinCode,
        description: `Kelas ${classroom.name} tahun ajaran 2025/2026.`,
        academicYear: "2025/2026",
        gradeLevel: classroom.gradeLevel,
        room: classroom.room,
        teacherId: users.get(classroom.teacher)!,
      },
      update: { name: classroom.name, joinCode: classroom.joinCode, teacherId: users.get(classroom.teacher)! },
    });
    classIds.set(classroom.code, row.id);
  }

  // Enrol every student into the classroom matching their grade level.
  let enrollmentCount = 0;
  for (const [username, , gradeLevel] of STUDENTS) {
    const match = classrooms.find((c) => c.gradeLevel === gradeLevel);
    if (!match) continue;
    await prisma.classEnrollment.upsert({
      where: {
        classId_studentId: { classId: classIds.get(match.code)!, studentId: users.get(username)! },
      },
      create: {
        classId: classIds.get(match.code)!,
        studentId: users.get(username)!,
        status: "ACTIVE",
      },
      update: {},
    });
    enrollmentCount += 1;
  }
  console.log(`   ✓ ${classrooms.length} kelas, ${enrollmentCount} pendaftaran kelas`);

  // --- courses, modules, lessons -----------------------------------------
  const lessonIds = new Map<string, string>();
  const courseIds = new Map<string, string>();
  let moduleTotal = 0;
  let lessonTotal = 0;

  for (const [courseIndex, course] of COURSES.entries()) {
    const slug = slugify(course.title);
    const teacherId = users.get(course.teacher)!;
    const classroomCode = course.teacher === "budi.santoso"
      ? course.tags.includes("proyek") ? "RBT-7A" : "RBT-7A"
      : "CDG-8A";

    const row = await prisma.course.upsert({
      where: { slug },
      create: {
        title: course.title,
        slug,
        summary: course.summary,
        description: course.description,
        level: course.level,
        language: course.language,
        status: "PUBLISHED",
        estimatedHours: course.hours,
        coverColor: course.color,
        tags: course.tags,
        orderIndex: courseIndex,
        teacherId,
        classroomId: classIds.get(classroomCode)!,
        publishedAt: daysAgo(60),
      },
      update: {
        title: course.title,
        summary: course.summary,
        description: course.description,
        status: "PUBLISHED",
        coverColor: course.color,
        tags: course.tags,
      },
    });
    courseIds.set(slug, row.id);

    for (const [moduleIndex, module] of course.modules.entries()) {
      // Modules have no natural unique key, so match on (courseId, title).
      const existing = await prisma.module.findFirst({
        where: { courseId: row.id, title: module.title },
      });
      const moduleRow = existing
        ? await prisma.module.update({
            where: { id: existing.id },
            data: { description: module.description, orderIndex: moduleIndex },
          })
        : await prisma.module.create({
            data: {
              courseId: row.id,
              title: module.title,
              description: module.description,
              orderIndex: moduleIndex,
            },
          });
      moduleTotal += 1;

      for (const [lessonIndex, lesson] of module.lessons.entries()) {
        const lessonSlug = slugify(lesson.title);
        const lessonRow = await prisma.lesson.upsert({
          where: { courseId_slug: { courseId: row.id, slug: lessonSlug } },
          create: {
            courseId: row.id,
            moduleId: moduleRow.id,
            title: lesson.title,
            slug: lessonSlug,
            summary: lesson.summary,
            content: lesson.content,
            type: lesson.type,
            durationMinutes: lesson.minutes,
            orderIndex: lessonIndex,
            status: "PUBLISHED",
            objectives: lesson.objectives,
            isPreview: lessonIndex === 0,
          },
          update: {
            title: lesson.title,
            content: lesson.content,
            summary: lesson.summary,
            type: lesson.type,
            objectives: lesson.objectives,
            moduleId: moduleRow.id,
          },
        });
        lessonIds.set(`${slug}::${lessonSlug}`, lessonRow.id);
        lessonTotal += 1;
      }
    }
  }
  console.log(`   ✓ ${COURSES.length} kursus, ${moduleTotal} modul, ${lessonTotal} pelajaran`);

  // --- course enrollment --------------------------------------------------
  for (const [username, , gradeLevel] of STUDENTS) {
    // Students take the beginner courses plus the one matching their grade.
    const targets = COURSES.filter((course) => {
      if (gradeLevel.startsWith("7")) return course.level !== "ADVANCED";
      return true;
    });
    for (const course of targets) {
      const courseId = courseIds.get(slugify(course.title))!;
      await prisma.courseEnrollment.upsert({
        where: { courseId_studentId: { courseId, studentId: users.get(username)! } },
        create: {
          courseId,
          studentId: users.get(username)!,
          status: "ACTIVE",
          enrolledAt: daysAgo(randomInt(30, 55)),
        },
        update: {},
      });
    }
  }
  console.log(`   ✓ pendaftaran kursus`);

  // --- lesson progress ----------------------------------------------------
  // Ordered by (orderIndex, id): orderIndex ties across modules, and without a
  // stable tiebreaker the row order — and therefore which lessons are marked
  // complete below — would change between runs.
  const allLessons = await prisma.lesson.findMany({
    select: { id: true, courseId: true },
    orderBy: [{ orderIndex: "asc" }, { id: "asc" }],
  });
  let progressCount = 0;
  let completedCount = 0;

  for (const [username] of STUDENTS) {
    const studentId = users.get(username)!;
    const enrollments = await prisma.courseEnrollment.findMany({
      where: { studentId },
      select: { courseId: true },
    });
    const enrolledCourseIds = new Set(enrollments.map((e) => e.courseId));

    // Each student advances a different distance through each course. Derived
    // from (student, course) so the same lessons are completed on every run —
    // otherwise this loop alone grows lessonProgress and the XP ledger.
    //
    // The range must exceed 1.0: `toComplete` uses Math.floor, so a ratio that
    // caps at exactly 1.0 would only ever complete every lesson when the draw
    // hit the maximum, leaving essentially no student eligible for a course
    // certificate. Reaching ~1.15 means roughly one student in five finishes,
    // which is what the certificates page needs to have anything to show.
    for (const courseId of enrolledCourseIds) {
      const courseLessons = allLessons.filter((l) => l.courseId === courseId);
      const completionRatio = 0.3 + hashInt(`${username}|${courseId}|ratio`, 0, 85) / 100;
      const toComplete = Math.min(courseLessons.length, Math.floor(courseLessons.length * completionRatio));

      for (const [index, lesson] of courseLessons.entries()) {
        const done = index < toComplete;
        const inProgress = !done && index === toComplete && hashChance(`${username}|${lesson.id}|inprogress`, 0.5);
        if (!done && !inProgress) continue;

        await prisma.lessonProgress.upsert({
          where: { lessonId_studentId: { lessonId: lesson.id, studentId } },
          create: {
            lessonId: lesson.id,
            studentId,
            status: done ? "COMPLETED" : "IN_PROGRESS",
            progressPercent: done ? 100 : hashInt(`${username}|${lesson.id}|pct`, 15, 80),
            timeSpentSeconds: hashInt(`${username}|${lesson.id}|time`, 300, 2400),
            lastViewedAt: daysAgo(hashInt(`${username}|${lesson.id}|viewed`, 1, 25)),
            completedAt: done ? daysAgo(hashInt(`${username}|${lesson.id}|done`, 1, 25)) : null,
          },
          // Derived values, so re-running writes the same row rather than
          // growing anything — but it must write them: a lesson that is now
          // complete has to move off IN_PROGRESS, or the course never reaches
          // 100% and no certificate is ever earned.
          update: {
            status: done ? "COMPLETED" : "IN_PROGRESS",
            progressPercent: done ? 100 : hashInt(`${username}|${lesson.id}|pct`, 15, 80),
            completedAt: done ? daysAgo(hashInt(`${username}|${lesson.id}|done`, 1, 25)) : null,
          },
        });
        progressCount += 1;
        if (done) completedCount += 1;
      }
    }
  }
  console.log(`   ✓ ${progressCount} catatan progres (${completedCount} pelajaran selesai)`);

  // --- assignments --------------------------------------------------------
  interface AssignmentSeed {
    courseSlug: string;
    lessonSlug?: string;
    title: string;
    description: string;
    type: "HOMEWORK" | "PROJECT" | "QUIZ" | "CODING" | "EXAM";
    maxScore: number;
    weight: number;
    dueInDays: number;
    status: "DRAFT" | "PUBLISHED";
    quiz?: {
      passingScore: number;
      timeLimitMinutes: number;
      questions: {
        prompt: string;
        type: "MULTIPLE_CHOICE" | "MULTI_SELECT" | "TRUE_FALSE" | "SHORT_ANSWER";
        options?: string[];
        correctAnswer: unknown;
        explanation: string;
        points: number;
      }[];
    };
  }

  const assignmentSeeds: AssignmentSeed[] = [
    {
      courseSlug: "dasar-computational-thinking",
      lessonSlug: "kuis-pilar-computational-thinking",
      title: "Kuis: Pilar Computational Thinking",
      description: "Kuis pilihan ganda untuk mengukur pemahaman empat pilar computational thinking.",
      type: "QUIZ",
      maxScore: 100,
      weight: 2,
      dueInDays: 7,
      status: "PUBLISHED",
      quiz: {
        passingScore: 70,
        timeLimitMinutes: 20,
        questions: [
          {
            prompt: "Memecah masalah besar menjadi bagian-bagian kecil disebut…",
            type: "MULTIPLE_CHOICE",
            options: ["Abstraksi", "Dekomposisi", "Algoritma", "Pengenalan pola"],
            correctAnswer: 1,
            explanation: "Dekomposisi adalah proses memecah masalah kompleks menjadi sub-masalah yang lebih kecil.",
            points: 20,
          },
          {
            prompt: "Manakah yang termasuk contoh pengenalan pola?",
            type: "MULTIPLE_CHOICE",
            options: [
              "Membagi tugas kelompok menjadi beberapa bagian",
              "Menyadari bahwa setiap soal ujian memiliki format serupa",
              "Menuliskan langkah-langkah membuat teh",
              "Mengabaikan detail yang tidak penting",
            ],
            correctAnswer: 1,
            explanation: "Pengenalan pola berarti menemukan keteraturan atau kesamaan antar masalah.",
            points: 20,
          },
          {
            prompt: "Algoritma harus memiliki urutan langkah yang jelas.",
            type: "TRUE_FALSE",
            options: ["Benar", "Salah"],
            correctAnswer: 0,
            explanation: "Algoritma adalah urutan langkah yang terdefinisi dengan jelas dan berhingga.",
            points: 20,
          },
          {
            prompt: "Menyaring informasi yang tidak relevan agar fokus pada hal penting disebut…",
            type: "SHORT_ANSWER",
            correctAnswer: "abstraksi",
            explanation: "Abstraksi berarti menyaring detail yang tidak perlu.",
            points: 20,
          },
          {
            prompt: "Manakah pernyataan yang benar tentang computational thinking?",
            type: "MULTI_SELECT",
            options: [
              "Hanya berguna untuk programmer",
              "Membantu menyelesaikan masalah sehari-hari",
              "Terdiri dari empat pilar utama",
              "Selalu membutuhkan komputer",
            ],
            correctAnswer: [1, 2],
            explanation: "Computational thinking berguna di banyak bidang dan tidak selalu memerlukan komputer.",
            points: 20,
          },
        ],
      },
    },
    {
      courseSlug: "dasar-computational-thinking",
      title: "Tugas: Analisis Masalah Sehari-hari",
      description:
        "Pilih satu masalah yang kamu hadapi sehari-hari, lalu uraikan menggunakan empat pilar computational thinking. Tulis minimal 300 kata dalam format PDF atau dokumen.",
      type: "HOMEWORK",
      maxScore: 100,
      weight: 1,
      dueInDays: 5,
      status: "PUBLISHED",
    },
    {
      courseSlug: "dasar-computational-thinking",
      title: "Proyek: Flowchart Alur Pendaftaran Ekstrakurikuler",
      description:
        "Buat flowchart lengkap untuk alur pendaftaran ekstrakurikuler di sekolahmu, mulai dari pembukaan pendaftaran hingga pengumuman hasil seleksi. Sertakan minimal dua titik keputusan.",
      type: "PROJECT",
      maxScore: 100,
      weight: 3,
      dueInDays: 14,
      status: "PUBLISHED",
    },
    {
      courseSlug: "pemrograman-javascript-untuk-pemula",
      lessonSlug: "latihan-kalkulator-sederhana",
      title: "Latihan: Kalkulator Sederhana",
      description:
        "Kumpulkan kode kalkulator yang berisi fungsi tambah, kurang, kali, dan bagi. Sertakan penanganan pembagian dengan nol.",
      type: "CODING",
      maxScore: 100,
      weight: 2,
      dueInDays: 4,
      status: "PUBLISHED",
    },
    {
      courseSlug: "pemrograman-javascript-untuk-pemula",
      lessonSlug: "kuis-dasar-javascript",
      title: "Kuis: Dasar JavaScript",
      description: "Kuis untuk memastikan pemahaman variabel, tipe data, dan fungsi.",
      type: "QUIZ",
      maxScore: 100,
      weight: 2,
      dueInDays: 6,
      status: "PUBLISHED",
      quiz: {
        passingScore: 75,
        timeLimitMinutes: 25,
        questions: [
          {
            prompt: "Kata kunci mana yang membuat variabel tidak dapat diubah nilainya?",
            type: "MULTIPLE_CHOICE",
            options: ["let", "var", "const", "static"],
            correctAnswer: 2,
            explanation: "const menetapkan nilai yang tidak dapat diubah setelah inisialisasi.",
            points: 25,
          },
          {
            prompt: 'Apa hasil dari 7 % 3?',
            type: "MULTIPLE_CHOICE",
            options: ["1", "2", "2.33", "0"],
            correctAnswer: 0,
            explanation: "Operator % menghasilkan sisa pembagian. 7 dibagi 3 bersisa 1.",
            points: 25,
          },
          {
            prompt: "Tipe data untuk menyimpan nilai benar atau salah adalah boolean.",
            type: "TRUE_FALSE",
            options: ["Benar", "Salah"],
            correctAnswer: 0,
            explanation: "Boolean hanya memiliki dua nilai: true dan false.",
            points: 25,
          },
          {
            prompt: "Manakah penulisan fungsi yang benar?",
            type: "MULTIPLE_CHOICE",
            options: [
              "function tambah(a, b) { return a + b; }",
              "func tambah(a, b) { return a + b; }",
              "function tambah[a, b] { return a + b; }",
              "def tambah(a, b) { return a + b; }",
            ],
            correctAnswer: 0,
            explanation: "JavaScript menggunakan kata kunci 'function' dengan parameter di dalam tanda kurung.",
            points: 25,
          },
        ],
      },
    },
    {
      courseSlug: "pemrograman-javascript-untuk-pemula",
      title: "Tugas: Program Data Siswa",
      description:
        "Buat program yang menyimpan data minimal lima siswa menggunakan array of objects, lalu tampilkan nama siswa dengan nilai tertinggi beserta rata-rata kelas.",
      type: "HOMEWORK",
      maxScore: 100,
      weight: 2,
      dueInDays: 9,
      status: "PUBLISHED",
    },
    {
      courseSlug: "robotika-dasar-sensor-dan-aktuator",
      lessonSlug: "lab-navigasi-grid",
      title: "Praktikum: Navigasi Grid",
      description:
        "Tuntaskan minimal tiga tantangan di simulator robot, lalu kumpulkan kode program yang kamu gunakan beserta penjelasan singkat strategimu.",
      type: "CODING",
      maxScore: 100,
      weight: 3,
      dueInDays: 10,
      status: "PUBLISHED",
    },
    {
      courseSlug: "robotika-dasar-sensor-dan-aktuator",
      title: "Laporan: Perbandingan Jenis Sensor",
      description:
        "Buat tabel perbandingan minimal empat jenis sensor robot. Untuk setiap sensor, jelaskan prinsip kerja, kelebihan, kekurangan, dan contoh penerapan.",
      type: "HOMEWORK",
      maxScore: 100,
      weight: 1,
      dueInDays: 3,
      status: "PUBLISHED",
    },
    {
      courseSlug: "python-untuk-analisis-data",
      lessonSlug: "lab-analisis-nilai-kelas",
      title: "Tugas: Analisis Nilai Kelas",
      description:
        "Kumpulkan program Python yang menghitung rata-rata, nilai tertinggi, nilai terendah, jumlah siswa di atas rata-rata, dan persentase kelulusan.",
      type: "CODING",
      maxScore: 100,
      weight: 2,
      dueInDays: 8,
      status: "PUBLISHED",
    },
    {
      courseSlug: "proyek-robot-line-follower",
      title: "Proyek Akhir: Robot Line Follower",
      description:
        "Kumpulkan laporan lengkap proyek robot line follower: spesifikasi, sketsa desain, daftar komponen, kode program, data pengujian, dan refleksi.",
      type: "PROJECT",
      maxScore: 100,
      weight: 5,
      dueInDays: 21,
      status: "PUBLISHED",
    },
    {
      courseSlug: "algoritma-dan-struktur-data",
      title: "Ujian Tengah Semester: Algoritma",
      description:
        "Ujian tertulis mencakup analisis kompleksitas, pencarian biner, dan pemilihan struktur data yang tepat.",
      type: "EXAM",
      maxScore: 100,
      weight: 4,
      dueInDays: 12,
      status: "PUBLISHED",
    },
    {
      courseSlug: "algoritma-dan-struktur-data",
      title: "Tugas: Implementasi Pencarian Biner",
      description:
        "Implementasikan fungsi pencarian biner dan bandingkan jumlah langkahnya dengan pencarian linear untuk array berukuran 100, 1000, dan 10000 elemen.",
      type: "HOMEWORK",
      maxScore: 100,
      weight: 2,
      dueInDays: 6,
      status: "PUBLISHED",
    },
  ];

  const assignmentIds: { id: string; seed: AssignmentSeed; courseId: string }[] = [];

  for (const seed of assignmentSeeds) {
    const courseId = courseIds.get(seed.courseSlug);
    if (!courseId) continue;

    const course = COURSES.find((c) => slugify(c.title) === seed.courseSlug)!;
    const teacherId = users.get(course.teacher)!;
    const lessonId = seed.lessonSlug ? lessonIds.get(`${seed.courseSlug}::${seed.lessonSlug}`) : undefined;

    const existing = await prisma.assignment.findFirst({
      where: { courseId, title: seed.title },
    });

    const data = {
      courseId,
      lessonId: lessonId ?? null,
      title: seed.title,
      description: seed.description,
      type: seed.type,
      maxScore: seed.maxScore,
      weight: seed.weight,
      dueAt: daysAhead(seed.dueInDays),
      status: seed.status,
      createdById: teacherId,
    };

    const row = existing
      ? await prisma.assignment.update({ where: { id: existing.id }, data })
      : await prisma.assignment.create({ data });

    assignmentIds.push({ id: row.id, seed, courseId });

    if (seed.quiz) {
      const existingQuiz = await prisma.quiz.findUnique({ where: { assignmentId: row.id } });
      if (existingQuiz) {
        await prisma.quiz.update({
          where: { id: existingQuiz.id },
          data: {
            passingScore: seed.quiz.passingScore,
            timeLimitMinutes: seed.quiz.timeLimitMinutes,
            maxAttempts: 3,
          },
        });

        // Sync questions IN PLACE, keyed by orderIndex.
        //
        // Questions must never be deleted and recreated: `QuizAnswer.questionId`
        // cascades on delete, so recreating a question would silently destroy
        // every recorded answer. Updating the row keeps its id (and its
        // answers) intact.
        for (const [index, question] of seed.quiz.questions.entries()) {
          const questionData = {
            prompt: question.prompt,
            type: question.type,
            options: (question.options ?? []) as Prisma.InputJsonValue,
            correctAnswer: question.correctAnswer as Prisma.InputJsonValue,
            explanation: question.explanation,
            points: question.points,
          };
          const existingQuestion = await prisma.quizQuestion.findFirst({
            where: { quizId: existingQuiz.id, orderIndex: index },
            select: { id: true },
          });
          if (existingQuestion) {
            await prisma.quizQuestion.update({
              where: { id: existingQuestion.id },
              data: questionData,
            });
          } else {
            await prisma.quizQuestion.create({
              data: { ...questionData, quizId: existingQuiz.id, orderIndex: index },
            });
          }
        }

        // Drop only surplus questions beyond the seeded set.
        await prisma.quizQuestion.deleteMany({
          where: { quizId: existingQuiz.id, orderIndex: { gte: seed.quiz.questions.length } },
        });
      } else {
        const quiz = await prisma.quiz.create({
          data: {
            assignmentId: row.id,
            passingScore: seed.quiz.passingScore,
            timeLimitMinutes: seed.quiz.timeLimitMinutes,
            maxAttempts: 3,
            allowRetakes: true,
          },
        });
        for (const [index, question] of seed.quiz.questions.entries()) {
          await prisma.quizQuestion.create({
            data: {
              quizId: quiz.id,
              prompt: question.prompt,
              type: question.type,
              options: (question.options ?? []) as Prisma.InputJsonValue,
              correctAnswer: question.correctAnswer as Prisma.InputJsonValue,
              explanation: question.explanation,
              points: question.points,
              orderIndex: index,
            },
          });
        }
      }
    }
  }
  console.log(`   ✓ ${assignmentIds.length} tugas`);

  // --- submissions & grades ----------------------------------------------
  let submissionCount = 0;
  let gradedCount = 0;

  for (const { id: assignmentId, seed, courseId } of assignmentIds) {
    const enrollments = await prisma.courseEnrollment.findMany({
      where: { courseId },
      select: { studentId: true },
    });

    // Quiz submissions are derived from the student's actual attempt further
    // down, so that the quiz page, the assignment page and the gradebook all
    // report the same score. Generating one here as well would produce two
    // disagreeing numbers for the same student.
    if (seed.type === "QUIZ") continue;

    for (const { studentId } of enrollments) {
      // Decisions are derived from (assignmentId, studentId) rather than the
      // shared RNG stream, so the same students submit on every run.
      const key = `${assignmentId}|${studentId}`;

      // Not every student submits everything — leave a realistic backlog.
      if (hashChance(`${key}|submitted`, 0.12)) continue; // never submitted

      const isGraded = !hashChance(`${key}|graded`, 0.35);
      const score = isGraded
        ? Math.min(seed.maxScore, Math.max(45, Math.round(seed.maxScore * (0.62 + hashInt(`${key}|score`, 0, 38) / 100))))
        : null;
      const submittedAt = daysAgo(hashInt(`${key}|when`, 1, 20));

      await prisma.submission.upsert({
        where: { assignmentId_studentId: { assignmentId, studentId } },
        create: {
          assignmentId,
          studentId,
          content:
            "Berikut hasil pekerjaan saya. Saya sudah mencoba menjalankan program dan memastikan hasilnya sesuai.",
          status: isGraded ? "GRADED" : "SUBMITTED",
          submittedAt,
          isLate: random() < 0.15,
          score,
          feedback: isGraded
            ? pick([
                "Kerja bagus! Struktur kodenya rapi dan mudah dibaca.",
                "Sudah benar, tetapi perhatikan penamaan variabel agar lebih deskriptif.",
                "Hasilnya sesuai. Tingkatkan lagi kerapian indentasi ya.",
                "Analisis sudah tepat. Tambahkan komentar pada bagian yang kompleks.",
                "Bagus! Coba eksplorasi solusi alternatif yang lebih efisien.",
              ])
            : null,
          gradedById: isGraded ? users.get("budi.santoso")! : null,
          gradedAt: isGraded ? daysAgo(randomInt(1, 5)) : null,
        },
        update: {},
      });
      submissionCount += 1;
      if (isGraded) gradedCount += 1;
    }
  }
  console.log(`   ✓ ${submissionCount} pengumpulan (${gradedCount} sudah dinilai)`);

  // --- quiz attempts ------------------------------------------------------
  const quizzes = await prisma.quiz.findMany({
    include: {
      questions: true,
      assignment: {
        select: { id: true, title: true, courseId: true, maxScore: true, dueAt: true },
      },
    },
  });
  let attemptCount = 0;

  for (const quiz of quizzes) {
    const enrollments = await prisma.courseEnrollment.findMany({
      where: { courseId: quiz.assignment.courseId },
      select: { studentId: true },
    });

    for (const { studentId } of enrollments) {
      const attemptKey = `${quiz.id}|${studentId}`;
      if (hashChance(`${attemptKey}|attempted`, 0.3)) continue; // hasn't attempted yet

      const attemptNo = hashChance(`${attemptKey}|second`, 0.2) ? 2 : 1;
      const maxScore = quiz.questions.reduce((sum, q) => sum + q.points, 0);

      // Natural key: (quizId, studentId, attemptNo). Reuse an existing attempt
      // rather than inserting a second one.
      const existingAttempt = await prisma.quizAttempt.findFirst({
        where: { quizId: quiz.id, studentId, attemptNo },
        select: { id: true },
      });

      // Submitted strictly after starting. The two timestamps used to be drawn
      // from independent hashes, so a student could "finish" days before they
      // began — which the staff table then rendered as a duration of 14400
      // minutes. The offset is bounded by the quiz's own time limit when it has
      // one, so the recorded duration is always plausible.
      const startedDaysAgo = hashInt(`${attemptKey}|started`, 2, 18);
      const startedAt = daysAgo(startedDaysAgo, hashInt(`${attemptKey}|hour`, 7, 15));
      const tookMinutes = quiz.timeLimitMinutes
        ? hashInt(`${attemptKey}|took`, 3, Math.max(4, quiz.timeLimitMinutes))
        : hashInt(`${attemptKey}|took`, 4, 35);
      const submittedAt = new Date(startedAt.getTime() + tookMinutes * 60 * 1000);

      const attempt =
        existingAttempt ??
        (await prisma.quizAttempt.create({
          data: {
            quizId: quiz.id,
            studentId,
            startedAt,
            submittedAt,
            attemptNo,
            maxScore,
          },
        }));

      // An attempt created by an earlier seed run keeps its row but gets its
      // timestamps corrected, so a re-seed repairs the durations already stored.
      if (existingAttempt) {
        await prisma.quizAttempt.update({
          where: { id: existingAttempt.id },
          data: { startedAt, submittedAt, maxScore },
        });
      }

      // Answers are upserted on the (attemptId, questionId) unique key, which
      // keeps this idempotent and also self-heals attempts whose answers were
      // lost to an older destructive seed.
      //
      // The stored `response` is what the student chose, not the answer key.
      // Storing the key made every seeded attempt look like a perfect paper on
      // the review screen, and made a wrong answer indistinguishable from a
      // right one — the two fields have to agree for the explanation page to
      // mean anything.
      let earned = 0;
      for (const question of quiz.questions) {
        // Better-performing students answer more accurately.
        const correct = hashChance(`${attemptKey}|${question.id}|correct`, 0.72);
        const response = seededResponse(question, correct, `${attemptKey}|${question.id}`);
        const awarded = correct ? question.points : 0;
        earned += awarded;
        await prisma.quizAnswer.upsert({
          where: { attemptId_questionId: { attemptId: attempt.id, questionId: question.id } },
          create: {
            attemptId: attempt.id,
            questionId: question.id,
            response: response as Prisma.InputJsonValue,
            isCorrect: correct,
            pointsAwarded: awarded,
          },
          update: {
            response: response as Prisma.InputJsonValue,
            isCorrect: correct,
            pointsAwarded: awarded,
          },
        });
      }

      const percentage = maxScore > 0 ? Math.round((earned / maxScore) * 100) : 0;
      await prisma.quizAttempt.update({
        where: { id: attempt.id },
        data: {
          score: percentage,
          passed: percentage >= quiz.passingScore,
        },
      });

      attemptCount += 1;
    }
  }
  console.log(`   ✓ ${attemptCount} percobaan kuis`);

  // Repair pass for attempts left by an earlier seed run.
  //
  // Those rows drew `startedAt` and `submittedAt` from independent hashes, so
  // some finish before they begin — rendered as a duration of 14400 minutes.
  // The loop above only touches the attempt its own hash selects, so the
  // broken rows it did not select would otherwise survive forever.
  //
  // Scoped to rows that are actually impossible (finish before start, or a
  // duration beyond any sane sitting) so a real attempt is never rewritten.
  let repairedAttempts = 0;
  for (const quiz of quizzes) {
    const attempts = await prisma.quizAttempt.findMany({
      where: { quizId: quiz.id, submittedAt: { not: null } },
      select: { id: true, startedAt: true, submittedAt: true, attemptNo: true },
    });

    const ceilingMinutes = quiz.timeLimitMinutes
      ? quiz.timeLimitMinutes + 30
      : 6 * 60;

    for (const attempt of attempts) {
      const minutes =
        ((attempt.submittedAt?.getTime() ?? 0) - attempt.startedAt.getTime()) / 60000;
      if (minutes > 0 && minutes <= ceilingMinutes) continue;

      const took = hashInt(`repair|${attempt.id}`, 4, Math.max(5, Math.min(ceilingMinutes, 45)));
      const start = daysAgo(
        hashInt(`repair|${attempt.id}|day`, 2, 18),
        hashInt(`repair|${attempt.id}|hour`, 7, 15)
      );

      await prisma.quizAttempt.update({
        where: { id: attempt.id },
        data: {
          startedAt: start,
          submittedAt: new Date(start.getTime() + took * 60 * 1000),
        },
      });
      repairedAttempts += 1;
    }
  }
  if (repairedAttempts > 0) {
    console.log(`   ✓ ${repairedAttempts} percobaan dengan waktu tidak wajar diperbaiki`);
  }

  // The gradebook reads Submission, not QuizAttempt, so a quiz score has to be
  // written there too — rescaled onto the assignment's own maximum. Without
  // this the attempt is marked but invisible to every grade view.
  //
  // Done as its own pass over the best attempt per student, because a student
  // may have two attempts and only one submission row can exist. Writing it
  // inside the attempt loop would let the later attempt overwrite the better
  // one, which is the opposite of what the app does when a retake scores lower.
  let quizSubmissionCount = 0;

  for (const quiz of quizzes) {
    const submitted = await prisma.quizAttempt.findMany({
      where: { quizId: quiz.id, submittedAt: { not: null } },
      select: { studentId: true, score: true, submittedAt: true },
    });

    const best = new Map<string, { score: number; submittedAt: Date }>();
    for (const attempt of submitted) {
      const current = best.get(attempt.studentId);
      if (!current || attempt.score > current.score) {
        best.set(attempt.studentId, {
          score: attempt.score,
          submittedAt: attempt.submittedAt ?? new Date(),
        });
      }
    }

    for (const [studentId, attempt] of best) {
      const scaled = Math.round((attempt.score / 100) * quiz.assignment.maxScore);
      const late =
        quiz.assignment.dueAt !== null && attempt.submittedAt > quiz.assignment.dueAt;
      const payload = {
        content: `Kuis dikerjakan otomatis. Skor ${attempt.score}%.`,
        status: "GRADED" as const,
        isLate: late,
        submittedAt: attempt.submittedAt,
        score: scaled,
        gradedAt: attempt.submittedAt,
        feedback: `Dinilai otomatis. Ambang kelulusan ${quiz.passingScore}%.`,
      };

      // `update` is a real write, not an empty object: an earlier seed run
      // wrote a random score for this student, and leaving it in place would
      // keep the quiz page and the gradebook permanently disagreeing.
      await prisma.submission.upsert({
        where: {
          assignmentId_studentId: { assignmentId: quiz.assignment.id, studentId },
        },
        create: { assignmentId: quiz.assignment.id, studentId, ...payload },
        update: payload,
      });
      quizSubmissionCount += 1;
    }
  }
  console.log(`   ✓ ${quizSubmissionCount} pengumpulan kuis dari attempt terbaik`);

  // An earlier seed generated quiz submissions from its own random score rather
  // than from an attempt. Those rows are orphans — the app can never create one,
  // because a quiz grade is always written by handing in an attempt — and they
  // make the gradebook show a number that no attempt explains. Removing them is
  // narrow by construction: only a quiz assignment, and only a student with no
  // submitted attempt at all.
  let orphanQuizzesRemoved = 0;
  for (const quiz of quizzes) {
    const attempted = new Set(
      (
        await prisma.quizAttempt.findMany({
          where: { quizId: quiz.id, submittedAt: { not: null } },
          select: { studentId: true },
        })
      ).map((attempt) => attempt.studentId)
    );

    const orphans = await prisma.submission.findMany({
      where: {
        assignmentId: quiz.assignment.id,
        ...(attempted.size > 0 ? { studentId: { notIn: [...attempted] } } : {}),
      },
      select: { id: true },
    });

    if (orphans.length > 0) {
      await prisma.submission.deleteMany({
        where: { id: { in: orphans.map((row) => row.id) } },
      });
      orphanQuizzesRemoved += orphans.length;
    }
  }
  if (orphanQuizzesRemoved > 0) {
    console.log(`   ✓ ${orphanQuizzesRemoved} pengumpulan kuis yatim dibersihkan`);
  }

  // --- attendance ---------------------------------------------------------
  let attendanceSessions = 0;
  let attendanceRecords = 0;

  for (const classroom of classrooms) {
    const classId = classIds.get(classroom.code)!;
    const courseForClass = COURSES.find((c) =>
      classroom.teacher === c.teacher && c.tags.length > 0
    );
    const courseId = courseForClass ? courseIds.get(slugify(courseForClass.title))! : null;

    const roster = await prisma.classEnrollment.findMany({
      where: { classId },
      select: { studentId: true },
    });

    // 12 weekly sessions, going back in time.
    for (let week = 12; week >= 1; week -= 1) {
      const date = daysAgo(week * 7, 7);
      date.setMinutes(30, 0, 0);

      const session = await prisma.attendanceSession.upsert({
        where: { classId_date: { classId, date } },
        create: {
          classId,
          courseId,
          date,
          topic: pick([
            "Pengenalan sensor ultrasonik",
            "Praktik perulangan",
            "Latihan algoritma",
            "Diskusi proyek kelompok",
            "Praktik robot line follower",
            "Review materi minggu lalu",
            "Pengenalan struktur data",
            "Simulasi navigasi grid",
          ]),
          createdById: users.get(classroom.teacher)!,
        },
        update: {},
      });
      attendanceSessions += 1;

      for (const { studentId } of roster) {
        const roll = hashInt(`${session.id}|${studentId}|attendance`, 0, 99) / 100;
        const status = roll < 0.85 ? "PRESENT" : roll < 0.93 ? "LATE" : roll < 0.97 ? "ABSENT" : "EXCUSED";

        await prisma.attendanceRecord.upsert({
          where: { sessionId_studentId: { sessionId: session.id, studentId } },
          create: {
            sessionId: session.id,
            studentId,
            status,
            note: status === "EXCUSED" ? "Surat izin dari orang tua" : null,
            markedAt: date,
          },
          update: {},
        });
        attendanceRecords += 1;
      }
    }
  }
  console.log(`   ✓ ${attendanceSessions} sesi absensi, ${attendanceRecords} catatan kehadiran`);

  // --- coding projects ----------------------------------------------------
  const projectIds = new Map<string, string>();
  for (const [index, project] of CODING_PROJECTS.entries()) {
    const slug = slugify(project.title);
    const courseSlug = project.language === "PYTHON" ? "python-untuk-analisis-data" : "pemrograman-javascript-untuk-pemula";
    const courseId = courseIds.get(courseSlug) ?? null;

    const row = await prisma.codingProject.upsert({
      where: { slug },
      create: {
        title: project.title,
        slug,
        description: project.description,
        brief: project.brief,
        language: project.language,
        difficulty: project.difficulty,
        starterCode: project.starterCode,
        solutionCode: project.solutionCode,
        tests: project.tests as unknown as Prisma.InputJsonValue,
        hints: project.hints,
        xpReward: project.xpReward,
        status: "PUBLISHED",
        courseId,
        createdById: users.get("sari.dewi")!,
        orderIndex: index,
      },
      update: {
        description: project.description,
        brief: project.brief,
        starterCode: project.starterCode,
        solutionCode: project.solutionCode,
        tests: project.tests as unknown as Prisma.InputJsonValue,
        hints: project.hints,
        xpReward: project.xpReward,
        status: "PUBLISHED",
      },
    });
    projectIds.set(slug, row.id);

    for (const skillSlug of project.skills) {
      const skillId = skillIds.get(skillSlug);
      if (!skillId) continue;
      await prisma.projectSkill.upsert({
        where: { projectId_skillId: { projectId: row.id, skillId } },
        create: { projectId: row.id, skillId, xp: 15 },
        update: {},
      });
    }
  }
  console.log(`   ✓ ${CODING_PROJECTS.length} proyek coding`);

  // --- coding submissions -------------------------------------------------
  let codingSubmissions = 0;
  const studentUsernames = STUDENTS.map(([username]) => username);

  for (const project of CODING_PROJECTS) {
    const projectId = projectIds.get(slugify(project.title))!;
    const testCount = project.tests.length;

    for (const username of studentUsernames) {
      const studentId = users.get(username)!;
      const subKey = `${projectId}|${studentId}`;
      if (hashChance(`${subKey}|attempted`, 0.4)) continue; // hasn't attempted

      const passed = hashChance(`${subKey}|passed`, 0.68);
      const passedTests = passed ? testCount : hashInt(`${subKey}|tests`, 0, Math.max(0, testCount - 1));
      const status = passed ? "PASSED" : "FAILED";

      // Natural key: (projectId, studentId) — one seeded submission per student
      // per project, so a re-run updates rather than appends.
      const existingSubmission = await prisma.codingSubmission.findFirst({
        where: { projectId, studentId },
        select: { id: true },
      });
      if (existingSubmission) continue;

      await prisma.codingSubmission.create({
        data: {
          projectId,
          studentId: users.get(username)!,
          code: passed ? project.solutionCode : project.starterCode,
          language: project.language,
          status,
          passedTests,
          totalTests: testCount,
          testResults: project.tests.map((test, index) => ({
            name: test.name,
            passed: index < passedTests,
            message: index < passedTests ? "Passed" : "Assertion failed",
            durationMs: randomInt(1, 12),
          })) as unknown as Prisma.InputJsonValue,
          score: Math.round((passedTests / testCount) * 100),
          executionTimeMs: randomInt(2, 40),
          stdout: "",
          stderr: passed ? "" : "AssertionError: expected value did not match",
          createdAt: daysAgo(randomInt(1, 22)),
        },
      });
      codingSubmissions += 1;
    }
  }
  console.log(`   ✓ ${codingSubmissions} pengumpulan coding`);

  // --- simulator challenges ----------------------------------------------
  const challengeIds = new Map<string, string>();
  for (const [index, challenge] of SIMULATOR_CHALLENGES.entries()) {
    const row = await prisma.simulatorChallenge.upsert({
      where: { slug: challenge.slug },
      create: {
        slug: challenge.slug,
        title: challenge.title,
        description: challenge.description,
        difficulty: challenge.difficulty,
        gridWidth: challenge.gridWidth,
        gridHeight: challenge.gridHeight,
        walls: challenge.walls as unknown as Prisma.InputJsonValue,
        startX: challenge.startX,
        startY: challenge.startY,
        startDir: challenge.startDir,
        goalX: challenge.goalX,
        goalY: challenge.goalY,
        stars: challenge.stars as unknown as Prisma.InputJsonValue,
        maxSteps: challenge.maxSteps,
        parSteps: Math.round(challenge.maxSteps * 0.4),
        starterCode: challenge.starterCode,
        solutionCode: challenge.solutionCode,
        hints: challenge.hints,
        xpReward: challenge.xpReward,
        status: "PUBLISHED",
        orderIndex: index,
      },
      update: {
        title: challenge.title,
        description: challenge.description,
        walls: challenge.walls as unknown as Prisma.InputJsonValue,
        stars: challenge.stars as unknown as Prisma.InputJsonValue,
        starterCode: challenge.starterCode,
        solutionCode: challenge.solutionCode,
        hints: challenge.hints,
        xpReward: challenge.xpReward,
        status: "PUBLISHED",
      },
    });
    challengeIds.set(challenge.slug, row.id);
  }

  let simAttempts = 0;
  for (const challenge of SIMULATOR_CHALLENGES) {
    const challengeId = challengeIds.get(challenge.slug)!;
    for (const username of studentUsernames) {
      const studentId = users.get(username)!;
      const simKey = `${challengeId}|${studentId}`;
      if (hashChance(`${simKey}|attempted`, 0.45)) continue;
      const success = hashChance(`${simKey}|success`, 0.7);
      const steps = success
        ? hashInt(`${simKey}|steps`, 8, challenge.maxSteps)
        : hashInt(`${simKey}|steps`, 3, challenge.maxSteps);

      // Natural key: (challengeId, userId) — one seeded attempt per student.
      const existingAttempt = await prisma.simulatorAttempt.findFirst({
        where: { challengeId, userId: studentId },
        select: { id: true },
      });
      if (existingAttempt) continue;

      await prisma.simulatorAttempt.create({
        data: {
          challengeId,
          userId: users.get(username)!,
          program: success ? challenge.solutionCode : challenge.starterCode,
          success,
          stepsUsed: steps,
          starsEarned: success ? challenge.stars.length : randomInt(0, challenge.stars.length),
          score: success ? randomInt(75, 100) : randomInt(10, 55),
          trace: [] as unknown as Prisma.InputJsonValue,
          createdAt: daysAgo(randomInt(1, 25)),
        },
      });
      simAttempts += 1;
    }
  }
  console.log(`   ✓ ${SIMULATOR_CHALLENGES.length} tantangan simulator, ${simAttempts} percobaan`);

  // --- XP ledger & user skills -------------------------------------------
  let xpEvents = 0;
  for (const username of studentUsernames) {
    const studentId = users.get(username)!;

    const progressRows = await prisma.lessonProgress.findMany({
      where: { studentId, status: "COMPLETED" },
      select: { id: true, lessonId: true, completedAt: true },
      take: 40,
    });

    for (const row of progressRows) {
      // Natural key: (userId, source, refType, refId) — one XP award per
      // completed lesson. The XP total below is recomputed from this ledger, so
      // duplicates here would also corrupt every student's level.
      const existingEvent = await prisma.xpEvent.findFirst({
        where: {
          userId: studentId,
          source: "LESSON_COMPLETE",
          refType: "lesson",
          refId: row.lessonId,
        },
        select: { id: true },
      });
      if (existingEvent) continue;

      await prisma.xpEvent.create({
        data: {
          userId: studentId,
          amount: 25,
          source: "LESSON_COMPLETE",
          reason: "Menyelesaikan pelajaran",
          refType: "lesson",
          refId: row.lessonId,
          createdAt: row.completedAt ?? daysAgo(randomInt(1, 25)),
        },
      });
      xpEvents += 1;
    }

    // Grant skills the student has demonstrably practised. Key-derived so the
    // granted set is identical on every run (upsert alone would still let new
    // skills accumulate across runs).
    const grantedSkills = SKILLS.filter((skill) => hashChance(`${username}|${skill.slug}`, 0.55));
    for (const skill of grantedSkills) {
      const skillId = skillIds.get(skill.slug)!;
      await prisma.userSkill.upsert({
        where: { userId_skillId: { userId: studentId, skillId } },
        create: {
          userId: studentId,
          skillId,
          level: randomInt(1, 4),
          xp: randomInt(50, 420),
        },
        update: {},
      });
    }
  }

  // Recompute each student's XP total and level from the ledger so the
  // denormalised counters always reconcile with the audit trail.
  for (const username of studentUsernames) {
    const studentId = users.get(username)!;
    const aggregate = await prisma.xpEvent.aggregate({
      where: { userId: studentId },
      _sum: { amount: true },
    });
    const totalXp = aggregate._sum.amount ?? 0;
    let level = 1;
    while (level < 100 && totalXp >= Math.round(100 * Math.pow(level, 1.5))) level += 1;
    await prisma.user.update({ where: { id: studentId }, data: { xp: totalXp, level } });
  }
  console.log(`   ✓ ${xpEvents} catatan XP, level pengguna dihitung ulang`);

  // --- course progress recalculation -------------------------------------
  for (const username of studentUsernames) {
    const studentId = users.get(username)!;
    const enrollments = await prisma.courseEnrollment.findMany({
      where: { studentId },
      select: { id: true, courseId: true },
    });

    for (const enrollment of enrollments) {
      const totalLessons = await prisma.lesson.count({ where: { courseId: enrollment.courseId } });
      if (totalLessons === 0) continue;
      const doneLessons = await prisma.lessonProgress.count({
        where: {
          studentId,
          status: "COMPLETED",
          lesson: { courseId: enrollment.courseId },
        },
      });
      const percent = Math.round((doneLessons / totalLessons) * 100);
      await prisma.courseEnrollment.update({
        where: { id: enrollment.id },
        data: {
          progress: percent,
          status: percent >= 100 ? "COMPLETED" : "ACTIVE",
          completedAt: percent >= 100 ? daysAgo(randomInt(1, 5)) : null,
        },
      });
    }
  }
  console.log(`   ✓ progres kursus dihitung ulang`);

  // --- certificates --------------------------------------------------------
  // Award a certificate to every student who has finished a course. The same
  // helper the app calls on lesson completion is reused here, so seeded data
  // and real usage can never drift apart.
  let certificateCount = 0;
  for (const username of studentUsernames) {
    const studentId = users.get(username)!;
    const completed = await prisma.courseEnrollment.findMany({
      where: { studentId, status: "COMPLETED", progress: { gte: 100 } },
      select: { courseId: true, completedAt: true },
    });

    for (const enrollment of completed) {
      const result = await ensureCertificateForCourse(
        studentId,
        enrollment.courseId,
        users.get("waloonnn")!
      );
      if (!result?.created) continue;
      certificateCount += 1;

      // Spread issue dates back over the term rather than stamping them all
      // "now", so the register and the "this month" figure look plausible.
      await prisma.certificate.update({
        where: { id: result.certificateId },
        data: { issuedAt: enrollment.completedAt ?? daysAgo(randomInt(1, 5)) },
      });
    }
  }
  console.log(`   ✓ ${certificateCount} sertifikat diterbitkan`);

  // --- achievements -------------------------------------------------------
  // Award achievements by evaluating each student against the criteria their
  // description states. Without this every achievement row exists but nobody
  // ever unlocks one, so the achievements page is permanently empty.
  let unlockedTotal = 0;
  for (const username of studentUsernames) {
    const studentId = users.get(username)!;

    const [completedLessons, submissionCount, passedCode, simulatorWins, skillCount, attendanceCount, completedCourses, student] =
      await Promise.all([
        prisma.lessonProgress.count({ where: { studentId, status: "COMPLETED" } }),
        prisma.submission.count({ where: { studentId } }),
        prisma.codingSubmission.count({ where: { studentId, status: "PASSED" } }),
        prisma.simulatorAttempt.count({ where: { userId: studentId, success: true } }),
        prisma.userSkill.count({ where: { userId: studentId } }),
        prisma.attendanceRecord.count({
          where: { studentId, status: { in: ["PRESENT", "LATE"] } },
        }),
        prisma.courseEnrollment.count({ where: { studentId, status: "COMPLETED" } }),
        prisma.user.findUniqueOrThrow({ where: { id: studentId }, select: { level: true } }),
      ]);

    // Each entry: [achievement code, whether the student has earned it].
    const earned: [string, boolean][] = [
      ["first-steps", completedLessons >= 1],
      ["lesson-enthusiast", completedLessons >= 10],
      ["lesson-master", completedLessons >= 30],
      ["first-submission", submissionCount >= 1],
      ["consistent-worker", submissionCount >= 15],
      ["first-code", passedCode >= 1],
      ["code-warrior", passedCode >= 10],
      ["robot-whisperer", simulatorWins >= 5],
      ["skill-collector", skillCount >= 5],
      ["level-5", student.level >= 5],
      ["level-10", student.level >= 10],
      ["course-complete", completedCourses >= 1],
      ["perfect-attendance", attendanceCount >= 20],
    ];

    for (const [code, qualifies] of earned) {
      if (!qualifies) continue;
      await prisma.userAchievement.upsert({
        where: {
          userId_achievementId: { userId: studentId, achievementId: achievementIds.get(code)! },
        },
        create: {
          userId: studentId,
          achievementId: achievementIds.get(code)!,
          unlockedAt: daysAgo(hashInt(`${username}|${code}|unlocked`, 1, 30)),
        },
        update: {},
      });
      unlockedTotal += 1;
    }
  }
  console.log(`   ✓ ${ACHIEVEMENTS.length} pencapaian, ${unlockedTotal} terbuka`);

  // --- announcements ------------------------------------------------------
  const announcements = [
    {
      title: "Selamat datang di RoboLearn!",
      body: "Selamat datang di platform pembelajaran robotika dan pemrograman. Silakan jelajahi kursus yang tersedia, dan jangan ragu bertanya kepada guru jika ada yang belum jelas.\n\nSelamat belajar!",
      author: "waloonnn",
      classCode: null,
      pinned: true,
    },
    {
      title: "Persiapan Kompetisi Robotik Antar Sekolah",
      body: "Bagi siswa yang berminat mengikuti kompetisi robotik tingkat kota, silakan mendaftar ke Pak Budi paling lambat akhir minggu ini. Latihan akan dimulai minggu depan setiap hari Sabtu pukul 09.00 di Lab Komputer 1.",
      author: "budi.santoso",
      classCode: "RBT-7A",
      pinned: true,
    },
    {
      title: "Jadwal Praktikum Minggu Ini",
      body: "Praktikum minggu ini akan fokus pada simulator navigasi grid. Pastikan kalian sudah menyelesaikan pelajaran \"Lab: Navigasi Grid\" sebelum masuk lab agar waktu praktik lebih efektif.",
      author: "budi.santoso",
      classCode: "RBT-7B",
      pinned: false,
    },
    {
      title: "Tips Belajar Python",
      body: "Untuk yang baru mulai belajar Python: biasakan menulis kode sedikit-sedikit lalu langsung dijalankan. Lebih baik menjalankan 5 baris yang benar daripada menulis 50 baris sekaligus lalu bingung mencari errornya.",
      author: "sari.dewi",
      classCode: "CDG-8A",
      pinned: false,
    },
    {
      title: "Pengumpulan Proyek Akhir Diperpanjang",
      body: "Batas waktu pengumpulan proyek akhir robot line follower diperpanjang satu minggu. Manfaatkan waktu tambahan ini untuk menyempurnakan laporan dan melakukan pengujian ulang.",
      author: "budi.santoso",
      classCode: "CDG-8B",
      pinned: false,
    },
  ];

  let announcementCount = 0;
  for (const item of announcements) {
    const existing = await prisma.announcement.findFirst({ where: { title: item.title } });
    const classId = item.classCode ? classIds.get(item.classCode)! : null;
    const data = {
      title: item.title,
      body: item.body,
      authorId: users.get(item.author)!,
      classId,
      pinned: item.pinned,
    };
    if (existing) {
      await prisma.announcement.update({ where: { id: existing.id }, data });
    } else {
      await prisma.announcement.create({ data });
    }
    announcementCount += 1;
  }
  console.log(`   ✓ ${announcementCount} pengumuman`);

  // --- notifications ------------------------------------------------------
  const notifications: { userId: string; type: "INFO" | "SUCCESS" | "WARNING" | "GRADE" | "ASSIGNMENT" | "ANNOUNCEMENT" | "ACHIEVEMENT"; title: string; body: string; link: string | null; read: boolean; daysAgo: number }[] = [];

  for (const username of studentUsernames.slice(0, 8)) {
    const studentId = users.get(username)!;
    notifications.push({
      userId: studentId,
      type: "ASSIGNMENT",
      title: "Tugas baru tersedia",
      body: "Tugas \"Program Data Siswa\" sudah dipublikasikan. Batas pengumpulan 9 hari dari sekarang.",
      link: "/dashboard/assignments",
      read: hashChance(`${username}|notif-assignment|read`, 0.4),
      daysAgo: hashInt(`${username}|notif-assignment`, 1, 4),
    });
    notifications.push({
      userId: studentId,
      type: "GRADE",
      title: "Nilai tugas keluar",
      body: "Gurumu telah menilai tugasmu. Buka halaman tugas untuk melihat umpan balik.",
      link: "/dashboard/assignments",
      read: hashChance(`${username}|notif-grade|read`, 0.5),
      daysAgo: hashInt(`${username}|notif-grade`, 2, 10),
    });
    if (hashChance(`${username}|notif-achievement|exists`, 0.5)) {
      notifications.push({
        userId: studentId,
        type: "ACHIEVEMENT",
        title: "Pencapaian terbuka!",
        body: "Kamu membuka pencapaian \"Langkah Pertama\". Terus semangat!",
        link: "/dashboard/achievements",
        read: hashChance(`${username}|notif-achievement|read`, 0.6),
        daysAgo: hashInt(`${username}|notif-achievement`, 3, 15),
      });
    }
  }

  for (const staff of STAFF) {
    notifications.push({
      userId: users.get(staff.username)!,
      type: "INFO",
      title: "Pengumpulan tugas menunggu penilaian",
      body: "Ada pengumpulan tugas yang belum dinilai. Buka halaman penilaian untuk memprosesnya.",
      link: "/dashboard/grading",
      read: false,
      daysAgo: randomInt(1, 3),
    });
  }

  for (const item of notifications) {
    // Natural key is (userId, title) — Notification has no unique constraint, so
    // an explicit existence check is what keeps re-runs from duplicating rows.
    const existing = await prisma.notification.findFirst({
      where: { userId: item.userId, title: item.title },
      select: { id: true },
    });
    if (existing) continue;

    await prisma.notification.create({
      data: {
        userId: item.userId,
        type: item.type,
        title: item.title,
        body: item.body,
        link: item.link,
        readAt: item.read ? daysAgo(item.daysAgo - 1 < 0 ? 0 : item.daysAgo - 1) : null,
        createdAt: daysAgo(item.daysAgo),
      },
    });
  }
  console.log(`   ✓ ${notifications.length} notifikasi`);

  // --- assistant knowledge base -------------------------------------------
  // The bundled answers ship as editable rows so an administrator can correct
  // them from the console. `seededId` keys the upsert, so re-running the seed
  // refreshes the shipped text without disturbing admin-authored entries.
  for (const entry of BUNDLED_ENTRIES) {
    await prisma.knowledgeEntry.upsert({
      where: { seededId: entry.id },
      create: {
        topic: entry.topic,
        keywords: entry.keywords,
        answer: entry.answer,
        priority: entry.priority,
        seededId: entry.id,
        createdById: users.get("waloonnn")!,
      },
      update: {
        topic: entry.topic,
        keywords: entry.keywords,
        answer: entry.answer,
        priority: entry.priority,
      },
    });
  }
  console.log(`   ✓ ${BUNDLED_ENTRIES.length} pengetahuan asisten`);

  await prisma.auditLog.create({
    data: {
      actorId: users.get("waloonnn")!,
      action: "SEED_DATABASE",
      entity: "System",
      metadata: {
        users: users.size,
        courses: COURSES.length,
        lessons: lessonTotal,
        assignments: assignmentIds.length,
        projects: CODING_PROJECTS.length,
        challenges: SIMULATOR_CHALLENGES.length,
        knowledge: BUNDLED_ENTRIES.length,
        certificates: certificateCount,
      },
    },
  });

  // --- summary ------------------------------------------------------------
  console.log("\n✅ Seed selesai.\n");
  console.log("   Akun demo (password sama untuk semua):");
  console.log(`   ┌──────────────────┬─────────────────────────┬───────────────┐`);
  console.log(`   │ USERNAME         │ PERAN                   │ PASSWORD      │`);
  console.log(`   ├──────────────────┼─────────────────────────┼───────────────┤`);
  console.log(`   │ waloonnn         │ Administrator           │ ${SEED_PASSWORD.padEnd(13)} │`);
  console.log(`   │ budi.santoso     │ Guru (Robotika)         │ ${SEED_PASSWORD.padEnd(13)} │`);
  console.log(`   │ sari.dewi        │ Guru (Coding/Python)    │ ${SEED_PASSWORD.padEnd(13)} │`);
  console.log(`   │ agus.wijaya      │ Guru (Algoritma)        │ ${SEED_PASSWORD.padEnd(13)} │`);
  console.log(`   │ andi.pratama     │ Siswa                   │ ${SEED_PASSWORD.padEnd(13)} │`);
  console.log(`   │ bella.kusuma     │ Siswa                   │ ${SEED_PASSWORD.padEnd(13)} │`);
  console.log(`   │ irfan.maulana    │ Siswa                   │ ${SEED_PASSWORD.padEnd(13)} │`);
  console.log(`   └──────────────────┴─────────────────────────┴───────────────┘`);
  console.log(`\n   Masuk di /login menggunakan USERNAME (bukan email).\n`);
}

main()
  .catch((error) => {
    console.error("\n❌ Seed gagal:\n", error);
    process.exit(1);
  })
  .finally(async () => {
    await prisma.$disconnect();
  });
