"""
LAB 1 - EKSPERIMEN CHUNKING (versi 3)

Membaca PDF, memotongnya dengan 3 ukuran chunk (overlap 15%), lalu
menganalisis kualitas potongan: terpotong di tengah kalimat/kata,
mengandung pola tabel, atau memuat simbol matematika yang rusak.

Dua metode dibandingkan:
  - "tetap"  : potong tepat per N karakter (naif, sering memutus kata/kalimat)
  - "cerdas" : potong di batas kalimat terdekat (atau batas kata jika tidak
               ada), dan awal chunk berikutnya selalu di awal kata.
               Panjang chunk = maksimal "ukuran" karakter.
"""

import random
import re
from pathlib import Path

from pypdf import PdfReader
from pypdf.errors import PdfReadError

random.seed(42)  # agar sampel acak reproducible

FOLDER = Path("dokumen")
PENGATURAN = [(500, 75), (1000, 150), (1500, 225)]  # (ukuran, overlap) = 15%
JUMLAH_SAMPEL = 3
JENDELA_CARI = 0.3  # cari batas kalimat/kata di 30% terakhir sebuah chunk

# Karakter Private Use Area (simbol matematika yang rusak saat ekstraksi)
POLA_SIMBOL_RUSAK = re.compile(r"[-]")
POLA_AKHIR_KALIMAT = re.compile(r"[.!?:;][\"')\]]*$")
POLA_BATAS_KALIMAT = re.compile(r"[.!?][\"')\]]*(?=\s|$)")
POLA_SPASI = re.compile(r"\s")
POLA_KOLOM = re.compile(r"\S\s{3,}\S")  # 3+ spasi di antara dua token


# ==========================================
# MEMBACA PDF
# ==========================================

def baca_pdf(path):
    """Mengembalikan (teks_gabungan, jumlah_halaman)."""
    reader = PdfReader(path)
    if reader.is_encrypted:
        try:
            reader.decrypt("")
        except Exception:
            raise ValueError("PDF terenkripsi dan tidak bisa dibuka tanpa password")
    halaman = [(p.extract_text() or "") for p in reader.pages]
    return "\n".join(halaman), len(reader.pages)


# ==========================================
# CHUNKING
# ==========================================

def _validasi(ukuran, tumpang):
    if ukuran <= 0:
        raise ValueError("Ukuran chunk harus > 0")
    if tumpang < 0 or tumpang >= ukuran:
        raise ValueError("Overlap harus 0 <= tumpang < ukuran")


def potong_tetap(teks, ukuran=800, tumpang=100):
    """Potong per N karakter. Mengembalikan daftar (mulai, akhir)."""
    _validasi(ukuran, tumpang)
    posisi = []
    mulai = 0
    langkah = ukuran - tumpang
    while mulai < len(teks):
        akhir = min(mulai + ukuran, len(teks))
        if teks[mulai:akhir].strip():
            posisi.append((mulai, akhir))
        if akhir >= len(teks):  # hindari chunk ekor yang isinya hanya overlap
            break
        mulai += langkah
    return posisi


def _cari_akhir(teks, mulai, batas, ukuran):
    """Pilih titik akhir chunk (<= batas): batas kalimat > batas kata > batas keras."""
    awal_cari = max(mulai + 1, batas - int(ukuran * JENDELA_CARI))
    wilayah = teks[awal_cari:batas]

    # 1. batas kalimat terakhir di dalam jendela
    cocok = None
    for cocok in POLA_BATAS_KALIMAT.finditer(wilayah):
        pass
    if cocok:
        return awal_cari + cocok.end()

    # 2. spasi/baris baru terakhir (chunk berakhir tepat di akhir sebuah kata)
    spasi = None
    for spasi in POLA_SPASI.finditer(wilayah):
        pass
    if spasi:
        return awal_cari + spasi.start()

    # 3. tidak ada spasi sama sekali (mis. string panjang tanpa jeda)
    return batas


