app.py

"""

Nesting Otomatis Banner v2 — Super Optimized (Fixed)

=====================================================

Perbaikan: original_dims dipass ke pack_multi_width_multi_roll

"""

import math
import os
import random
import concurrent.futures

import gradio as gr
import pandas as pd
from PIL import Image, ImageDraw, ImageFont
from rectpack import newPacker

from rectpack import (
    SORT_AREA, SORT_PERI, SORT_DIFF, SORT_SSIDE, SORT_LSIDE, SORT_RATIO, SORT_NONE
)
from rectpack.maxrects import MaxRectsBl, MaxRectsBssf, MaxRectsBaf, MaxRectsBlsf
from rectpack.skyline import (
    SkylineBl, SkylineBlWm, SkylineMwf, SkylineMwfl, SkylineMwfWm, SkylineMwflWm
)
from rectpack.guillotine import (
    GuillotineBssfSas, GuillotineBssfLas, GuillotineBssfSlas,
    GuillotineBssfLlas, GuillotineBssfMaxas, GuillotineBssfMinas,
    GuillotineBafSas, GuillotineBafLas, GuillotineBafSlas,
    GuillotineBafLlas, GuillotineBafMaxas, GuillotineBafMinas,
    GuillotineBlsfSas, GuillotineBlsfLas, GuillotineBlsfSlas,
    GuillotineBlsfLlas, GuillotineBlsfMaxas, GuillotineBlsfMinas,
)


# --------------------------------------------------------------------------
# 1. FUNGSI BANTU
# --------------------------------------------------------------------------

def generate_color(seed_text: str):
    random.seed(seed_text)
    return tuple(random.randint(90, 220) for _ in range(3))


def load_font(size: int = 14):
    candidates = [
        "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
        "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
    ]
    for path in candidates:
        try:
            return ImageFont.truetype(path, size)
        except Exception:
            continue
    return ImageFont.load_default()


def lighten_color(c, factor=0.55):
    return tuple(min(255, int(v + (255 - v) * factor)) for v in c)


def get_sort_name(sort_algo):
    mapping = {
        SORT_AREA: "AREA", SORT_PERI: "PERI", SORT_LSIDE: "LSIDE",
        SORT_SSIDE: "SSIDE", SORT_RATIO: "RATIO", SORT_DIFF: "DIFF",
        SORT_NONE: "NONE", None: "Default",
    }
    return mapping.get(sort_algo, str(sort_algo))
    
    
def add_banner_to_list(label, width, height, item_margin, current_data):
    if not label or not str(label).strip():
        label = f"Banner"
    try:
        w = float(width)
        h = float(height)
        m = float(item_margin) if item_margin is not None else 0.0
        if m < 0:
            m = 0.0
    except (TypeError, ValueError):
        return current_data  # Abaikan jika nilai tidak valid

    new_row = [str(label).strip(), w, h, m]

    # Tangkap apakah current_data berupa DataFrame pandas atau List of Lists
    if isinstance(current_data, pd.DataFrame):
        new_row_df = pd.DataFrame([new_row], columns=current_data.columns)
        return pd.concat([current_data, new_row_df], ignore_index=True)
    elif isinstance(current_data, list):
        return current_data + [new_row]
    else:
        return [new_row]



# --------------------------------------------------------------------------
# 2. PERSIAPAN DATA
# --------------------------------------------------------------------------

def prepare_rects(df: pd.DataFrame, allow_rotation: bool = True):
    """

    Setiap baris di tabel = satu banner (tanpa Qty). Margin/jarak antar item

    kini dibaca PER BARIS dari kolom "Margin", sehingga tiap desain banner

    bisa punya jarak potong yang berbeda-beda. Untuk mencetak banner yang

    sama lebih dari satu kali, tambahkan baris terpisah lewat form input

    (bisa dengan label & margin yang sama).

    """
    rects, original_dims, item_margins = [], {}, {}
    for idx, row in df.iterrows():
        label = str(row["Label"]).strip() or f"Item{idx}"
        try:
            w, h = float(row["Width"]), float(row["Height"])
            m = float(row["Margin"]) if pd.notna(row.get("Margin")) else 0.0
        except (TypeError, ValueError):
            continue
        if w <= 0 or h <= 0:
            continue
        if m < 0:
            m = 0.0
        rid = f"{label}#{idx}"
        rects.append((w + m * 2, h + m * 2, rid))
        original_dims[rid] = (w, h)
        item_margins[rid] = m
    if not rects:
        return None, None, None, 0, 0
    max_margin = max(item_margins.values()) if item_margins else 0.0
    # PERBAIKAN BUG: dulu tinggi bin (max_height) dihitung hanya dari sisi
    # "Height" tanpa rotasi (sum(h ...)). Kalau rotasi diizinkan, item dengan
    # rasio aspek ekstrem (mis. 605 x 60 cm) bisa ditempatkan berdiri, dan
    # footprint tingginya justru jadi 610 cm — jauh lebih besar dari 65 cm
    # yang tadinya diasumsikan. Bin yang terlalu pendek membuat rectpack
    # gagal menempatkan item ini walau seharusnya muat. Sekarang tiap item
    # disumbang oleh SISI TERPANJANG-nya (w atau h, mana yang lebih besar)
    # saat rotasi diizinkan, sebagai estimasi konservatif yang aman untuk
    # segala kemungkinan orientasi hasil packing.
    if allow_rotation:
        per_item_h = [max(w, h) for w, h, _ in rects]
    else:
        per_item_h = [h for _, h, _ in rects]
    max_height = sum(per_item_h) + max_margin * (len(rects) + 2) + 50
    return rects, original_dims, item_margins, len(rects), max_height


# --------------------------------------------------------------------------
# 3. CORE: PACKING ENGINE
# --------------------------------------------------------------------------

def pack_multi_roll(rects, roll_width, max_height, allow_rotation,

                    pack_algo=None, sort_algo=None, reverse=False):
    remaining = list(reversed(rects)) if reverse else rects[:]
    rolls, safety = [], 50
    for _ in range(safety):
        if not remaining:
            break
        kwargs = {"rotation": allow_rotation}
        if pack_algo:
            kwargs["pack_algo"] = pack_algo
        if sort_algo:
            kwargs["sort_algo"] = sort_algo
        packer = newPacker(**kwargs)
        for w, h, rid in remaining:
            packer.add_rect(w, h, rid=rid)
        packer.add_bin(roll_width, max_height)
        packer.pack()
        if len(packer) == 0 or len(packer[0]) == 0:
            return rolls, len(remaining)
        placed = packer[0]
        used_height = max(r.y + r.height for r in placed)
        rolls.append((placed, used_height, roll_width))
        placed_ids = {r.rid for r in placed}
        remaining = [r for r in remaining if r[2] not in placed_ids]
    return rolls, len(remaining)


# --------------------------------------------------------------------------
# 4. GUILLOTINE CUT VALIDATION
# --------------------------------------------------------------------------

def is_guillotine_cuttable(rolls):
    violations = 0
    for placed, used_height, roll_width in rolls:
        items = []
        for r in placed:
            items.append({
                'x': r.x, 'y': r.y,
                'w': r.width, 'h': r.height,
                'rid': r.rid
            })
        for a in items:
            has_free_top = a['y'] + a['h'] >= used_height - 0.01
            has_free_bottom = a['y'] <= 0.01
            has_free_left = a['x'] <= 0.01
            has_free_right = a['x'] + a['w'] >= roll_width - 0.01
            if has_free_top or has_free_bottom or has_free_left or has_free_right:
                continue

            can_slide_up = all(
                not (b['x'] < a['x'] + a['w'] and b['x'] + b['w'] > a['x'] and
                     b['y'] > a['y'] + a['h'])
                for b in items if b['rid'] != a['rid']
            )
            if can_slide_up:
                continue

            can_slide_down = all(
                not (b['x'] < a['x'] + a['w'] and b['x'] + b['w'] > a['x'] and
                     b['y'] + b['h'] < a['y'])
                for b in items if b['rid'] != a['rid']
            )
            if can_slide_down:
                continue

            can_slide_left = all(
                not (b['y'] < a['y'] + a['h'] and b['y'] + b['h'] > a['y'] and
                     b['x'] + b['w'] < a['x'])
                for b in items if b['rid'] != a['rid']
            )
            if can_slide_left:
                continue

            can_slide_right = all(
                not (b['y'] < a['y'] + a['h'] and b['y'] + b['h'] > a['y'] and
                     b['x'] > a['x'] + a['w'])
                for b in items if b['rid'] != a['rid']
            )
            if can_slide_right:
                continue

            violations += 1
    return violations == 0, violations


