# 1a: Toggle callback format
for ing in SAMPLE_INGREDIENTS:
    expected = f"toggle:{RECIPE_ID}:{ing['index']}"
    actual = f"toggle:{ing['recipe_id']}:{ing['index']}"
    record("toggle callback format", expected == actual, f"expected={expected} actual={actual}")

# 1b: Commit callback format
expected = f"commit:{RECIPE_ID}"
actual = f"commit:{SAMPLE_INGREDIENTS[0]['recipe_id']}"
record("commit callback format", expected == actual, f"expected={expected} actual={actual}")

# 1c: Cancel callback format
expected = f"cancel:{RECIPE_ID}"
actual = f"cancel:{SAMPLE_INGREDIENTS[0]['recipe_id']}"
record("cancel callback format", expected == actual, f"expected={expected} actual={actual}")

# 1d: Callback data parsing (toggle)
data = f"toggle:{RECIPE_ID}:5"
parts = data.split(":")
record("toggle data splits to 3 parts", len(parts) == 3, f"parts={parts}")
record("toggle action is 'toggle'", parts[0] == "toggle")
record("toggle recipe_id matches", parts[1] == RECIPE_ID)
record("toggle index parses to int", parts[2] == "5")

# 1e: Callback data parsing (commit)
data = f"commit:{RECIPE_ID}"
parts = data.split(":")
record("commit data splits to 2 parts", len(parts) == 2, f"parts={parts}")

# 1f: Callback data parsing (cancel)
data = f"cancel:{RECIPE_ID}"
parts = data.split(":")
record("cancel data splits to 2 parts", len(parts) == 2, f"parts={parts}")

# 1g: Edge cases — invalid callback data
invalid_cases = ["toggle:abc", "toggle:abc:xyz", "commit", "cancel:"]
for case in invalid_cases:
    parts = case.split(":")
    is_valid_toggle = case.startswith("toggle:") and len(parts) == 3 and parts[2].isdigit()
    is_valid_commit = case.startswith("commit:") and len(parts) == 2
    is_valid_cancel = case.startswith("cancel:") and len(parts) == 2 and parts[1]
    record(f"invalid callback rejected: '{case}'", not (is_valid_toggle or is_valid_commit or is_valid_cancel))

# 2a: build_caption with all selected
caption_all = build_caption("Creamy Tomato and Spinach Pasta", "budgetbytes.com", SAMPLE_INGREDIENTS)
record("caption includes title", "🍝 Creamy Tomato and Spinach Pasta" in caption_all)
record("caption includes domain", "From: budgetbytes.com" in caption_all)
record("caption includes instruction", "Tap to deselect items you don't need:" in caption_all)
record("caption includes all 8 ingredients", caption_all.count("✅") == 8)

# 2b: build_caption with deselected items (strikethrough)
deselected = [dict(ing) for ing in SAMPLE_INGREDIENTS]
deselected[1] = {**deselected[1], "selected": False}  # Onion deselected
deselected[4] = {**deselected[4], "selected": False}  # Cream deselected
caption_partial = build_caption("Creamy Tomato and Spinach Pasta", "budgetbytes.com", deselected)

record("caption shows ❌ for deselected", "❌" in caption_partial)
record("caption has strikethrough markup", "~" in caption_partial, "Telegram MarkdownV2 strikethrough")

# Check that deselected items have both ❌ and ~...~
lines = caption_partial.split("\n")
deselected_lines = [l for l in lines if "❌" in l]
record("deselected lines contain strikethrough", all("~" in l for l in deselected_lines))

# Check index numbers in caption
record("caption includes #1 for first ingredient", "#1" in caption_all)
record("caption includes #8 for last ingredient", "#8" in caption_all)

# 2c: build_toggle_keyboard — 8 ingredients, 4-per-row
keyboard = build_toggle_keyboard(SAMPLE_INGREDIENTS, 8)
kb = keyboard["inline_keyboard"]

record("keyboard is dict with inline_keyboard key", "inline_keyboard" in keyboard)
record("8 ingredients → 2 rows of 4 + commit/cancel row = 3 rows", len(kb) == 3,
      f"actual rows={len(kb)}")