def potong_cerdas(teks, ukuran=800, tumpang=100):
    """Potong di batas kalimat/kata. Mengembalikan daftar (mulai, akhir)."""
    _validasi(ukuran, tumpang)
    n = len(teks)
    posisi = []
    mulai = 0
    while mulai < n and teks[mulai].isspace():
        mulai += 1

    while mulai < n:
        batas = min(mulai + ukuran, n)
        akhir = n if batas >= n else _cari_akhir(teks, mulai, batas, ukuran)

        if teks[mulai:akhir].strip():
            posisi.append((mulai, akhir))
        if akhir >= n:
            break

        # awal chunk berikutnya = mundur sebesar overlap, lalu geser maju
        # ke awal kata terdekat supaya tidak dimulai di tengah kata
        baru = max(akhir - tumpang, mulai + 1)
        while baru < akhir and not teks[baru - 1].isspace():
            baru += 1
        if baru <= mulai:
            baru = akhir
        while baru < n and teks[baru].isspace():
            baru += 1
        mulai = baru
    return posisi


METODE = {"tetap": potong_tetap, "cerdas": potong_cerdas}


# ==========================================
# ANALISIS CHUNK
# ==========================================

def analisis_chunk(teks_penuh, mulai, akhir):
    chunk = teks_penuh[mulai:akhir]
    isi = chunk.rstrip()

    berakhir_kalimat = bool(POLA_AKHIR_KALIMAT.search(isi))

    # Terpotong di tengah kata: karakter terakhir chunk dan karakter
    # berikutnya di teks asli sama-sama huruf/angka.
    ada_lanjutan = akhir < len(teks_penuh)
    terpotong_kata = (
        ada_lanjutan
        and chunk[-1:].isalnum()
        and teks_penuh[akhir:akhir + 1].isalnum()
    )

    baris = [b for b in (x.strip() for x in chunk.splitlines()) if b]
    baris_tabel = sum(1 for b in baris if "|" in b or "\t" in b or POLA_KOLOM.search(b))
    ada_tabel = baris_tabel >= 2

    jumlah_simbol = len(POLA_SIMBOL_RUSAK.findall(chunk))

    kata = isi.split()
    return {
        "panjang": len(chunk),
        "berakhir_kalimat": berakhir_kalimat,
        "terpotong_kata": terpotong_kata,
        "ada_tabel": ada_tabel,
        "jumlah_simbol_rusak": jumlah_simbol,
        "ada_simbol_rusak": jumlah_simbol > 0,
        "akhir_kata": " ".join(kata[-3:]) if kata else "",
    }


def persen(bagian, total):
    return f"{bagian / total * 100:.0f}%" if total else "-"


def rapikan(teks):
    """Ubah baris baru/spasi berlebih jadi satu spasi agar enak dibaca di terminal."""
    return " ".join(teks.split())


# ==========================================
# PROGRAM UTAMA
# ==========================================