# --------------------------------------------------------------------------
# 5. VISUALISASI
# --------------------------------------------------------------------------

def render_multi_roll(rolls, original_dims, item_margins, px_per_unit=4.0):
    if not rolls:
        return None, 0, 0, 0

    max_roll_w = max(w for _, _, w in rolls)
    img_w = max(1, int(round(max_roll_w * px_per_unit)))
    gap = 40
    total_h = sum(int(round(h * px_per_unit)) for _, h, _ in rolls)
    total_h += gap * (len(rolls) - 1) + 60

    img = Image.new("RGB", (img_w, total_h), "white")
    draw = ImageDraw.Draw(img)
    font = load_font(14)
    font_small = load_font(11)
    font_title = load_font(16)

    y_offset, total_true, total_roll_area, total_rot = 0, 0, 0, 0

    for roll_idx, (placed, used_height, roll_width) in enumerate(rolls):
        roll_h_px = int(round(used_height * px_per_unit))
        roll_label = f"ROLL {roll_idx + 1}  |  {roll_width:g} x {used_height:.1f} cm"
        draw.text((img_w / 2, y_offset + 5), roll_label, fill="#cc0000", font=font_title, anchor="ma")

        roll_y0 = y_offset + 25
        roll_y1 = roll_y0 + roll_h_px
        draw.rectangle([0, roll_y0, int(round(roll_width * px_per_unit)) - 1, roll_y1], outline="red", width=3)

        for r in placed:
            base_label = r.rid.rsplit("#", 1)[0]
            color = generate_color(base_label)
            outer_color = lighten_color(color, 0.55)
            inner_color = color
            orig_w, orig_h = original_dims[r.rid]
            item_margin = item_margins.get(r.rid, 0.0)
            is_rotated = round(r.width - item_margin * 2, 3) != round(orig_w, 3)

            x0 = r.x * px_per_unit
            y0 = roll_y0 + (used_height - r.y - r.height) * px_per_unit
            x1 = (r.x + r.width) * px_per_unit
            y1 = roll_y0 + (used_height - r.y) * px_per_unit

            m = item_margin * px_per_unit
            ix0, iy0 = x0 + m, y0 + m
            ix1, iy1 = x1 - m, y1 - m

            draw.rectangle([x0, y0, x1, y1], fill=outer_color, outline="black", width=2)
            if ix1 > ix0 and iy1 > iy0:
                draw.rectangle([ix0, iy0, ix1, iy1], fill=inner_color, outline="black", width=1)

            label_text = base_label
            size_text = f"{orig_w:g} x {orig_h:g}" + (" (diputar)" if is_rotated else "")
            bbox_label = draw.textbbox((0, 0), label_text, font=font)
            bbox_size = draw.textbbox((0, 0), size_text, font=font_small)
            total_th = (bbox_label[3] - bbox_label[1]) + (bbox_size[3] - bbox_size[1]) + 4
            cx, cy = (x0 + x1) / 2, (y0 + y1) / 2
            ty = cy - total_th / 2
            if (x1 - x0) > 20 and (y1 - y0) > 20:
                draw.text((cx, ty), label_text, fill="black", font=font, anchor="ma")
                draw.text((cx, ty + (bbox_label[3] - bbox_label[1]) + 4), size_text,
                           fill="black", font=font_small, anchor="ma")

            total_true += orig_w * orig_h
            if is_rotated:
                total_rot += 1

        for x in range(0, int(round(roll_width * px_per_unit)), 20):
            draw.line([(x, roll_y0), (x, roll_y1)], fill="#f5f5f5", width=1)
        for y in range(int(roll_y0), int(roll_y1), 20):
            draw.line([(0, y), (int(round(roll_width * px_per_unit)) - 1, y)], fill="#f5f5f5", width=1)

        total_roll_area += roll_width * used_height
        y_offset = roll_y1 + gap

    return img, total_true, total_roll_area, total_rot


# --------------------------------------------------------------------------
# 5b. EKSPOR SVG (skala 1 unit SVG = 1 cm, untuk dibuka di CorelDraw/Illustrator)
# --------------------------------------------------------------------------

def _xml_escape(text: str) -> str:
    return (
        str(text)
        .replace("&", "&amp;")
        .replace("<", "&lt;")
        .replace(">", "&gt;")
        .replace('"', "&quot;")
    )


def render_svg(rolls, original_dims, item_margins, roll_gap_cm=10.0, header_h_cm=2.0):
    """

    Render layout nesting sebagai SVG vektor, 1 unit SVG = 1 cm.

    Tiap item digambar dengan DUA kotak:

      - Kotak LUAR (garis hitam)  = area termasuk margin/jarak antar item = garis potong roll.

      - Kotak DALAM (garis biru putus-putus) = ukuran desain ASLI banner

        (tanpa margin). Ini adalah area yang harus diisi dengan desain asli

        saat file dibuka di CorelDraw, sehingga posisinya sudah pas dengan

        hasil nesting.

    Jika item diputar 90°, kotak dalam otomatis ikut ditukar (swap w/h)

    supaya tetap merepresentasikan orientasi tempel yang benar.

    Roll ditumpuk vertikal, sama seperti pratinjau PNG, supaya keduanya

    konsisten secara visual.

    """
    if not rolls:
        return None

    max_roll_w = max(w for _, _, w in rolls)
    total_h = (
        sum(h for _, h, _ in rolls)
        + header_h_cm * len(rolls)
        + roll_gap_cm * max(0, len(rolls) - 1)
    )

    svg = []
    svg.append(
        f'<svg xmlns="http://www.w3.org/2000/svg" '
        f'width="{max_roll_w:.4f}cm" height="{total_h:.4f}cm" '
        f'viewBox="0 0 {max_roll_w:.4f} {total_h:.4f}">'
    )
    svg.append(
        '<desc>Layout nesting banner. 1 unit SVG = 1 cm. '
        'Kotak hitam = garis potong roll (termasuk margin). '
        'Kotak biru putus-putus = ukuran &amp; posisi desain asli banner.</desc>'
    )

    y_offset = 0.0
    for roll_idx, (placed, used_height, roll_width) in enumerate(rolls):
        label_y = y_offset + header_h_cm - 0.4
        svg.append(
            f'<text x="{roll_width / 2:.4f}" y="{label_y:.4f}" '
            f'font-family="sans-serif" font-size="0.7" text-anchor="middle" '
            f'fill="#cc0000">ROLL {roll_idx + 1} | {roll_width:g} x {used_height:.1f} cm</text>'
        )

        roll_y0 = y_offset + header_h_cm
        roll_y1 = roll_y0 + used_height
        svg.append(
            f'<rect x="0" y="{roll_y0:.4f}" width="{roll_width:.4f}" height="{used_height:.4f}" '
            f'fill="none" stroke="red" stroke-width="0.08"/>'
        )

        for r in placed:
            base_label = r.rid.rsplit("#", 1)[0]
            orig_w, orig_h = original_dims[r.rid]
            item_margin = item_margins.get(r.rid, 0.0)
            is_rotated = round(r.width - item_margin * 2, 3) != round(orig_w, 3)

            # Kotak luar (footprint termasuk margin), y di-flip spy sama
            # orientasinya dgn pratinjau PNG (roll dibaca dari bawah ke atas).
            x0 = r.x
            y0 = roll_y0 + (used_height - r.y - r.height)
            w0 = r.width
            h0 = r.height

            svg.append(
                f'<rect x="{x0:.4f}" y="{y0:.4f}" width="{w0:.4f}" height="{h0:.4f}" '
                f'fill="none" stroke="black" stroke-width="0.05"/>'
            )

            # Kotak dalam = ukuran desain asli (swap kalau item diputar)
            inner_w, inner_h = (orig_h, orig_w) if is_rotated else (orig_w, orig_h)
            ix0 = x0 + item_margin
            iy0 = y0 + item_margin
            if inner_w > 0 and inner_h > 0:
                svg.append(
                    f'<rect x="{ix0:.4f}" y="{iy0:.4f}" width="{inner_w:.4f}" height="{inner_h:.4f}" '
                    f'fill="none" stroke="blue" stroke-width="0.04" stroke-dasharray="0.3,0.2"/>'
                )

            label_text = f"{base_label} ({orig_w:g}x{orig_h:g}{'R' if is_rotated else ''})"
            svg.append(
                f'<text x="{x0 + w0 / 2:.4f}" y="{y0 + h0 / 2:.4f}" '
                f'font-family="sans-serif" font-size="0.4" text-anchor="middle" '
                f'dominant-baseline="middle" fill="#333333">{_xml_escape(label_text)}</text>'
            )

        y_offset = roll_y1 + roll_gap_cm

    svg.append('</svg>')
    return "\n".join(svg)