# First row: 4 ingredient buttons
row0 = kb[0]
record("row 0 has 4 buttons", len(row0) == 4, f"actual={len(row0)}")

# Check button labels
record("first button label is '✅ #1'", row0[0]["text"] == "✅ #1", f"actual={row0[0]['text']}")
record("fourth button label is '✅ #4'", row0[3]["text"] == "✅ #4", f"actual={row0[3]['text']}")

# Second row: 4 ingredient buttons
row1 = kb[1]
record("row 1 has 4 buttons", len(row1) == 4, f"actual={len(row1)}")
record("5th button label is '✅ #5'", row1[0]["text"] == "✅ #5", f"actual={row1[0]['text']}")

# Commit/Cancel row
row2 = kb[2]
record("commit/cancel row has 2 buttons", len(row2) == 2, f"actual={len(row2)}")
record("commit button shows count", "Commit (8)" in row2[0]["text"], f"actual={row2[0]['text']}")
record("commit callback is correct", row2[0]["callback_data"] == f"commit:{RECIPE_ID}",
      f"actual={row2[0]['callback_data']}")
record("cancel callback is correct", row2[1]["callback_data"] == f"cancel:{RECIPE_ID}",
      f"actual={row2[1]['callback_data']}")

# 2d: Keyboard with partial selection
partial = [dict(ing) for ing in SAMPLE_INGREDIENTS]
partial[1] = {**partial[1], "selected": False}
partial[4] = {**partial[4], "selected": False}
partial[7] = {**partial[7], "selected": False}
keyboard_partial = build_toggle_keyboard(partial, 5)
kb_p = keyboard_partial["inline_keyboard"]

record("deselected button shows ❌", "❌" in kb_p[0][1]["text"], f"actual={kb_p[0][1]['text']}")
record("commit shows correct count (5)", "5)" in kb_p[2][0]["text"], f"actual={kb_p[2][0]['text']}")

# 2e: Keyboard with zero selection
none_selected = [{**ing, "selected": False} for ing in SAMPLE_INGREDIENTS]
keyboard_none = build_toggle_keyboard(none_selected, 0)
kb_n = keyboard_none["inline_keyboard"]
commit_btn = kb_n[-1][0]
record("zero selection: commit shows 'Select at least 1'", "Select at least 1" in commit_btn["text"],
      f"actual={commit_btn['text']}")

# 2f: 5 ingredients (odd number)
five_ings = SAMPLE_INGREDIENTS[:5]
kb5 = build_toggle_keyboard(five_ings, 5)["inline_keyboard"]
record("5 ingredients → row of 4 + row of 1 + commit row = 3 rows", len(kb5) == 3,
      f"actual rows={len(kb5)}")
record("row 1 has 1 button (partial)", len(kb5[1]) == 1, f"actual={len(kb5[1])}")

# 2g: Callback data for each ingredient button
all_buttons = [btn for row in kb for btn in row if btn["callback_data"].startswith("toggle:")]
record("8 ingredient buttons with toggle callbacks", len(all_buttons) == 8, f"actual={len(all_buttons)}")

for i in range(8):
    expected_data = f"toggle:{RECIPE_ID}:{i}"
    record(f"ingredient {i} callback data correct", all_buttons[i]["callback_data"] == expected_data,
          f"actual={all_buttons[i]['callback_data']}")

# 3a: Toggle simulation — deselect ingredient #1
ingredients = [dict(ing) for ing in SAMPLE_INGREDIENTS]
assert all(ing["selected"] for ing in ingredients)

idx = 1
ingredients[idx]["selected"] = not ingredients[idx]["selected"]  # False
selected_count = sum(1 for i in ingredients if i["selected"])
record("toggle index 1 → deselected", not ingredients[idx]["selected"])
record("selected count after 1 toggle → 7", selected_count == 7, f"actual={selected_count}")

keyboard = build_toggle_keyboard(ingredients, selected_count)
kb = keyboard["inline_keyboard"]
record("after deselect, button shows ❌", "❌" in kb[0][1]["text"], f"actual={kb[0][1]['text']}")
record("commit count updates to 7", "7)" in kb[2][0]["text"], f"actual={kb[2][0]['text']}")

