import math

try:
    import tkinter as tk
    from tkinter import messagebox
    from tkinter import ttk
    TK_AVAILABLE = True
    TK_IMPORT_ERROR = None
except Exception as exc:
    tk = None
    messagebox = None
    ttk = None
    TK_AVAILABLE = False
    TK_IMPORT_ERROR = exc

# =========================
# EDIT VALUES HERE (CONFIG)
# =========================

KELP_PRICE = 61                 # per kelp item
BLAZE_ROD_PRICE = 150            # per blaze rod
DRIED_KELP_PRICE = 83.18         # per dried kelp item
DRIED_KELP_BLOCK_PRICE = 750.5     # per dried kelp block
BUY_KELP = True                  # True = buy kelp, False = use owned kelp

SMOKERS = 64               # amount of smokers
KELP_AMOUNT = "1s"                  # amount of kelp to process (items)

# =========================
# GAME CONSTANTS (DON'T EDIT)
# =========================

SECONDS_PER_ITEM_SMOKER = 5
ITEMS_PER_BLAZE_ROD = 12
DRIED_KELP_PER_BLOCK = 9

NUMBER_SUFFIXES = {
    "": 1,
    "k": 1_000,
    "m": 1_000_000,
    "b": 1_000_000_000,
}


def money(x: float) -> str:
    return f"{x:,.2f}"


def format_duration(total_seconds: float) -> str:
    """Format seconds as a compact duration like 2d 3h 4m 5s."""
    seconds = max(0, int(round(total_seconds)))
    days, rem = divmod(seconds, 86_400)
    hours, rem = divmod(rem, 3_600)
    minutes, secs = divmod(rem, 60)

    parts = []
    if days:
        parts.append(f"{days}d")
    if hours:
        parts.append(f"{hours}h")
    if minutes:
        parts.append(f"{minutes}m")
    if secs or not parts:
        parts.append(f"{secs}s")

    return " ".join(parts)


def parse_number_with_suffix(value) -> float:
    """Parse values like 1200, 1.2k, 3m, 4B (case-insensitive)."""
    if isinstance(value, (int, float)):
        return float(value)

    text = str(value).strip()
    if not text:
        raise ValueError("Value cannot be empty")

    suffix = ""
    if text[-1].isalpha():
        suffix = text[-1].lower()
        text = text[:-1].strip()

    if suffix not in NUMBER_SUFFIXES:
        raise ValueError("Invalid suffix. Use k, m, or b")

    try:
        base_value = float(text)
    except ValueError as exc:
        raise ValueError(f"Invalid numeric value: {value}") from exc

    return base_value * NUMBER_SUFFIXES[suffix]


def parse_int_with_suffix(value, field_name: str) -> int:
    parsed = parse_number_with_suffix(value)
    result = int(round(parsed))
    if result < 0:
        raise ValueError(f"{field_name} must be >= 0")
    return result


def parse_kelp_amount(value) -> int:
    """Parse kelp amount as items; supports k/m/b and shulker forms s/ks/ms/bs."""
    text = str(value).strip()
    if not text:
        raise ValueError("KELP_AMOUNT cannot be empty")

    lower_text = text.lower()
    shulker_multipliers = [
        ("bs", 1_000_000_000),
        ("ms", 1_000_000),
        ("ks", 1_000),
        ("s", 1),
    ]

    amount = None
    for suffix, shulker_scale in shulker_multipliers:
        if lower_text.endswith(suffix):
            number_part = text[:-len(suffix)].strip()
            if not number_part:
                raise ValueError("Invalid shulker amount format")
            try:
                shulker_count = float(number_part)
            except ValueError as exc:
                raise ValueError("Invalid shulker amount format") from exc
            amount = int(round(shulker_count * shulker_scale * 1728))
            break

    if amount is None:
        amount = parse_int_with_suffix(text, "KELP_AMOUNT")

    if amount < 0:
        raise ValueError("KELP_AMOUNT must be >= 0")

    return amount