def export_svg_file(rolls, original_dims, item_margins):
    """

    Tulis hasil render_svg() ke file .svg di folder 'exports/' dan kembalikan

    path-nya, supaya bisa dipakai sebagai output gr.File (tombol download).

    Nama file memakai uuid4 (bukan timestamp detik) supaya aman dipakai

    banyak user sekaligus di HuggingFace Space publik tanpa risiko

    tabrakan/overwrite antar request yang terjadi di detik yang sama.

    """
    if not rolls or not original_dims:
        return None
    svg_str = render_svg(rolls, original_dims, item_margins or {})
    if not svg_str:
        return None

    import os
    import uuid

    out_dir = "exports"
    os.makedirs(out_dir, exist_ok=True)
    path = os.path.join(out_dir, f"nesting_layout_{uuid.uuid4().hex}.svg")
    with open(path, "w", encoding="utf-8") as f:
        f.write(svg_str)
    return path


# --------------------------------------------------------------------------
# 6. STRATEGI PRE-SORT
# --------------------------------------------------------------------------

def get_pre_sort_strategies(rects):
    strategies = []

    def area(r):
        return r[0] * r[1]

    def max_side(r):
        return max(r[0], r[1])

    def ratio(r):
        return max(r[0], r[1]) / max(min(r[0], r[1]), 0.001)

    base = [
        ("default", rects[:]),
        ("area_desc", sorted(rects, key=area, reverse=True)),
        ("area_asc", sorted(rects, key=area)),
        ("width_desc", sorted(rects, key=lambda r: r[0], reverse=True)),
        ("width_asc", sorted(rects, key=lambda r: r[0])),
        ("height_desc", sorted(rects, key=lambda r: r[1], reverse=True)),
        ("height_asc", sorted(rects, key=lambda r: r[1])),
        ("longest_desc", sorted(rects, key=max_side, reverse=True)),
        ("ratio_desc", sorted(rects, key=ratio, reverse=True)),
        ("ratio_asc", sorted(rects, key=ratio)),
    ]
    strategies.extend(base)

    label_groups = {}
    for r in rects:
        label = r[2].rsplit("#", 1)[0]
        label_groups.setdefault(label, []).append(r)
    grouped = []
    for label in sorted(label_groups.keys()):
        grouped.extend(label_groups[label])
    strategies.append(("group_label", grouped))

    by_area = sorted(rects, key=area, reverse=True)
    interleaved = []
    i, j = 0, len(by_area) - 1
    while i <= j:
        interleaved.append(by_area[i])
        if i != j:
            interleaved.append(by_area[j])
        i += 1
        j -= 1
    strategies.append(("interleave", interleaved))
    return strategies


# --------------------------------------------------------------------------
# 7. SIMULATED ANNEALING
# --------------------------------------------------------------------------

def calculate_waste(rolls, original_dims):
    total_true = sum(
        original_dims[r.rid][0] * original_dims[r.rid][1]
        for placed, _, _ in rolls for r in placed
    )
    total_roll = sum(w * h for _, h, w in rolls)
    return total_roll - total_true, (total_roll - total_true) / total_roll * 100 if total_roll else 100


def unified_key(waste, num_rolls, not_placed):
    """

    Langkah 5: format key SATU-SATUNYA yang dipakai untuk membandingkan

    hasil single-width, multi-width, dan mode cepat, supaya perbandingan

    `key < best_key` semantiknya valid di seluruh jalur di process().

    Item yang tidak muat diberi penalti besar (bukan diskualifikasi total),

    supaya solusi yang menempatkan semua item selalu diprioritaskan tapi

    solusi hampir-sempurna tetap bisa bersaing.

    """
    return (waste + not_placed * 1e6, num_rolls, not_placed)


def simulated_annealing(rects, roll_width, max_height, allow_rotation,

                        pack_algo, sort_algo, original_dims,

                        initial_temp=100, cooling=0.995, max_iter=3000,

                        stall_limit=250, reheat_factor=0.6, seed=None):
    """

    Perbaikan #4: menambah dua mekanisme supaya SA tidak terjebak di local

    optimum begitu saja:

      - REHEATING: kalau tidak ada perbaikan pada `best_waste` selama

        `stall_limit` iterasi berturut-turut, suhu dinaikkan kembali

        (temp = initial_temp * reheat_factor) supaya SA berani "melompat"

        keluar dari lembah lokal yang sedang dieksplorasi, alih-alih terus

        mendingin menuju nol dan berhenti bergerak.

      - SEED: parameter `seed` memungkinkan tiap chain SA (dijalankan

        paralel lewat _run_parallel) benar-benar independen satu sama lain

        (multi-start), bukan mengulang jalur pencarian yang persis sama.

    """
    rng = random.Random(seed) if seed is not None else random
    current = rects[:]
    best = rects[:]
    best_result = None
    best_waste = float('inf')
    current_result, _ = pack_multi_roll(
        current, roll_width, max_height, allow_rotation, pack_algo, sort_algo, False
    )
    if not current_result:
        return None, float('inf')
    current_waste, _ = calculate_waste(current_result, original_dims)

    temp = initial_temp
    stall = 0

    for i in range(max_iter):
        neighbor = current[:]
        op = rng.choice(['swap', 'reverse', 'insert'])
        if op == 'swap' and len(neighbor) > 1:
            a, b = rng.sample(range(len(neighbor)), 2)
            neighbor[a], neighbor[b] = neighbor[b], neighbor[a]
        elif op == 'reverse' and len(neighbor) > 2:
            a, b = sorted(rng.sample(range(len(neighbor)), 2))
            neighbor[a:b + 1] = list(reversed(neighbor[a:b + 1]))
        elif op == 'insert' and len(neighbor) > 1:
            a = rng.randint(0, len(neighbor) - 1)
            b = rng.randint(0, len(neighbor) - 1)
            item = neighbor.pop(a)
            neighbor.insert(b, item)

        rolls, _ = pack_multi_roll(
            neighbor, roll_width, max_height, allow_rotation, pack_algo, sort_algo, False
        )
        if not rolls:
            stall += 1
        else:
            waste, _ = calculate_waste(rolls, original_dims)

            if waste < best_waste - 1e-9:
                best_waste = waste
                best = neighbor[:]
                best_result = rolls
                stall = 0
            else:
                stall += 1

            if waste < current_waste or rng.random() < math.exp((current_waste - waste) / max(temp, 0.001)):
                current = neighbor[:]
                current_waste = waste

        if stall >= stall_limit:
            temp = initial_temp * reheat_factor
            stall = 0
        else:
            temp *= cooling

    return best_result, best_waste


# --------------------------------------------------------------------------
# 8. MULTI-WIDTH MULTI-ROLL (FIXED: tambah original_dims parameter)
# --------------------------------------------------------------------------