caption = build_caption("Test Recipe", "test.com", ingredients)
record("caption shows ❌ for deselected", "❌" in caption)
record("caption shows ~strikethrough~ for deselected", "~1 small onion, diced~" in caption)

# 3b: Toggle back — re-select ingredient #1
ingredients[idx]["selected"] = not ingredients[idx]["selected"]  # True again
selected_count = sum(1 for i in ingredients if i["selected"])
record("toggle back → reselected", ingredients[idx]["selected"])
record("selected count restored to 8", selected_count == 8, f"actual={selected_count}")

# 3c: Multiple toggles
ingredients = [dict(ing) for ing in SAMPLE_INGREDIENTS]
for idx in [0, 2, 4, 6]:
    ingredients[idx]["selected"] = False
selected_count = sum(1 for i in ingredients if i["selected"])
record("4 deselected → count 4", selected_count == 4, f"actual={selected_count}")

keyboard = build_toggle_keyboard(ingredients, selected_count)
kb = keyboard["inline_keyboard"]
commit_text = kb[-1][0]["text"]
record("commit button shows 4 after multi-toggle", "(4)" in commit_text, f"actual={commit_text}")

# 3d: Zero selection → commit disabled
for ing in ingredients:
    ing["selected"] = False
selected_count = 0
keyboard = build_toggle_keyboard(ingredients, 0)
kb = keyboard["inline_keyboard"]
record("zero selection → commit shows disabled state", "Select at least 1" in kb[-1][0]["text"])

import core.db.grocery_list as gl
original_db_path = gl.DB_PATH

with tempfile.TemporaryDirectory() as tmpdir:
    tmp_db = Path(tmpdir) / "test_icarus.db"
    gl.DB_PATH = tmp_db

    try:
        init_db()

        # 4a: Save temp state
        save_temp_state(
            recipe_id=RECIPE_ID,
            user_id=12345,
            chat_id=67890,
            message_id=99999,
            title="Creamy Tomato and Spinach Pasta",
            source_url="https://www.budgetbytes.com/creamy-tomato-spinach-pasta/",
            ingredients=SAMPLE_INGREDIENTS,
        )

        state = get_temp_state(RECIPE_ID)
        record("temp state saved and retrieved", state is not None)
        record("temp state has correct title", state["title"] == "Creamy Tomato and Spinach Pasta")
        record("temp state has 8 ingredients", len(state["ingredients"]) == 8, f"actual={len(state['ingredients'])}")
        record("all ingredients initially selected", all(ing["selected"] for ing in state["ingredients"]))

        # 4b: Update temp state (deselect 2 items)
        updated = [dict(ing) for ing in state["ingredients"]]
        updated[1]["selected"] = False  # Onion
        updated[4]["selected"] = False  # Cream
        update_temp_state(RECIPE_ID, updated)

        state2 = get_temp_state(RECIPE_ID)
        record("updated state has 6 selected", sum(1 for i in state2["ingredients"] if i["selected"]) == 6)
        record("onion deselected", not state2["ingredients"][1]["selected"])
        record("cream deselected", not state2["ingredients"][4]["selected"])

        # 4c: Commit — add selected items to grocery list
        selected = [i for i in state2["ingredients"] if i["selected"]]
        count = add_items(
            items=[{"text": i["text"]} for i in selected],
            recipe_source=state2["title"],
            recipe_url=state2["source_url"],
            requested_by="matt",
        )
        record("6 items committed to grocery list", count == 6, f"actual={count}")

        # 4d: Verify grocery list
        items = list_items()
        record("grocery list has 6 items", len(items) == 6, f"actual={len(items)}")
        record("items are from correct recipe", all(i["recipe_source"] == "Creamy Tomato and Spinach Pasta" for i in items))

        # 4e: Delete temp state after commit
        delete_temp_state(RECIPE_ID)
        state3 = get_temp_state(RECIPE_ID)
        record("temp state deleted after commit", state3 is None)

        # 4f: Cancel flow
        RECIPE_ID_2 = "def456"
        save_temp_state(
            recipe_id=RECIPE_ID_2,
            user_id=12345,
            chat_id=67890,
            message_id=99998,
            title="Another Recipe",
            source_url="https://example.com/another/",
            ingredients=SAMPLE_INGREDIENTS[:3],
        )

        state_cancel = get_temp_state(RECIPE_ID_2)
        record("cancel flow: state exists before cancel", state_cancel is not None)

        delete_temp_state(RECIPE_ID_2)
        state_after_cancel = get_temp_state(RECIPE_ID_2)
        record("cancel flow: state deleted after cancel", state_after_cancel is None)

    finally:
        gl.DB_PATH = original_db_path