def calculate(
    kelp_price: float,
    blaze_rod_price: float,
    dried_kelp_price: float,
    dried_kelp_block_price: float,
    smokers: int,
    kelp_amount: int,
    buy_kelp: bool,
) -> dict:

    if smokers <= 0:
        raise ValueError("SMOKERS must be >= 1")
    if kelp_amount < 0:
        raise ValueError("KELP_AMOUNT must be >= 0")

    dried_kelp_out = kelp_amount  # 1 kelp -> 1 dried kelp

    # Fuel usage (rounded up to whole rods)
    blaze_rods_used = math.ceil(kelp_amount / ITEMS_PER_BLAZE_ROD)
    fuel_cost = blaze_rods_used * blaze_rod_price

    # Time
    total_seconds = (kelp_amount * SECONDS_PER_ITEM_SMOKER) / smokers
    total_minutes = total_seconds / 60
    total_hours = total_minutes / 60

    # --- Scenario 1: Smelt and sell dried kelp ---
    kelp_market_value = kelp_amount * kelp_price
    # In owned mode we still use kelp market value as opportunity cost,
    # but label it as raw kelp profit in the UI.
    kelp_cost = kelp_market_value
    kelp_value_label = "Kelp Cost" if buy_kelp else "Raw Kelp Profit"
    cost_smelt_only = kelp_cost + fuel_cost
    revenue_smelt_only = dried_kelp_out * dried_kelp_price
    profit_smelt_only = revenue_smelt_only - cost_smelt_only

    # Blocks and leftovers from the smelt output
    blocks_from_amount = dried_kelp_out // DRIED_KELP_PER_BLOCK
    leftover_dried = dried_kelp_out % DRIED_KELP_PER_BLOCK

    # --- Scenario 2: Craft blocks only (buy dried kelp for blocks) ---
    cost_craft_only = (blocks_from_amount * DRIED_KELP_PER_BLOCK) * dried_kelp_price
    revenue_craft_only = blocks_from_amount * dried_kelp_block_price
    profit_craft_only = revenue_craft_only - cost_craft_only

    # --- Scenario 3: Smelt then craft, sell blocks + leftover dried kelp ---
    cost_smelt_then_craft = kelp_cost + fuel_cost
    revenue_smelt_then_craft = (blocks_from_amount * dried_kelp_block_price) + (leftover_dried * dried_kelp_price)
    profit_smelt_then_craft = revenue_smelt_then_craft - cost_smelt_then_craft

    print("=== Kelp Smelting / Block Craft Profit Calculator ===")
    print("\n=== Config ===")
    print(f"KELP_PRICE: {kelp_price}")
    print(f"BLAZE_ROD_PRICE: {blaze_rod_price}")
    print(f"DRIED_KELP_PRICE: {dried_kelp_price}")
    print(f"DRIED_KELP_BLOCK_PRICE: {dried_kelp_block_price}")
    print(f"BUY_KELP: {buy_kelp}")
    print(f"SMOKERS: {smokers}")
    print(f"KELP_AMOUNT: {kelp_amount}")

    print("\n=== Results ===")
    print(f"Kelp processed: {kelp_amount}")
    print(f"Dried kelp produced: {dried_kelp_out}")
    print(f"Blocks craftable: {blocks_from_amount} (leftover dried kelp: {leftover_dried})")

    print("\n--- Smelting logistics ---")
    print(f"Blaze rods used: {blaze_rods_used} (1 rod smelts {ITEMS_PER_BLAZE_ROD} items)")
    print(f"Fuel cost: {money(fuel_cost)}")
    print(f"Time to smelt all: {total_seconds:,.0f} s  ({total_minutes:,.2f} min, {total_hours:,.2f} hr)")

    print("\n--- Profit calculations ---")
    print(f"Profit (smelt -> sell dried kelp): {money(profit_smelt_only)}")
    print(f"Profit (craft blocks only): {money(profit_craft_only)}")
    print(f"Profit (smelt -> craft -> sell blocks + leftover dried): {money(profit_smelt_then_craft)}")

    print("\n--- Useful unit breakdowns ---")
    avg_fuel_cost_per_item = blaze_rod_price / ITEMS_PER_BLAZE_ROD
    smelt_profit_per_kelp = (dried_kelp_price - kelp_price) - avg_fuel_cost_per_item
    craft_profit_per_block = dried_kelp_block_price - (DRIED_KELP_PER_BLOCK * dried_kelp_price)

    return {
        "kelp_price": kelp_price,
        "blaze_rod_price": blaze_rod_price,
        "dried_kelp_price": dried_kelp_price,
        "dried_kelp_block_price": dried_kelp_block_price,
        "buy_kelp": buy_kelp,
        "smokers": smokers,
        "kelp_amount": kelp_amount,
        "dried_kelp_out": dried_kelp_out,
        "blocks_from_amount": blocks_from_amount,
        "leftover_dried": leftover_dried,
        "blaze_rods_used": blaze_rods_used,
        "kelp_market_value": kelp_market_value,
        "kelp_value_label": kelp_value_label,
        "kelp_cost": kelp_cost,
        "fuel_cost": fuel_cost,
        "total_seconds": total_seconds,
        "total_minutes": total_minutes,
        "total_hours": total_hours,
        "profit_smelt_only": profit_smelt_only,
        "profit_craft_only": profit_craft_only,
        "profit_smelt_then_craft": profit_smelt_then_craft,
        "avg_fuel_cost_per_item": avg_fuel_cost_per_item,
        "smelt_profit_per_kelp": smelt_profit_per_kelp,
        "craft_profit_per_block": craft_profit_per_block,
    }