def _try_pack_width(remaining, w, max_height, allow_rotation, pack_algo, sort_algo, original_dims):
    """

    Helper: coba pack 'remaining' rects ke satu bin lebar w. Return None kalau

    gagal, atau (waste, placed, used_height, new_remaining) kalau berhasil.

    Dipakai bersama oleh pack_multi_width_multi_roll (greedy dan lookahead).

    """
    kwargs = {"rotation": allow_rotation}
    if pack_algo:
        kwargs["pack_algo"] = pack_algo
    if sort_algo:
        kwargs["sort_algo"] = sort_algo
    packer = newPacker(**kwargs)
    for rect_w, rect_h, rid in remaining:
        packer.add_rect(rect_w, rect_h, rid=rid)
    packer.add_bin(w, max_height)
    packer.pack()

    if len(packer) == 0 or len(packer[0]) == 0:
        return None

    placed = packer[0]
    used_height = max(r.y + r.height for r in placed)
    placed_ids = {r.rid for r in placed}

    true_area = sum(
        (original_dims[rid][0] * original_dims[rid][1])
        for _, _, rid in remaining if rid in placed_ids
    )
    roll_area = w * used_height
    waste = roll_area - true_area
    new_remaining = [r for r in remaining if r[2] not in placed_ids]
    return waste, placed, used_height, new_remaining


def pack_multi_width_multi_roll(rects, widths, max_height, allow_rotation,

                                original_dims,  # <-- FIX: tambah parameter ini

                                pack_algo=None, sort_algo=None, reverse=False,

                                lookahead=False, lookahead_k=3):
    """

    Packing di mana TIAP ROLL boleh beda lebar.



    Langkah 4: bila lookahead=True, alih-alih langsung memilih lebar dengan

    waste terkecil untuk roll SAAT INI saja (murni greedy), fungsi ini

    mengambil top-`lookahead_k` kandidat lebar berdasar waste roll ini, lalu

    untuk tiap kandidat mengintip 1 roll ke depan (waste terbaik yang bisa

    dicapai pada sisa item) dan memilih kandidat dengan total waste gabungan

    (roll ini + estimasi roll berikutnya) terkecil. Ini membantu menghindari

    jebakan lokal di mana pilihan yang "tampak" optimal untuk roll saat ini

    justru membuat sisa item sulit dinestik secara efisien di roll berikutnya.

    """
    remaining = list(reversed(rects)) if reverse else rects[:]
    all_rolls = []
    safety = 50

    for _ in range(safety):
        if not remaining:
            break

        candidates = []
        for w in widths:
            res = _try_pack_width(remaining, w, max_height, allow_rotation,
                                  pack_algo, sort_algo, original_dims)
            if res is None:
                continue
            waste, placed, used_height, new_remaining = res
            candidates.append((waste, placed, used_height, w, new_remaining))

        if not candidates:
            return all_rolls, len(remaining)

        candidates.sort(key=lambda c: c[0])

        if not lookahead or len(candidates) <= 1:
            chosen = candidates[0]
        else:
            topk = candidates[:lookahead_k]
            chosen = None
            best_total = float('inf')
            for waste, placed, used_height, w, new_remaining in topk:
                if new_remaining:
                    # Intip 1 langkah ke depan: waste terbaik di antara semua
                    # lebar untuk sisa item setelah kandidat ini dipilih.
                    next_best = float('inf')
                    for w2 in widths:
                        res2 = _try_pack_width(new_remaining, w2, max_height, allow_rotation,
                                               pack_algo, sort_algo, original_dims)
                        if res2 is not None and res2[0] < next_best:
                            next_best = res2[0]
                    total = waste + (next_best if next_best != float('inf') else 0)
                else:
                    total = waste
                if total < best_total:
                    best_total = total
                    chosen = (waste, placed, used_height, w, new_remaining)

        _, placed, used_height, w, new_remaining = chosen
        all_rolls.append((placed, used_height, w))
        remaining = new_remaining

    return all_rolls, len(remaining)


# --------------------------------------------------------------------------
# 8b. SIMULATED ANNEALING UNTUK MULTI-WIDTH MULTI-ROLL (Langkah 2)
# --------------------------------------------------------------------------

def simulated_annealing_multi_width(rects, widths, max_height, allow_rotation,

                                    pack_algo, sort_algo, original_dims,

                                    initial_temp=100, cooling=0.995, max_iter=1500,

                                    stall_limit=200, reheat_factor=0.6, seed=None):
    """

    Versi SA dari simulated_annealing(), tapi memakai pack_multi_width_multi_roll

    sebagai fungsi evaluasi sehingga tiap roll boleh punya lebar berbeda.

    Key evaluasi memakai (waste, not_placed) supaya solusi yang menempatkan

    semua item tetap diprioritaskan, tapi solusi dengan sedikit item tidak

    muat tidak langsung dibuang (lihat _mw_score).



    Perbaikan #4: reheating (keluar dari local optimum saat stagnan) dan

    dukungan `seed` untuk multi-start yang benar-benar independen.

    """
    def _mw_score(rolls, not_placed):
        waste, _ = calculate_waste(rolls, original_dims)
        # Penalti besar per item tidak muat, tapi tidak diskualifikasi total
        return waste + not_placed * 1e6, waste

    rng = random.Random(seed) if seed is not None else random
    current = rects[:]
    best = rects[:]
    best_result = None
    best_not_placed = None
    best_waste = float('inf')
    best_score = float('inf')

    current_result, current_not_placed = pack_multi_width_multi_roll(
        current, widths, max_height, allow_rotation, original_dims, pack_algo, sort_algo, False
    )
    if not current_result:
        return None, float('inf'), None
    current_score, current_waste = _mw_score(current_result, current_not_placed)
    best_result, best_not_placed, best_waste, best_score = (
        current_result, current_not_placed, current_waste, current_score
    )

    temp = initial_temp
    stall = 0

    for _ in range(max_iter):
        neighbor = current[:]
        op = rng.choice(['swap', 'reverse', 'insert'])
        if op == 'swap' and len(neighbor) > 1:
            a, b = rng.sample(range(len(neighbor)), 2)
            neighbor[a], neighbor[b] = neighbor[b], neighbor[a]
        elif op == 'reverse' and len(neighbor) > 2:
            a, b = sorted(rng.sample(range(len(neighbor)), 2))
            neighbor[a:b + 1] = list(reversed(neighbor[a:b + 1]))
        elif op == 'insert' and len(neighbor) > 1:
            a = rng.randint(0, len(neighbor) - 1)
            b = rng.randint(0, len(neighbor) - 1)
            item = neighbor.pop(a)
            neighbor.insert(b, item)

        rolls, not_placed = pack_multi_width_multi_roll(
            neighbor, widths, max_height, allow_rotation, original_dims, pack_algo, sort_algo, False
        )
        if not rolls:
            stall += 1
        else:
            score, waste = _mw_score(rolls, not_placed)

            if score < best_score - 1e-9:
                best_score = score
                best_waste = waste
                best_not_placed = not_placed
                best = neighbor[:]
                best_result = rolls
                stall = 0
            else:
                stall += 1

            if score < current_score or rng.random() < math.exp((current_score - score) / max(temp, 0.001)):
                current = neighbor[:]
                current_score = score

        if stall >= stall_limit:
            temp = initial_temp * reheat_factor
            stall = 0
        else:
            temp *= cooling

    return best_result, best_waste, best_not_placed


# --------------------------------------------------------------------------
# 8c. PARALLEL EXECUTION HELPERS (Perbaikan #3)
# --------------------------------------------------------------------------
# Semua worker di bawah ini WAJIB berupa fungsi top-level (bukan closure/
# nested function) supaya bisa di-pickle dan dikirim ke proses worker oleh
# ProcessPoolExecutor. Tiap worker menerima satu tuple argumen (payload)
# dan mengembalikan hasil yang ringkas (bukan object rectpack mentah bila
# tidak perlu), supaya biaya serialisasi antar-proses tetap murah.

# Jumlah worker proses dibatasi supaya tidak membebani host (mis. HF Spaces
# free tier biasanya cuma 2 vCPU). Bisa di-override lewat env var kalau perlu.
_MAX_WORKERS = max(1, min(int(os.environ.get("NESTING_MAX_WORKERS", os.cpu_count() or 2)), 8))