handler_path = Path("/home/hoffmann_admin/.openclaw/workspace/services/icarus/core/telegram/handler.py")
handler_code = handler_path.read_text()

has_recipe_import = "recipe_toggle" in handler_code or "from icarus.core.handlers" in handler_code or "from core.handlers" in handler_code
has_callback = "callback_query" in handler_code or "callback" in handler_code

record("handler.py imports recipe_toggle", has_recipe_import,
      "NEEDS WIRING: handler.py does not import recipe_toggle module")
record("handler.py handles callback_query", has_callback,
      "NEEDS WIRING: handler.py does not handle callback queries")

api_path = Path("/home/hoffmann_admin/.openclaw/workspace/services/icarus/core/api.py")
api_code = api_path.read_text()

record("api.py has telegram webhook route", "/telegram/webhook" in api_code)
record("api.py routes to handle_telegram_update", "handle_telegram_update" in api_code)
record("handler detects URLs in text messages", "http" in handler_code or "url" in handler_code.lower())

toggle_handler_path = Path("/home/hoffmann_admin/.openclaw/workspace/services/icarus/core/handlers/recipe_toggle.py")
toggle_code = toggle_handler_path.read_text()

record("handle_toggle validates 3-part callback", 'len(parts) != 3' in toggle_code or "parts != 3" in toggle_code)
record("handle_commit validates 2-part callback", 'len(parts) != 2' in toggle_code)
record("handle_cancel validates 2-part callback", 'cancel' in toggle_code and 'len(parts)' in toggle_code)
record("handle_toggle uses edit_message_text", "edit_message_text" in toggle_code,
      "CRITICAL FIX APPLIED: uses edit_message_text (not edit_message_reply_markup)")
record("build_caption defined", "def build_caption" in toggle_code)
record("build_toggle_keyboard defined", "def build_toggle_keyboard" in toggle_code)
record("4-per-row keyboard layout", "len(row) == 4" in toggle_code or "== 4" in toggle_code)

# Check MarkdownV2 handling
has_markdown_v2 = "MarkdownV2" in toggle_code
has_parse_mode = "parse_mode" in toggle_code
record("MarkdownV2 parse_mode for strikethrough", has_markdown_v2 or has_parse_mode,
      "WARNING: Strikethrough (~) needs parse_mode='MarkdownV2' in Telegram API calls")

# 6a: Single ingredient
single = [SAMPLE_INGREDIENTS[0]]
kb = build_toggle_keyboard(single, 1)
record("1 ingredient → 1 button + commit/cancel = 2 rows", len(kb["inline_keyboard"]) == 2)

# 6b: Empty ingredients
try:
    kb_empty = build_toggle_keyboard([], 0)
    record("empty ingredients handled without crash", True)
    record("empty keyboard: commit uses noop callback", kb_empty["inline_keyboard"][0][0]["callback_data"] == "noop")
except Exception as e:
    record("empty ingredients handled without crash", False, f"raised {type(e).__name__}: {e}")

# 6c: Very long ingredient text — button label is compact "✅ #1"
long_ing = {"index": 0, "text": "A" * 200, "selected": True, "recipe_id": RECIPE_ID}
kb_long = build_toggle_keyboard([long_ing], 1)
btn_text = kb_long["inline_keyboard"][0][0]["text"]
record("long ingredient name: button label is short", len(btn_text) < 20, f"len={len(btn_text)} text={btn_text}")