def format_results(data: dict) -> str:
    return (
        "=== Kelp Smelting / Block Craft Profit Calculator ===\n\n"
        "=== Config ===\n"
        f"KELP_PRICE: {data['kelp_price']}\n"
        f"BLAZE_ROD_PRICE: {data['blaze_rod_price']}\n"
        f"DRIED_KELP_PRICE: {data['dried_kelp_price']}\n"
        f"DRIED_KELP_BLOCK_PRICE: {data['dried_kelp_block_price']}\n"
        f"BUY_KELP: {data['buy_kelp']}\n"
        f"SMOKERS: {data['smokers']}\n"
        f"KELP_AMOUNT: {data['kelp_amount']}\n\n"
        "=== Results ===\n"
        f"Kelp processed: {data['kelp_amount']}\n"
        f"Dried kelp produced: {data['dried_kelp_out']}\n"
        f"Blocks craftable: {data['blocks_from_amount']} "
        f"(leftover dried kelp: {data['leftover_dried']})\n\n"
        "--- Smelting logistics ---\n"
        f"Blaze rods used: {data['blaze_rods_used']} "
        f"(1 rod smelts {ITEMS_PER_BLAZE_ROD} items)\n"
        f"Fuel cost: {money(data['fuel_cost'])}\n"
        f"Time to smelt all: {format_duration(data['total_seconds'])} "
        f"({data['total_seconds']:,.0f} s, {data['total_minutes']:,.2f} min, {data['total_hours']:,.2f} hr)\n\n"
        "--- Profit calculations ---\n"
        f"Profit (smelt -> sell dried kelp): {money(data['profit_smelt_only'])}\n"
        f"Profit (craft blocks only): {money(data['profit_craft_only'])}\n"
        f"Profit (smelt -> craft -> sell blocks + leftover dried): "
        f"{money(data['profit_smelt_then_craft'])}\n\n"
        "--- Useful unit breakdowns ---\n"
        f"Avg fuel cost per smelted item: {money(data['avg_fuel_cost_per_item'])}\n"
        "Estimated profit per kelp smelted (avg fuel): "
        f"{money(data['smelt_profit_per_kelp'])}\n"
        f"Profit per dried kelp block crafted: {money(data['craft_profit_per_block'])}"
    )