# Berapa banyak "chain" independen yang dijalankan untuk tiap konfigurasi SA
# (multi-start). Tiap chain pakai seed acak berbeda supaya benar-benar
# menjelajah ruang solusi yang berbeda, bukan cuma mengulang jalur yang sama.
_SA_STARTS = 3


def _run_parallel(worker_fn, tasks):
    """

    Jalankan `worker_fn` untuk tiap item di `tasks` secara paralel memakai

    proses terpisah (menghindari GIL, supaya CPU-bound packing benar-benar

    berjalan bersamaan). Kalau environment tidak mengizinkan pembuatan

    proses baru (mis. container sandboxed), otomatis fallback ke eksekusi

    sekuensial biasa, supaya fitur ini tidak pernah membuat aplikasi crash.

    """
    if not tasks:
        return []
    if len(tasks) == 1 or _MAX_WORKERS <= 1:
        return [worker_fn(t) for t in tasks]
    try:
        max_workers = min(len(tasks), _MAX_WORKERS)
        with concurrent.futures.ProcessPoolExecutor(max_workers=max_workers) as executor:
            return list(executor.map(worker_fn, tasks))
    except Exception:
        # Fallback aman: platform tidak mendukung multiprocessing (mis.
        # beberapa sandbox), atau objek gagal di-pickle. Jangan sampai
        # optimasi paralel mematikan fitur inti.
        return [worker_fn(t) for t in tasks]


def _grid_worker(payload):
    """Worker untuk satu kombinasi (pack_algo, sort_algo, reverse) — single width."""
    (rects, roll_width, max_height, allow_rotation, pack_algo, sort_algo,
     reverse, original_dims, label) = payload
    try:
        rolls, not_placed = pack_multi_roll(
            rects, roll_width, max_height, allow_rotation, pack_algo, sort_algo, reverse
        )
    except Exception:
        return (label, None, None, None)
    if not rolls:
        return (label, None, None, None)
    waste, _ = calculate_waste(rolls, original_dims)
    return (label, rolls, not_placed, waste)


def _sa_worker(payload):
    """Worker untuk satu chain Simulated Annealing (single width, multi-start)."""
    (rects, roll_width, max_height, allow_rotation, pack_algo, sort_algo,
     original_dims, initial_temp, cooling, max_iter, stall_limit,
     reheat_factor, seed, label) = payload
    rolls, waste = simulated_annealing(
        rects, roll_width, max_height, allow_rotation, pack_algo, sort_algo,
        original_dims, initial_temp=initial_temp, cooling=cooling,
        max_iter=max_iter, stall_limit=stall_limit,
        reheat_factor=reheat_factor, seed=seed,
    )
    return (label, rolls, waste)


def _swap_worker(payload):
    """Worker untuk satu percobaan local-swap (Fase 4)."""
    (order, roll_width, max_height, allow_rotation, original_dims, label) = payload
    rolls, not_placed = pack_multi_roll(order, roll_width, max_height, allow_rotation, None, None, False)
    if not rolls:
        return (label, None, None, None)
    waste, _ = calculate_waste(rolls, original_dims)
    return (label, rolls, not_placed, waste)


def _mw_grid_worker(payload):
    """Worker untuk satu kombinasi (pack_algo, sort_algo, reverse) — multi-width."""
    (rects, widths, max_height, allow_rotation, original_dims, pack_algo,
     sort_algo, reverse, label) = payload
    rolls, not_placed = pack_multi_width_multi_roll(
        rects, widths, max_height, allow_rotation, original_dims, pack_algo, sort_algo, reverse
    )
    return (label, rolls, not_placed)


def _mw_lookahead_worker(payload):
    """Worker untuk satu konfigurasi lookahead — multi-width."""
    (rects, widths, max_height, allow_rotation, original_dims, pack_algo,
     sort_algo, label) = payload
    rolls, not_placed = pack_multi_width_multi_roll(
        rects, widths, max_height, allow_rotation, original_dims, pack_algo, sort_algo, False,
        lookahead=True, lookahead_k=3
    )
    return (label, rolls, not_placed)


def _sa_mw_worker(payload):
    """Worker untuk satu chain Simulated Annealing multi-width (multi-start)."""
    (rects, widths, max_height, allow_rotation, pack_algo, sort_algo,
     original_dims, initial_temp, cooling, max_iter, stall_limit,
     reheat_factor, seed, label) = payload
    rolls, waste, not_placed = simulated_annealing_multi_width(
        rects, widths, max_height, allow_rotation, pack_algo, sort_algo,
        original_dims, initial_temp=initial_temp, cooling=cooling,
        max_iter=max_iter, stall_limit=stall_limit,
        reheat_factor=reheat_factor, seed=seed,
    )
    return (label, rolls, waste, not_placed)


# --------------------------------------------------------------------------
# 9. PENCARIAN UNTUK SATU LEBAR ROLL
# --------------------------------------------------------------------------