# 6d: Caption with all deselected
all_off = [{**ing, "selected": False} for ing in SAMPLE_INGREDIENTS]
caption = build_caption("Test", "test.com", all_off)
record("all deselected: 8 ❌ symbols", caption.count("❌") == 8)
record("all deselected: 8 strikethroughs", caption.count("~") == 16)  # opening + closing = 2 per item

test_backend_contract()
test_ui_components()
test_callback_simulation()
test_db_state()
test_telegram_integration()
test_edge_cases()

print("\n" + "=" * 60)
print(f"RESULTS: {RESULTS['pass']} passed, {RESULTS['fail']} failed")
print("=" * 60)

failures = [t for t in RESULTS["tests"] if not t["passed"]]
if failures:
    print("\nFAILURES:")
    for f in failures:
        print(f"  ❌ {f['name']}" + (f" — {f['detail']}" if f['detail'] else ""))

# Handoff notes
print("\n" + "=" * 60)
print("HANDOFF NOTES FOR FINAL INTEGRATION")
print("=" * 60)

handler_path = Path("/home/hoffmann_admin/.openclaw/workspace/services/icarus/core/telegram/handler.py")
handler_code = handler_path.read_text()

notes = []

if "recipe_toggle" not in handler_code and "handle_toggle" not in handler_code:
    notes.append("⚠️  CRITICAL: telegram/handler.py does NOT wire recipe_toggle callbacks")
    notes.append("   → Need to add callback_query routing in handle_telegram_update()")
    notes.append("   → Route 'toggle:*' → handle_toggle()")
    notes.append("   → Route 'commit:*' → handle_commit()")
    notes.append("   → Route 'cancel:*' → handle_cancel()")
    notes.append("   → Route recipe URLs → handle_recipe_url()")

if "callback_query" not in handler_code:
    notes.append("⚠️  CRITICAL: No callback_query handling in telegram/handler.py")
    notes.append("   → Telegram Bot API sends callback_query for inline keyboard presses")
    notes.append("   → Must extract data, route to appropriate handler")

toggle_path = Path("/home/hoffmann_admin/.openclaw/workspace/services/icarus/core/handlers/recipe_toggle.py")
toggle_code = toggle_path.read_text()

if "MarkdownV2" not in toggle_code and "parse_mode" not in toggle_code:
    notes.append("⚠️  MEDIUM: build_caption uses ~strikethrough~ but no parse_mode='MarkdownV2'")
    notes.append("   → Strikethrough requires MarkdownV2 in Telegram")
    notes.append("   → Must add parse_mode='MarkdownV2' to edit_message_text calls")
    notes.append("   → Also need to escape special chars: _ * [ ] ( ) ~ ` > # + - = | { } . !")

if "handle_recipe_url" not in handler_code:
    notes.append("⚠️  MEDIUM: telegram/handler.py does not route recipe URLs")
    notes.append("   → Need URL detection in text message handler")
    notes.append("   → Route http(s):// URLs to handle_recipe_url()")

notes.append("")
notes.append("✅ BACKEND CONTRACT VERIFIED:")
notes.append("   → toggle:{recipe_id}:{index} format matches handler parsing")
notes.append("   → commit:{recipe_id} format matches handler parsing")
notes.append("   → cancel:{recipe_id} format matches handler parsing")
notes.append("   → build_caption + build_toggle_keyboard work correctly together")
notes.append("")
notes.append("✅ UI SPEC VERIFIED:")
notes.append("   → 4-per-row compact layout renders correctly")
notes.append("   → ✅/❌ state indicators in button labels")
notes.append("   → Strikethrough (~) in caption for deselected items")
notes.append("   → Index numbers (#1, #2...) in both buttons and caption")
notes.append("   → Commit button shows live count (e.g., '✅ Commit (5)')")
notes.append("   → Zero selection shows '⬜ Select at least 1'")
notes.append("")
notes.append("✅ DATABASE STATE VERIFIED:")
notes.append("   → save/get/update/delete temp state all working")
notes.append("   → add_items to grocery list working")
notes.append("   → TTL mechanism in place (5-min expiry)")

for note in notes:
    print(note)

return RESULTS["fail"] == 0