def main():
    data = calculate(
        kelp_price=parse_number_with_suffix(KELP_PRICE),
        blaze_rod_price=parse_number_with_suffix(BLAZE_ROD_PRICE),
        dried_kelp_price=parse_number_with_suffix(DRIED_KELP_PRICE),
        dried_kelp_block_price=parse_number_with_suffix(DRIED_KELP_BLOCK_PRICE),
        smokers=parse_int_with_suffix(SMOKERS, "SMOKERS"),
        kelp_amount=parse_kelp_amount(KELP_AMOUNT),
        buy_kelp=BUY_KELP,
    )

    print(format_results(data))


def launch_ui():
    if not TK_AVAILABLE:
        raise RuntimeError(f"Tkinter is unavailable: {TK_IMPORT_ERROR}")

    root = tk.Tk()
    root.title("Kelp Profit Calculator")
    root.geometry("980x700")
    root.minsize(900, 620)
    root.configure(bg="#000000")

    style = ttk.Style(root)
    try:
        style.theme_use("clam")
    except tk.TclError:
        pass

    style.configure("App.TFrame", background="#000000")
    style.configure("Card.TFrame", background="#111214", relief="flat")
    style.configure("Header.TLabel", background="#000000", foreground="#f2f3f5", font=("Segoe UI", 21, "bold"))
    style.configure("SubHeader.TLabel", background="#000000", foreground="#b5bac1", font=("Segoe UI", 10))
    style.configure("FieldLabel.TLabel", background="#111214", foreground="#dbdee1", font=("Segoe UI", 10, "bold"))
    style.configure("KpiLabel.TLabel", background="#111214", foreground="#949ba4", font=("Segoe UI", 9, "bold"))
    style.configure("KpiValue.TLabel", background="#111214", foreground="#f2f3f5", font=("Segoe UI", 13, "bold"))
    style.configure("KpiValueBest.TLabel", background="#111214", foreground="#57f287", font=("Segoe UI", 13, "bold"))
    style.configure("KpiValueProfit.TLabel", background="#111214", foreground="#f2f3f5", font=("Segoe UI", 13, "bold"))
    style.configure("KpiValueLoss.TLabel", background="#111214", foreground="#ed4245", font=("Segoe UI", 13, "bold"))
    style.configure("Accent.TButton", font=("Segoe UI", 10, "bold"), padding=8)
    style.map(
        "Accent.TButton",
        background=[("active", "#4752c4"), ("!disabled", "#5865f2")],
        foreground=[("!disabled", "#ffffff")],
    )

    style.configure(
        "TEntry",
        fieldbackground="#1e1f22",
        foreground="#f2f3f5",
        bordercolor="#2b2d31",
        insertcolor="#f2f3f5",
    )
    style.configure("SourceOn.TButton", font=("Segoe UI", 9, "bold"), padding=7)
    style.map(
        "SourceOn.TButton",
        background=[("active", "#4752c4"), ("!disabled", "#5865f2")],
        foreground=[("!disabled", "#ffffff")],
    )
    style.configure("SourceOff.TButton", font=("Segoe UI", 9, "bold"), padding=7)
    style.map(
        "SourceOff.TButton",
        background=[("active", "#3a3d42"), ("!disabled", "#2b2d31")],
        foreground=[("!disabled", "#dbdee1")],
    )

    style.configure("Dark.Vertical.TScrollbar", background="#2b2d31", troughcolor="#1e1f22")

    app = ttk.Frame(root, style="App.TFrame", padding=(22, 18, 22, 18))
    app.pack(fill="both", expand=True)
    app.grid_columnconfigure(0, weight=1)
    app.grid_columnconfigure(1, weight=1)
    app.grid_rowconfigure(2, weight=1)

    ttk.Label(app, text="Kelp Profit Dashboard", style="Header.TLabel").grid(
        row=0, column=0, columnspan=2, sticky="w"
    )
    ttk.Label(
        app,
        text="Smelting, crafting, and profit snapshots in one place",
        style="SubHeader.TLabel",
    ).grid(row=1, column=0, columnspan=2, sticky="w", pady=(0, 14))

    input_card = ttk.Frame(app, style="Card.TFrame", padding=(16, 16, 16, 16))
    input_card.grid(row=2, column=0, sticky="nsew", padx=(0, 10))
    input_card.grid_columnconfigure(0, weight=1)
    input_card.grid_columnconfigure(1, weight=1)

    results_card = ttk.Frame(app, style="Card.TFrame", padding=(16, 16, 16, 16))
    results_card.grid(row=2, column=1, sticky="nsew", padx=(10, 0))
    results_card.grid_columnconfigure(0, weight=1)
    results_card.grid_rowconfigure(4, weight=1)

    fields = [
        ("Kelp Price (k/m/b)", str(KELP_PRICE)),
        ("Blaze Rod Price (k/m/b)", str(BLAZE_ROD_PRICE)),
        ("Dried Kelp Price (k/m/b)", str(DRIED_KELP_PRICE)),
        ("Dried Kelp Block Price (k/m/b)", str(DRIED_KELP_BLOCK_PRICE)),
        ("Smokers (k/m/b)", str(SMOKERS)),
        ("Kelp Amount (items k/m/b or s/ks/ms/bs)", str(KELP_AMOUNT)),
    ]

    entries = {}
    buy_kelp_var = tk.BooleanVar(value=BUY_KELP)

    ttk.Label(input_card, text="Inputs", style="FieldLabel.TLabel").grid(
        row=0, column=0, columnspan=2, sticky="w", pady=(0, 10)
    )

    for row, (label_text, default_value) in enumerate(fields):
        label = ttk.Label(input_card, text=label_text, style="FieldLabel.TLabel", anchor="w")
        label.grid(row=row + 1, column=0, sticky="w", padx=(0, 8), pady=6)

        entry = ttk.Entry(input_card, width=24)
        entry.insert(0, default_value)
        entry.grid(row=row + 1, column=1, sticky="ew", pady=6)
        entries[label_text] = entry

    source_row = ttk.Frame(input_card, style="Card.TFrame")
    source_row.grid(row=len(fields) + 1, column=0, columnspan=2, sticky="ew", pady=(10, 2))
    source_row.grid_columnconfigure(1, weight=1)

    ttk.Label(source_row, text="Kelp Source", style="FieldLabel.TLabel").grid(row=0, column=0, sticky="w", padx=(0, 8))
    source_toggle_btn = ttk.Button(source_row)
    source_toggle_btn.grid(row=0, column=1, sticky="ew")

    def refresh_source_toggle():
        if buy_kelp_var.get():
            source_toggle_btn.configure(text="Buying Kelp (click to use owned)", style="SourceOn.TButton")
        else:
            source_toggle_btn.configure(text="Using Owned Kelp (click to buy)", style="SourceOff.TButton")

    def toggle_kelp_source():
        buy_kelp_var.set(not buy_kelp_var.get())
        refresh_source_toggle()
        on_calculate()

    source_toggle_btn.configure(command=toggle_kelp_source)
    refresh_source_toggle()

    kpi_row = ttk.Frame(results_card, style="Card.TFrame")
    kpi_row.grid(row=0, column=0, sticky="ew")
    kpi_row.grid_columnconfigure(0, weight=1)
    kpi_row.grid_columnconfigure(1, weight=1)
    kpi_row.grid_columnconfigure(2, weight=1)

    kpi_1 = ttk.Frame(kpi_row, style="Card.TFrame", padding=(10, 8, 10, 8))
    kpi_1.grid(row=0, column=0, sticky="nsew", padx=(0, 6))
    kpi_2 = ttk.Frame(kpi_row, style="Card.TFrame", padding=(10, 8, 10, 8))
    kpi_2.grid(row=0, column=1, sticky="nsew", padx=3)
    kpi_3 = ttk.Frame(kpi_row, style="Card.TFrame", padding=(10, 8, 10, 8))
    kpi_3.grid(row=0, column=2, sticky="nsew", padx=(6, 0))

    ttk.Label(kpi_1, text="Smelt Profit", style="KpiLabel.TLabel").pack(anchor="w")
    kpi_1_value = ttk.Label(kpi_1, text="0.00", style="KpiValue.TLabel")
    kpi_1_value.pack(anchor="w")

    ttk.Label(kpi_2, text="Craft Profit", style="KpiLabel.TLabel").pack(anchor="w")
    kpi_2_value = ttk.Label(kpi_2, text="0.00", style="KpiValue.TLabel")
    kpi_2_value.pack(anchor="w")

    ttk.Label(kpi_3, text="Hybrid Profit", style="KpiLabel.TLabel").pack(anchor="w")
    kpi_3_value = ttk.Label(kpi_3, text="0.00", style="KpiValue.TLabel")
    kpi_3_value.pack(anchor="w")

    metrics_row = ttk.Frame(results_card, style="Card.TFrame")
    metrics_row.grid(row=1, column=0, sticky="ew", pady=(10, 0))
    metrics_row.grid_columnconfigure(0, weight=1)
    metrics_row.grid_columnconfigure(1, weight=1)
    metrics_row.grid_columnconfigure(2, weight=1)

    smelt_card = ttk.Frame(metrics_row, style="Card.TFrame", padding=(10, 8, 10, 8))
    smelt_card.grid(row=0, column=0, sticky="nsew", padx=(0, 6))
    fuel_card = ttk.Frame(metrics_row, style="Card.TFrame", padding=(10, 8, 10, 8))
    fuel_card.grid(row=0, column=1, sticky="nsew", padx=3)
    kelp_card = ttk.Frame(metrics_row, style="Card.TFrame", padding=(10, 8, 10, 8))
    kelp_card.grid(row=0, column=2, sticky="nsew", padx=(6, 0))

    ttk.Label(smelt_card, text="Smelt Time", style="KpiLabel.TLabel").pack(anchor="w")
    smelt_time_value = ttk.Label(smelt_card, text="0m", style="KpiValueProfit.TLabel")
    smelt_time_value.pack(anchor="w")

    ttk.Label(fuel_card, text="Fuel Cost", style="KpiLabel.TLabel").pack(anchor="w")
    fuel_cost_value = ttk.Label(fuel_card, text="0.00", style="KpiValueProfit.TLabel")
    fuel_cost_value.pack(anchor="w")

    kelp_cost_label = ttk.Label(kelp_card, text="Kelp Cost", style="KpiLabel.TLabel")
    kelp_cost_label.pack(anchor="w")
    kelp_cost_value = ttk.Label(kelp_card, text="0.00", style="KpiValueProfit.TLabel")
    kelp_cost_value.pack(anchor="w")

    ttk.Separator(results_card, orient="horizontal").grid(row=2, column=0, sticky="ew", pady=(12, 10))

    ttk.Label(results_card, text="Full Breakdown", style="FieldLabel.TLabel").grid(row=3, column=0, sticky="w", pady=(0, 8))

    text_wrap = ttk.Frame(results_card, style="Card.TFrame")
    text_wrap.grid(row=4, column=0, sticky="nsew")
    text_wrap.grid_columnconfigure(0, weight=1)
    text_wrap.grid_rowconfigure(0, weight=1)

    result_text = tk.Text(
        text_wrap,
        wrap="word",
        height=24,
        bg="#1e1f22",
        fg="#f2f3f5",
        insertbackground="#f2f3f5",
        relief="flat",
        padx=10,
        pady=10,
        font=("Consolas", 10),
    )
    result_text.grid(row=0, column=0, sticky="nsew")

    scrollbar = ttk.Scrollbar(text_wrap, orient="vertical", command=result_text.yview, style="Dark.Vertical.TScrollbar")
    scrollbar.grid(row=0, column=1, sticky="ns")
    result_text.configure(yscrollcommand=scrollbar.set)

    result_text.tag_configure("section", foreground="#f2f3f5", font=("Consolas", 10, "bold"))
    result_text.tag_configure("profit_best", foreground="#57f287", font=("Consolas", 10, "bold"))
    result_text.tag_configure("profit_other", foreground="#f2f3f5", font=("Consolas", 10, "bold"))
    result_text.tag_configure("loss", foreground="#ed4245", font=("Consolas", 10, "bold"))

    button_row = ttk.Frame(input_card, style="Card.TFrame")
    button_row.grid(row=len(fields) + 2, column=0, columnspan=2, sticky="ew", pady=(14, 2))
    button_row.grid_columnconfigure(0, weight=1)

    calculate_btn = ttk.Button(button_row, text="Calculate", style="Accent.TButton")
    calculate_btn.grid(row=0, column=0, sticky="ew")

    def on_calculate():
        try:
            data = calculate(
                kelp_price=parse_number_with_suffix(entries["Kelp Price (k/m/b)"].get()),
                blaze_rod_price=parse_number_with_suffix(entries["Blaze Rod Price (k/m/b)"].get()),
                dried_kelp_price=parse_number_with_suffix(entries["Dried Kelp Price (k/m/b)"].get()),
                dried_kelp_block_price=parse_number_with_suffix(entries["Dried Kelp Block Price (k/m/b)"].get()),
                smokers=parse_int_with_suffix(entries["Smokers (k/m/b)"].get(), "SMOKERS"),
                kelp_amount=parse_kelp_amount(entries["Kelp Amount (items k/m/b or s/ks/ms/bs)"].get()),
                buy_kelp=buy_kelp_var.get(),
            )
        except ValueError as exc:
            messagebox.showerror("Invalid input", str(exc))
            return

        kpi_1_value.configure(text=money(data["profit_smelt_only"]))
        kpi_2_value.configure(text=money(data["profit_craft_only"]))
        kpi_3_value.configure(text=money(data["profit_smelt_then_craft"]))

        profits = {
            "smelt": data["profit_smelt_only"],
            "craft": data["profit_craft_only"],
            "hybrid": data["profit_smelt_then_craft"],
        }
        max_profit = max(profits.values())

        def kpi_style(value: float) -> str:
            if value < 0:
                return "KpiValueLoss.TLabel"
            if value == max_profit:
                return "KpiValueBest.TLabel"
            return "KpiValueProfit.TLabel"

        kpi_1_value.configure(style=kpi_style(profits["smelt"]))
        kpi_2_value.configure(style=kpi_style(profits["craft"]))
        kpi_3_value.configure(style=kpi_style(profits["hybrid"]))

        smelt_time_value.configure(text=format_duration(data["total_seconds"]))
        fuel_cost_value.configure(text=money(data["fuel_cost"]))
        kelp_cost_label.configure(text=data["kelp_value_label"])
        kelp_cost_value.configure(text=money(data["kelp_cost"]))

        result_text.delete("1.0", tk.END)
        result_text.insert(tk.END, format_results(data))

        for heading in ["===", "---"]:
            start = "1.0"
            while True:
                idx = result_text.search(heading, start, tk.END)
                if not idx:
                    break
                line_end = result_text.index(f"{idx} lineend")
                result_text.tag_add("section", idx, line_end)
                start = line_end

        result_text.tag_remove("profit_best", "1.0", tk.END)
        result_text.tag_remove("profit_other", "1.0", tk.END)
        result_text.tag_remove("loss", "1.0", tk.END)

        line_rules = [
            ("Profit (smelt -> sell dried kelp)", profits["smelt"]),
            ("Profit (craft blocks only)", profits["craft"]),
            ("Profit (smelt -> craft -> sell blocks + leftover dried)", profits["hybrid"]),
        ]

        for label, value in line_rules:
            idx = result_text.search(label, "1.0", tk.END)
            if not idx:
                continue
            line_end = result_text.index(f"{idx} lineend")
            if value < 0:
                result_text.tag_add("loss", idx, line_end)
            elif value == max_profit:
                result_text.tag_add("profit_best", idx, line_end)
            else:
                result_text.tag_add("profit_other", idx, line_end)

    calculate_btn.configure(command=on_calculate)

    on_calculate()
    root.mainloop()

if __name__ == "__main__":
    try:
        if TK_AVAILABLE:
            try:
                launch_ui()
            except tk.TclError:
                main()
        else:
            print(f"UI unavailable ({TK_IMPORT_ERROR}). Falling back to CLI output.\n")
            main()
    except KeyboardInterrupt:
        print("\nInterrupted by user. Exiting.")