def search_single_width(rects, original_dims, total_rects, max_height,

                        roll_width, item_margins, allow_rotation,

                        search_mode, target_waste_pct, px_per_unit):
    best_result = None
    best_key = None
    best_config = None
    best_rolls = None
    tried, failed = 0, 0
    hit_target = False

    def consider(rolls, not_placed, config_name):
        """

        Perbaikan #1: dulu fungsi ini (`evaluate`) memakai key

        (waste, num_rolls, not_placed) TANPA penalti — beda dengan

        `unified_key` yang dipakai process() untuk membandingkan lintas

        lebar roll. Akibatnya "terbaik per lebar" bisa tidak konsisten

        dengan perbandingan level atas. Sekarang keduanya memakai

        `unified_key` yang sama persis.

        """
        nonlocal best_result, best_key, best_config, best_rolls, hit_target
        if not rolls:
            return
        waste, waste_pct = calculate_waste(rolls, original_dims)
        num_rolls = len(rolls)
        key = unified_key(waste, num_rolls, not_placed)
        if best_key is None or key < best_key:
            best_key = key
            best_result = (rolls, not_placed)
            best_config = config_name
            best_rolls = rolls
        if waste_pct <= target_waste_pct and not_placed == 0:
            hit_target = True

    def should_stop():
        return hit_target

    def consider_batch(results):
        """Reduce hasil satu batch paralel: catat tried/failed lalu consider()."""
        nonlocal tried, failed
        for label, rolls, not_placed, waste in results:
            tried += 1
            if not rolls:
                failed += 1
                continue
            consider(rolls, not_placed, label)

    ALL_PACK = [
        None, MaxRectsBssf, MaxRectsBaf, MaxRectsBl, MaxRectsBlsf,
        SkylineBl, SkylineBlWm, SkylineMwf, SkylineMwfl,
        SkylineMwfWm, SkylineMwflWm,
        GuillotineBssfSas, GuillotineBssfLas, GuillotineBssfMaxas,
        GuillotineBafSas, GuillotineBafLas, GuillotineBafMaxas,
        GuillotineBlsfSas, GuillotineBlsfLas,
    ]
    ALL_SORT = [None, SORT_AREA, SORT_PERI, SORT_LSIDE, SORT_RATIO, SORT_DIFF]

    # PHASE 1: GRID SEARCH (Perbaikan #3: satu batch besar dievaluasi paralel
    # lintas proses, bukan sekuensial satu-per-satu — jauh lebih cepat untuk
    # ratusan kombinasi algo x sort x reverse pada mode deep/pro/exhaustive)
    if search_mode in ("standard", "deep", "pro", "exhaustive"):
        if search_mode == "standard":
            pack_algos = [None, MaxRectsBssf, MaxRectsBaf, MaxRectsBlsf,
                          SkylineMwfl, GuillotineBssfSas, GuillotineBafSas]
            sort_algos = [None, SORT_AREA, SORT_LSIDE]
        else:
            pack_algos, sort_algos = ALL_PACK, ALL_SORT

        tasks = []
        for pack_algo in pack_algos:
            for sort_algo in sort_algos:
                for reverse in [False, True]:
                    algo_name = pack_algo.__name__ if pack_algo else "Default"
                    label = f"[Grid] {algo_name} + {get_sort_name(sort_algo)}{' rev' if reverse else ''}"
                    tasks.append((rects, roll_width, max_height, allow_rotation,
                                  pack_algo, sort_algo, reverse, original_dims, label))
        consider_batch(_run_parallel(_grid_worker, tasks))

    # PHASE 2: PRE-SORT (dijalankan hanya kalau Fase 1 belum capai target)
    if search_mode in ("pro", "exhaustive") and not should_stop():
        tasks = []
        for sort_name, sorted_rects in get_pre_sort_strategies(rects):
            for pack_algo in [None, MaxRectsBssf, GuillotineBssfSas]:
                for reverse in [False, True]:
                    algo_name = pack_algo.__name__ if pack_algo else "Default"
                    label = f"[PreSort:{sort_name}] {algo_name}{' rev' if reverse else ''}"
                    tasks.append((sorted_rects, roll_width, max_height, allow_rotation,
                                  pack_algo, SORT_NONE, reverse, original_dims, label))
        consider_batch(_run_parallel(_grid_worker, tasks))

    # PHASE 3: SIMULATED ANNEALING (Perbaikan #4: multi-start — tiap
    # kombinasi (pack_algo, sort_algo) dijalankan sebagai beberapa chain
    # independen dengan seed berbeda dan reheating aktif, semua dieksekusi
    # paralel, lalu diambil chain dengan waste terkecil.)
    if search_mode in ("pro", "exhaustive") and not should_stop():
        sa_configs = [
            (None, None), (MaxRectsBssf, SORT_AREA), (GuillotineBssfSas, SORT_AREA)
        ]
        max_iter = 5000 if search_mode == "exhaustive" else 2000
        tasks = []
        for pack_algo, sort_algo in sa_configs:
            algo_name = pack_algo.__name__ if pack_algo else "Default"
            for start in range(_SA_STARTS):
                seed = random.randint(0, 2**31 - 1)
                label = f"[SA] {algo_name} (start {start + 1}/{_SA_STARTS})"
                tasks.append((rects, roll_width, max_height, allow_rotation,
                              pack_algo, sort_algo, original_dims,
                              100, 0.995, max_iter, 250, 0.6, seed, label))
        results = _run_parallel(_sa_worker, tasks)
        for label, sa_rolls, sa_waste in results:
            tried += 1
            if sa_rolls:
                consider(sa_rolls, 0, f"{label} (waste {sa_waste:.1f})")
            else:
                failed += 1

    # PHASE 4: LOCAL SWAP (dievaluasi sebagai satu batch paralel alih-alih
    # perbaikan sekuensial satu-satu; sedikit kehilangan sifat "progresif"
    # tapi jauh lebih banyak kandidat swap yang bisa dicoba dalam waktu sama)
    if search_mode == "exhaustive" and best_rolls and not should_stop():
        best_order = []
        placed_ids = set()
        for placed, _, _ in best_rolls:
            for r in placed:
                placed_ids.add(r.rid)
        for r in rects:
            if r[2] in placed_ids:
                best_order.append(r)

        n = len(best_order)
        n_trials = min(500, n * n) if n > 1 else 0
        tasks = []
        seen_pairs = set()
        attempts = 0
        while len(tasks) < n_trials and attempts < n_trials * 4:
            attempts += 1
            i, j = random.randint(0, n - 1), random.randint(0, n - 1)
            if i == j or (i, j) in seen_pairs:
                continue
            seen_pairs.add((i, j))
            swapped = best_order[:]
            swapped[i], swapped[j] = swapped[j], swapped[i]
            tasks.append((swapped, roll_width, max_height, allow_rotation,
                          original_dims, f"[Swap:{i}-{j}]"))
        consider_batch(_run_parallel(_swap_worker, tasks))

    if best_result is None:
        return None, f"⚠️ Lebar {roll_width:g} cm: tidak muat.", None, None, None, tried, False, None, None

    rolls, not_placed = best_result
    img, total_true, total_roll, total_rot = render_multi_roll(
        rolls, original_dims, item_margins, px_per_unit
    )
    waste, waste_pct = calculate_waste(rolls, original_dims)
    num_rolls = len(rolls)

    is_guillotine, g_violations = is_guillotine_cuttable(rolls)

    target_status = "✅ TARGET TERCAPAI!" if waste_pct <= target_waste_pct else "❌ Target belum tercapai"

    stats = [
        f"{'🎯' if waste_pct <= target_waste_pct else '⚠️'} {target_status}",
        f"🏆 Algoritma terpilih         : {best_config}",
        f"🔍 Mode                       : {search_mode.upper()}",
        f"🔍 Iterasi dicoba             : {tried} (gagal: {failed})",
        f"📏 Lebar roll                 : {roll_width:g} cm",
        f"📦 Jumlah roll                : {num_rolls}",
        f"📏 Total panjang              : {sum(h for _, h, _ in rolls):.1f} cm",
        f"✅ Item ditempatkan           : {sum(len(p) for p, _, _ in rolls)} / {total_rects}",
        f"🔄 Diputar 90°                : {total_rot}",
        f"📐 Luas item (asli)           : {total_true:.1f} cm²",
        f"📐 Luas roll terpakai         : {total_roll:.1f} cm²",
        f"♻️ TOTAL WASTE                : {waste:.1f} cm²",
        f"📊 Persentase waste           : {waste_pct:.2f}%  (target: ≤{target_waste_pct}%)",
        f"🔪 Guillotine cuttable        : {'✅ Ya' if is_guillotine else f'⚠️ Tidak ({g_violations} pelanggaran)'}",
    ]
    if not_placed > 0:
        stats.insert(7, f"⚠️ Item TIDAK muat             : {not_placed}")

    return img, "\n".join(stats), waste, waste_pct, num_rolls, tried, hit_target, not_placed, rolls


# --------------------------------------------------------------------------
# 10. FUNGSI UTAMA
# --------------------------------------------------------------------------

def process(roll_widths_text, allow_rotation, search_mode, target_waste_pct,

            enable_multiwidth, table_data):
    if table_data is None or len(table_data) == 0:
        return None, "⚠️ Silakan isi tabel daftar banner terlebih dahulu.", None, None, None

    df = pd.DataFrame(table_data, columns=["Label", "Width", "Height", "Margin"])
    df = df.dropna(subset=["Width", "Height"], how="any")
    df["Margin"] = pd.to_numeric(df["Margin"], errors="coerce").fillna(0.0)

    try:
        widths = [float(w.strip()) for w in roll_widths_text.split(",") if w.strip()]
        widths = [w for w in widths if w > 0]
    except ValueError:
        return None, "⚠️ Format daftar lebar roll tidak valid.", None, None, None

    if not widths:
        return None, "⚠️ Masukkan minimal satu lebar roll yang valid.", None, None, None

    try:
        target_waste_pct = float(target_waste_pct)
        if target_waste_pct < 0:
            target_waste_pct = 5.0
    except (TypeError, ValueError):
        target_waste_pct = 5.0

    rects, original_dims, item_margins, total_rects, max_height = prepare_rects(df, bool(allow_rotation))
    if rects is None:
        return None, "⚠️ Tidak ada data banner yang valid.", None, None, None

    # Auto-generate lebar tambahan
    # MURNI MENGGUNAKAN INPUT USER (TANPA AUTO-GENERATE)
    # Hitung lebar roll minimal yang dibutuhkan.
    # PERBAIKAN BUG: sebelumnya kode selalu memakai kolom "Width" (w) saja,
    # padahal kalau rotasi diizinkan, sisi manapun dari banner bisa menempel
    # ke arah lebar roll — jadi syarat muatnya adalah SISI TERPENDEK + margin,
    # bukan w + margin. Akibatnya banner yang sebenarnya muat (setelah
    # diputar) malah ditolak duluan di sini sebelum sempat dicoba di-nesting.
    if allow_rotation:
        min_banner_w = max(
            min(w, h) + item_margins[rid] * 2 for rid, (w, h) in original_dims.items()
        )
    else:
        min_banner_w = max(
            w + item_margins[rid] * 2 for rid, (w, h) in original_dims.items()
        )