def main():
    if not FOLDER.is_dir():
        raise SystemExit(f"❌ ERROR: Folder '{FOLDER}/' tidak ditemukan!")

    daftar_pdf = sorted(FOLDER.glob("*.pdf"))  # sorted -> hasil konsisten
    if not daftar_pdf:
        raise SystemExit(f"❌ ERROR: Tidak ada file PDF di folder '{FOLDER}/'!")

    print("=" * 70)
    print("  LAB 1 — EKSPERIMEN CHUNKING")
    print("=" * 70)
    print(f"\n📁 Folder     : {FOLDER.resolve()}")
    print(f"📄 Jumlah PDF : {len(daftar_pdf)} file")
    for p in daftar_pdf:
        print(f"   - {p.name}")

    # ---------- Langkah 1: baca PDF ----------
    pdf_path = daftar_pdf[0]
    try:
        teks, n_halaman = baca_pdf(pdf_path)
    except (PdfReadError, ValueError, OSError) as e:
        raise SystemExit(f"❌ ERROR: Gagal membaca '{pdf_path.name}': {e}")

    if not teks.strip():
        raise SystemExit(f"❌ ERROR: PDF '{pdf_path.name}' kosong / hasil scan (butuh OCR)!")

    print("\n" + "=" * 70)
    print("  LANGKAH 1 — MEMBACA PDF")
    print("=" * 70)
    print(f"\n📄 File yang diuji : {pdf_path.name}")
    print(f"📏 Total karakter  : {len(teks):,}")
    print(f"📑 Jumlah halaman  : {n_halaman}")
    print("\n--- 500 KARAKTER PERTAMA ---")
    print(teks[:500])
    print("--- (akhir 500 karakter) ---")

    # ---------- Langkah 2: potong ----------
    print("\n" + "=" * 70)
    print("  LANGKAH 2 — POTONG 3 UKURAN (OVERLAP 15%), 2 METODE")
    print("=" * 70)

    posisi_semua = {}  # (ukuran, metode) -> daftar posisi
    print(f"\n{'Ukuran':<10}{'Overlap':<10}{'Chunk (tetap)':<16}{'Chunk (cerdas)':<16}")
    print("-" * 52)
    for ukuran, overlap in PENGATURAN:
        for nama, fungsi in METODE.items():
            posisi_semua[(ukuran, nama)] = fungsi(teks, ukuran, overlap)
        print(f"{ukuran:<10}{overlap:<10}"
              f"{len(posisi_semua[(ukuran, 'tetap')]):<16}"
              f"{len(posisi_semua[(ukuran, 'cerdas')]):<16}")

    # ---------- Langkah 3: contoh chunk (metode cerdas) ----------
    print("\n" + "=" * 70)
    print(f"  LANGKAH 3 — CONTOH {JUMLAH_SAMPEL} CHUNK ACAK TIAP UKURAN (metode cerdas)")
    print("=" * 70)

    for ukuran, _ in PENGATURAN:
        posisi = posisi_semua[(ukuran, "cerdas")]
        print(f"\n{'#' * 70}\n##  UKURAN MAKS = {ukuran} KARAKTER  ({len(posisi)} chunk)\n{'#' * 70}")

        for i, (m, a) in enumerate(random.sample(posisi, min(JUMLAH_SAMPEL, len(posisi))), 1):
            info = analisis_chunk(teks, m, a)
            print(f"\n--- Contoh {i} (posisi {m}–{a}) ---")
            print(f"  Panjang           : {info['panjang']} karakter")
            print(f"  Berakhir kalimat  : {'✅ YA' if info['berakhir_kalimat'] else '❌ TIDAK'}")
            print(f"  Putus di tg. kata : {'❌ YA' if info['terpotong_kata'] else '✅ tidak'}")
            print(f"  Pola tabel        : {'⚠️  YA' if info['ada_tabel'] else '✅ tidak'}")
            simbol = f"⚠️  {info['jumlah_simbol_rusak']} simbol" if info["ada_simbol_rusak"] else "✅ tidak"
            print(f"  Simbol rusak      : {simbol}")
            print(f"  Awal              : {rapikan(teks[m:m + 100])}")
            print(f"  Akhir             : ...{rapikan(teks[max(m, a - 100):a])}")

    # ---------- Langkah 4: rekap (semua chunk) ----------
    print("\n" + "=" * 70)
    print("  LANGKAH 4 — REKAP & KESIMPULAN (dihitung dari semua chunk)")
    print("=" * 70)

    ringkasan = {}
    for (ukuran, nama), posisi in posisi_semua.items():
        semua = [analisis_chunk(teks, m, a) for m, a in posisi]
        ringkasan[(ukuran, nama)] = {
            "jumlah_chunk": len(semua),
            "terpotong_kalimat": sum(not x["berakhir_kalimat"] for x in semua),
            "terpotong_kata": sum(x["terpotong_kata"] for x in semua),
            "ada_tabel": sum(x["ada_tabel"] for x in semua),
            "ada_simbol_rusak": sum(x["ada_simbol_rusak"] for x in semua),
            "rata_panjang": sum(x["panjang"] for x in semua) / len(semua),
        }

    kolom = (f"{'Ukuran':<8}{'Metode':<8}{'Chunk':<7}{'Rata2 pjg':<11}"
             f"{'Putus kalimat':<16}{'Putus kata':<14}{'Tabel':<12}{'Simbol':<10}")
    print("\n" + kolom)
    print("-" * len(kolom))
    for (ukuran, nama), r in ringkasan.items():
        n = r["jumlah_chunk"]

        def sel(k):
            return f"{r[k]} ({persen(r[k], n)})"

        print(f"{ukuran:<8}{nama:<8}{n:<7}{r['rata_panjang']:<11.0f}"
              f"{sel('terpotong_kalimat'):<16}{sel('terpotong_kata'):<14}"
              f"{sel('ada_tabel'):<12}{sel('ada_simbol_rusak'):<10}")

    def jml(nama, k):
        return sum(r[k] for (u, nm), r in ringkasan.items() if nm == nama)

    tot = {nm: jml(nm, "jumlah_chunk") for nm in METODE}
    jumlah_cerdas = [ringkasan[(u, "cerdas")]["jumlah_chunk"] for u, _ in PENGATURAN]

    print("\n--- KESIMPULAN OTOMATIS ---")
    print(f"1. Jumlah chunk (metode cerdas) per ukuran: {' → '.join(map(str, jumlah_cerdas))} "
          f"({'menurun' if jumlah_cerdas == sorted(jumlah_cerdas, reverse=True) else 'tidak monoton'} "
          f"seiring ukuran bertambah).")
    print(f"2. Chunk putus di tengah kata: tetap {jml('tetap', 'terpotong_kata')}/{tot['tetap']} "
          f"({persen(jml('tetap', 'terpotong_kata'), tot['tetap'])}) → cerdas "
          f"{jml('cerdas', 'terpotong_kata')}/{tot['cerdas']} "
          f"({persen(jml('cerdas', 'terpotong_kata'), tot['cerdas'])}).")
    print(f"3. Chunk tidak berakhir di akhir kalimat: tetap {jml('tetap', 'terpotong_kalimat')}/{tot['tetap']} "
          f"({persen(jml('tetap', 'terpotong_kalimat'), tot['tetap'])}) → cerdas "
          f"{jml('cerdas', 'terpotong_kalimat')}/{tot['cerdas']} "
          f"({persen(jml('cerdas', 'terpotong_kalimat'), tot['cerdas'])}).")
    print(f"4. Chunk dengan pola tabel (metode cerdas): {jml('cerdas', 'ada_tabel')}/{tot['cerdas']} "
          f"({persen(jml('cerdas', 'ada_tabel'), tot['cerdas'])}); "
          f"dengan simbol rusak: {jml('cerdas', 'ada_simbol_rusak')}/{tot['cerdas']} "
          f"({persen(jml('cerdas', 'ada_simbol_rusak'), tot['cerdas'])}).")
    if jml("cerdas", "terpotong_kalimat") / tot["cerdas"] > 0.5:
        print("5. Sebagian besar chunk masih tidak berakhir dengan tanda baca akhir kalimat "
              "(baris PDF sering berhenti di judul/daftar/tabel); pertimbangkan pemotongan "
              "per halaman atau per bagian/judul.")
    else:
        print("5. Metode cerdas menjaga sebagian besar chunk berakhir di batas kalimat.")

    print("\n" + "=" * 70)
    print("  ✅ Eksperimen chunking selesai.")
    print("=" * 70)


if __name__ == "__main__":
    main()