# Filter: Hanya ambil lebar roll dari input user yang >= lebar minimal yang dibutuhkan
    all_widths = sorted([w for w in widths if w >= min_banner_w])

# Validasi jika tidak ada lebar roll yang cocok
    if not all_widths:
        rotasi_note = (
            "(sudah memperhitungkan rotasi — sisi terpendek banner + margin)"
            if allow_rotation else
            "(rotasi tidak diaktifkan, jadi memakai kolom Width apa adanya)"
        )
        return None, (
            f"⚠️ Tidak ada lebar roll yang valid untuk menampung banner.\n"
            f"Lebar roll minimal yang diinput harus ≥ {min_banner_w:.1f} cm "
            f"(Lebar banner terbesar yang dibutuhkan + margin item tersebut) {rotasi_note}."
        ), None, None, None

    best_overall = None
    best_key = None
    best_width = None
    width_results = []
    global_tried = 0

    # MULTI-WIDTH MULTI-ROLL
    if enable_multiwidth and search_mode in ("pro", "exhaustive"):
        tried = 0
        mw_best_rolls = None
        mw_best_not_placed = None
        mw_best_config = None
        # key global untuk multi-width sendiri: (waste + penalti not_placed, num_rolls)
        # dibandingkan terpisah dari single-width supaya kombinasi terbaik multi-width
        # yang benar-benar ditemukan (bukan cuma kombinasi pertama yang all-placed)
        mw_best_key = None

        def _mw_key(rolls, not_placed):
            waste, _ = calculate_waste(rolls, original_dims)
            return unified_key(waste, len(rolls), not_placed)

        def _consider_mw(rolls, not_placed, config_name):
            nonlocal mw_best_rolls, mw_best_not_placed, mw_best_config, mw_best_key
            if not rolls:
                return
            key = _mw_key(rolls, not_placed)
            if mw_best_key is None or key < mw_best_key:
                mw_best_key = key
                mw_best_rolls = rolls
                mw_best_not_placed = not_placed
                mw_best_config = config_name

        # Perbaikan #3: Fase A/B/D dibangun sebagai daftar task lalu
        # dievaluasi paralel lintas proses lewat _run_parallel, alih-alih
        # loop sekuensial murni. Fase C (SA) memakai multi-start (Perbaikan
        # #4) yang juga paralel.

        # --- Fase A: grid search dasar (kombinasi algo x sort x reverse) ---
        tasks = []
        for pack_algo in [None, MaxRectsBssf, GuillotineBssfSas]:
            for sort_algo in [None, SORT_AREA]:
                for reverse in [False, True]:
                    algo_name = pack_algo.__name__ if pack_algo else "Default"
                    label = f"[Grid] {algo_name}+{get_sort_name(sort_algo)}{' rev' if reverse else ''}"
                    tasks.append((rects, all_widths, max_height, allow_rotation,
                                  original_dims, pack_algo, sort_algo, reverse, label))
        for label, rolls, not_placed in _run_parallel(_mw_grid_worker, tasks):
            tried += 1
            _consider_mw(rolls, not_placed, label)

        # --- Fase B (Langkah 1): pre-sort strategies, sama seperti single-width ---
        if search_mode in ("pro", "exhaustive"):
            tasks = []
            for sort_name, sorted_rects in get_pre_sort_strategies(rects):
                for pack_algo in [None, MaxRectsBssf, GuillotineBssfSas]:
                    for reverse in [False, True]:
                        algo_name = pack_algo.__name__ if pack_algo else "Default"
                        label = f"[MW-PreSort:{sort_name}] {algo_name}{' rev' if reverse else ''}"
                        tasks.append((sorted_rects, all_widths, max_height, allow_rotation,
                                      original_dims, pack_algo, SORT_NONE, reverse, label))
            for label, rolls, not_placed in _run_parallel(_mw_grid_worker, tasks):
                tried += 1
                _consider_mw(rolls, not_placed, label)

        # --- Fase C (Langkah 2): Simulated Annealing versi multi-width,
        # sekarang dengan multi-start (Perbaikan #4) ---
        if search_mode in ("pro", "exhaustive"):
            sa_mw_configs = [
                (None, None), (MaxRectsBssf, SORT_AREA), (GuillotineBssfSas, SORT_AREA)
            ]
            max_iter = 2500 if search_mode == "exhaustive" else 1200
            tasks = []
            for pack_algo, sort_algo in sa_mw_configs:
                algo_name = pack_algo.__name__ if pack_algo else "Default"
                for start in range(_SA_STARTS):
                    seed = random.randint(0, 2**31 - 1)
                    label = f"[MW-SA] {algo_name} (start {start + 1}/{_SA_STARTS})"
                    tasks.append((rects, all_widths, max_height, allow_rotation,
                                  pack_algo, sort_algo, original_dims,
                                  100, 0.995, max_iter, 200, 0.6, seed, label))
            for label, sa_rolls, sa_waste, sa_not_placed in _run_parallel(_sa_mw_worker, tasks):
                tried += 1
                if sa_rolls:
                    _consider_mw(sa_rolls, sa_not_placed, f"{label} (waste {sa_waste:.1f})")

        # --- Fase D (Langkah 4): pilihan lebar dgn lookahead 1-langkah ---
        # Dibatasi ke beberapa config saja karena tiap panggilan lebih mahal
        # (evaluasi top-k kandidat x semua lebar untuk mengintip roll berikutnya).
        if search_mode in ("pro", "exhaustive"):
            lookahead_configs = [(None, None), (MaxRectsBssf, SORT_AREA)]
            tasks = []
            for pack_algo, sort_algo in lookahead_configs:
                for sort_name, sorted_rects in [("default", rects), ("area_desc",
                        sorted(rects, key=lambda r: r[0] * r[1], reverse=True))]:
                    algo_name = pack_algo.__name__ if pack_algo else "Default"
                    label = f"[MW-Lookahead:{sort_name}] {algo_name}"
                    tasks.append((sorted_rects, all_widths, max_height, allow_rotation,
                                  original_dims, pack_algo, sort_algo, label))
            for label, rolls, not_placed in _run_parallel(_mw_lookahead_worker, tasks):
                tried += 1
                _consider_mw(rolls, not_placed, label)

        # --- Bandingkan hasil terbaik multi-width dengan best_overall global ---
        if mw_best_rolls is not None:
            waste, waste_pct = calculate_waste(mw_best_rolls, original_dims)
            key = unified_key(waste, len(mw_best_rolls), mw_best_not_placed)
            if best_key is None or key < best_key:
                best_key = key
                img, total_true, total_roll, total_rot = render_multi_roll(
                    mw_best_rolls, original_dims, item_margins
                )
                is_g, g_v = is_guillotine_cuttable(mw_best_rolls)
                stats = [
                    "🎯 MULTI-WIDTH MULTI-ROLL (tiap roll beda lebar)",
                    f"🏆 Algoritma terpilih         : {mw_best_config}",
                    f"🔍 Iterasi dicoba (multi-width): {tried}",
                    f"📦 Jumlah roll                : {len(mw_best_rolls)}",
                    f"📏 Lebar per roll             : {', '.join(f'{w:.0f}' for _, _, w in mw_best_rolls)} cm",
                    f"📏 Total panjang              : {sum(h for _, h, _ in mw_best_rolls):.1f} cm",
                    f"✅ Item ditempatkan           : {sum(len(p) for p, _, _ in mw_best_rolls)} / {total_rects}",
                    f"♻️ TOTAL WASTE                : {waste:.1f} cm²",
                    f"📊 Persentase waste           : {waste_pct:.2f}%  (target: ≤{target_waste_pct}%)",
                    f"🔪 Guillotine cuttable        : {'✅ Ya' if is_g else f'⚠️ Tidak ({g_v} pelanggaran)'}",
                ]
                if mw_best_not_placed:
                    stats.insert(7, f"⚠️ Item TIDAK muat             : {mw_best_not_placed}")
                best_overall = (img, "\n".join(stats), waste, waste_pct, mw_best_rolls)
                best_width = "multi"
            # Langkah 6 (persiapan): masukkan hasil multi-width ke tabel perbandingan juga
            width_results.append(("multi", waste, waste_pct, len(mw_best_rolls), f"{waste_pct:.2f}%"))
            global_tried += tried

    # SINGLE-WIDTH per lebar
    for width in all_widths:
        if search_mode == "quick":
            result = pack_multi_roll(rects, width, max_height, bool(allow_rotation))
            if not result or not result[0]:
                width_results.append((width, None, None, "Gagal"))
                continue
            rolls, not_placed = result
            img, total_true, total_roll, total_rot = render_multi_roll(
                rolls, original_dims, item_margins
            )
            waste, waste_pct = calculate_waste(rolls, original_dims)
            num_rolls = len(rolls)

            stats = [
                f"🏆 Mode                       : CEPAT",
                f"📏 Lebar roll                 : {width:g} cm",
                f"📦 Jumlah roll                : {num_rolls}",
                f"♻️ Total waste                : {waste:.1f} cm²",
                f"📊 Persentase waste           : {waste_pct:.2f}%",
            ]

            key = unified_key(waste, num_rolls, not_placed)
            if best_key is None or key < best_key:
                best_key = key
                best_overall = (img, "\n".join(stats), waste, waste_pct, rolls)
                best_width = width

            width_results.append((width, waste, waste_pct, num_rolls, f"{waste_pct:.2f}%"))
            global_tried += 1
            if waste_pct <= target_waste_pct:
                break

        else:
            img, stats, waste, waste_pct, num_rolls, tried, hit, sw_not_placed, sw_rolls = search_single_width(
                rects, original_dims, total_rects, max_height,
                width, item_margins, bool(allow_rotation),
                search_mode, target_waste_pct, 4.0
            )
            global_tried += tried

            if img is None:
                width_results.append((width, None, None, None, "Gagal"))
                continue

            key = unified_key(
                waste if waste is not None else float('inf'),
                num_rolls if num_rolls else 99,
                sw_not_placed if sw_not_placed is not None else 0,
            )
            if best_key is None or key < best_key:
                best_key = key
                best_overall = (img, stats, waste, waste_pct, sw_rolls)
                best_width = width

            width_results.append((width, waste, waste_pct, num_rolls, f"{waste_pct:.2f}%"))
            if hit:
                break

    if best_overall is None:
        return None, "⚠️ Tidak ada satupun lebar roll yang bisa menampung semua banner.", None, None, None

    img, stats, best_waste, best_waste_pct, best_rolls_final = best_overall

    comparison = ["\n" + "─" * 55, "📋 PERBANDINGAN LEBAR ROLL (10 teratas):"]
    sorted_r = sorted([r for r in width_results if r[1] is not None], key=lambda x: (x[1], x[3]))
    for w, waste, wpct, num_rolls_disp, note in sorted_r[:10]:
        mark = " ⭐ PALING HEMAT" if w == best_width else ""
        target = " 🎯" if isinstance(wpct, (int, float)) and wpct <= target_waste_pct else ""
        w_label = "MULTI (beda lebar)" if w == "multi" else f"{w:g} cm"
        comparison.append(
            f"   {'✅' if w == best_width else '  '} {w_label} → "
            f"{num_rolls_disp} roll, waste {waste:.1f} cm² ({note}){mark}{target}"
        )

    final = stats + "\n" + "\n".join(comparison)
    final += f"\n{'─' * 55}\n🔍 Total iterasi keseluruhan: {global_tried} kombinasi"

    return img, final, best_rolls_final, original_dims, item_margins


# --------------------------------------------------------------------------
# 11. UI GRADIO
# --------------------------------------------------------------------------

with gr.Blocks(title="Nesting Otomatis Banner v2 — Super Optimized") as demo:
    gr.Markdown("# 🖨️ Nesting Otomatis v2 — Simulated Annealing + Multi-Width")
    gr.Markdown(
        "Upgrade: **Simulated Annealing**, **Multi-Width Multi-Roll**, "
        "dan **Guillotine Validation**. Berburu waste minimum dengan target."
    )

    with gr.Row():
        with gr.Column(scale=1):
            roll_widths = gr.Textbox(
                label="Daftar Lebar Roll (cm, pisah koma)",
                value="150, 200, 250, 300",
                placeholder="Contoh: 150, 200, 250, 300",
            )
            gr.Markdown(
                "ℹ️ Jarak Antar Item / Margin kini diatur **per banner** lewat "
                "kolom **Margin** di form & tabel di bawah, bukan satu nilai global."
            )
            allow_rotation = gr.Checkbox(label="Izinkan Rotasi Otomatis", value=True)

            target_waste = gr.Number(
                label="🎯 Target Waste Maksimum (%)",
                value=5.0, minimum=0.1, maximum=50.0, step=0.5,
            )

            # 1. Multi-width aktif by default (True)
            enable_multiwidth = gr.Checkbox(
                label="🎨 Aktifkan Multi-Width Multi-Roll (tiap roll beda lebar)",
                value=True,
            )

            # 2. Mode pencarian diatur ke "exhaustive" (Menyeluruh) by default
            search_mode = gr.Dropdown(
                label="Mode Pencarian",
                choices=[
                    ("⚡ Cepat", "quick"),
                    ("🎯 Standar (~120)", "standard"),
                    ("🔍 Dalaman (~464)", "deep"),
                    ("🧠 Pro (~3.000+ + Simulated Annealing)", "pro"),
                    ("💎 Menyeluruh (~8.000+ + SA + Swap)", "exhaustive"),
                ],
                value="exhaustive",
            )

            gr.Markdown("### 📥 Form Input Banner Baru")
            with gr.Row():
                input_label = gr.Textbox(label="Label Banner", value="")
                input_width = gr.Number(label="Lebar (cm)", value=100)
            with gr.Row():
                input_height = gr.Number(label="Tinggi (cm)", value=60)
                input_margin = gr.Number(
                    label="Margin (cm)", value=2.5, minimum=0
                )

            btn_add = gr.Button("➕ Tambah ke Daftar Banner", variant="secondary")
            gr.Markdown(
                "💡 Untuk mencetak banner yang sama lebih dari satu kali, tekan "
                "tombol tambah beberapa kali (atau tambahkan baris manual di tabel)."
            )

            gr.Markdown("### 📋 Daftar Banner")
            # 3. Daftar banner default dikosongkan (value=[])
            data_input = gr.Dataframe(
                headers=["Label", "Width", "Height", "Margin"],
                datatype=["str", "number", "number", "number"],
                row_count=(0, "dynamic"),
                value=[],
            )
            
            # Event listener untuk tombol tambah banner berulang kali
            btn_add.click(
                fn=add_banner_to_list,
                inputs=[input_label, input_width, input_height, input_margin, data_input],
                outputs=[data_input]
            )

            btn = gr.Button("🚀 PROSES SUPER OPTIMIZED", variant="primary")

        with gr.Column(scale=2):
            output_img = gr.Image(label="Pratinjau Layout Cetakan", type="pil")
            output_stats = gr.Textbox(label="Statistik Hasil Nesting", lines=16)

            gr.Markdown("### 📤 Ekspor Layout Terpilih")
            btn_export_svg = gr.Button("💾 Download Layout (SVG untuk CorelDraw)", variant="secondary")
            output_svg_file = gr.File(label="File SVG Hasil Nesting (1 unit = 1 cm)")

    # State tersembunyi: menyimpan data mentah hasil nesting terbaik supaya
    # bisa dipakai ulang oleh tombol export SVG tanpa proses ulang perhitungan.
    state_best_rolls = gr.State(None)
    state_original_dims = gr.State(None)
    state_item_margins = gr.State(None)

    btn.click(
        fn=process,
        inputs=[roll_widths, allow_rotation, search_mode, target_waste,
                enable_multiwidth, data_input],
        outputs=[output_img, output_stats, state_best_rolls, state_original_dims, state_item_margins],
    )

    btn_export_svg.click(
        fn=export_svg_file,
        inputs=[state_best_rolls, state_original_dims, state_item_margins],
        outputs=[output_svg_file],
    )

if __name__ == "__main__":
    demo.launch()