test_sync.py

import csv
import hashlib
import json
import os
import plistlib
import shutil
import sqlite3
import subprocess
import uuid
from pathlib import Path

import pytest

import browser_bookmark_sync as sync_module
import safari_adapter
from browser_bookmark_sync import (
    App,
    AutomationRunLock,
    ProfileMapping,
    alphabetize_bookmarks,
    automation_readiness,
    catalog_backup_sets,
    close_browser_processes,
    compare_backup_sets,
    deduplicate_bookmarks,
    discover_firefox_profiles,
    discover_profiles,
    export_html,
    iter_urls,
    load_automation_config,
    load_profile_mappings,
    main,
    merge_bookmarks,
    normalized_url,
    parse_args,
    prepare_merged_data,
    prune_backups,
    read_firefox_bookmarks,
    restore_firefox_backup,
    restore_json_backup,
    run_automation,
    running_browser_processes,
    save_profile_mapping,
    synchronize,
    transactional_firefox_write,
    validate_backup_manifest,
    validate_unique_guids,
    verify_firefox_backup,
    verify_json_backup,
    write_launchd_plist,
    write_task_scheduler_script,
)


def safari_document(version: int = 1) -> dict:
    return {
        "WebBookmarkFileVersion": version,
        "Children": [
            {
                "WebBookmarkType": "WebBookmarkTypeList",
                "WebBookmarkIdentifier": "BookmarksBar",
                "Title": "Favorites",
                "Children": [
                    {
                        "WebBookmarkType": "WebBookmarkTypeList",
                        "Title": "Nested",
                        "Children": [
                            {
                                "WebBookmarkType": "WebBookmarkTypeLeaf",
                                "URLString": "https://safari.test/path",
                                "URIDictionary": {"title": "Private Safari title"},
                            }
                        ],
                    }
                ],
            },
            {
                "WebBookmarkType": "WebBookmarkTypeList",
                "WebBookmarkIdentifier": "com.apple.ReadingList",
                "Title": "Reading List",
                "Children": [
                    {
                        "WebBookmarkType": "WebBookmarkTypeLeaf",
                        "URLString": "https://reading-list.test",
                        "URIDictionary": {"title": "Never export"},
                    }
                ],
            },
        ],
    }


def write_safari_plist(path: Path, document: dict | None = None) -> Path:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("wb") as stream:
        plistlib.dump(document or safari_document(), stream, fmt=plistlib.FMT_BINARY)
    return path


@pytest.fixture(autouse=True)
def windows_platform(monkeypatch: pytest.MonkeyPatch):
    monkeypatch.setattr(sync_module, "is_macos", lambda: False)


def data(*urls: str) -> dict:
    children = [{"type": "url", "id": str(i + 10), "name": url, "url": url} for i, url in enumerate(urls)]
    return {"roots": {"bookmark_bar": {"type": "folder", "id": "1", "name": "Bookmarks bar", "children": children}, "other": {"type": "folder", "id": "2", "name": "Other bookmarks", "children": []}}, "version": 1, "checksum": "old"}


def firefox_profile(tmp_path: Path, *urls: str) -> Path:
    profile = tmp_path / "Firefox" / "Profiles" / "test.default-release"
    profile.mkdir(parents=True)
    connection = sqlite3.connect(profile / "places.sqlite")
    connection.execute("PRAGMA journal_mode=WAL")
    connection.executescript(
        """
        CREATE TABLE moz_places (
            id INTEGER PRIMARY KEY,
            url TEXT UNIQUE,
            url_hash INTEGER NOT NULL,
            title TEXT,
            rev_host TEXT NOT NULL DEFAULT '',
            hidden INTEGER NOT NULL DEFAULT 0,
            typed INTEGER NOT NULL DEFAULT 0,
            frecency INTEGER NOT NULL DEFAULT -1,
            guid TEXT UNIQUE NOT NULL,
            foreign_count INTEGER NOT NULL DEFAULT 0
        );
        CREATE TABLE moz_bookmarks (
            id INTEGER PRIMARY KEY,
            type INTEGER NOT NULL,
            fk INTEGER,
            parent INTEGER NOT NULL,
            position INTEGER NOT NULL,
            title TEXT,
            dateAdded INTEGER NOT NULL DEFAULT 0,
            lastModified INTEGER NOT NULL DEFAULT 0,
            guid TEXT UNIQUE NOT NULL,
            syncStatus INTEGER NOT NULL DEFAULT 0,
            syncChangeCounter INTEGER NOT NULL DEFAULT 1
        );
        CREATE TABLE moz_keywords (place_id INTEGER);
        INSERT INTO moz_bookmarks (id, type, parent, position, title, guid)
        VALUES
            (1, 2, 0, 0, '', 'root________'),
            (2, 2, 1, 0, 'Bookmarks Menu', 'menu________'),
            (3, 2, 1, 1, 'Bookmarks Toolbar', 'toolbar_____'),
            (4, 2, 1, 2, 'Other Bookmarks', 'unfiled_____'),
            (5, 2, 1, 3, 'Mobile Bookmarks', 'mobile______');
        """
    )
    for index, url in enumerate(urls, start=1):
        place_id = 100 + index
        connection.execute(
            "INSERT INTO moz_places (id, url, url_hash, title, rev_host, guid, foreign_count) VALUES (?, ?, ?, ?, '', ?, 1)",
            (place_id, url, sync_module.places_url_hash(url), url, f"placeguid{index:03d}"),
        )
        connection.execute(
            "INSERT INTO moz_bookmarks (id, type, fk, parent, position, title, guid) VALUES (?, 1, ?, 3, ?, ?, ?)",
            (200 + index, place_id, index - 1, url, f"bookmark{index:03d}"),
        )
    connection.commit()
    connection.close()
    return profile


@pytest.fixture(autouse=True)
def no_running_browsers(monkeypatch: pytest.MonkeyPatch):
    monkeypatch.setattr(sync_module, "running_browser_processes", lambda: [])
    monkeypatch.setattr(sync_module, "running_firefox_processes", lambda: [])


def test_merge_deduplicates_and_retains_unique_links():
    merged, added = merge_bookmarks(
        data("https://a.test/", "https://b.test"),
        data("https://a.test", "https://c.test"),
        duplicate_mode="aggressive",
    )
    urls = [node["url"] for root in merged["roots"].values() for node in iter_urls(root)]
    assert added == 1
    assert urls.count("https://c.test") == 1
    assert "checksum" not in merged


def test_merge_regenerates_imported_guids_and_preserves_primary_guids():
    primary = data("https://chrome.test")
    primary["roots"]["bookmark_bar"]["guid"] = "00000000-0000-4000-a000-000000000002"
    primary["roots"]["bookmark_bar"]["children"][0]["guid"] = "11111111-1111-4111-8111-111111111111"
    primary["roots"]["other"]["guid"] = "00000000-0000-4000-a000-000000000003"
    secondary = data()
    secondary["roots"]["bookmark_bar"]["children"] = [
        {
            "type": "folder",
            "id": "20",
            "guid": "22222222-2222-4222-8222-222222222222",
            "name": "Edge folder",
            "children": [
                {
                    "type": "url",
                    "id": "21",
                    "guid": "33333333-3333-4333-8333-333333333333",
                    "name": "Edge link",
                    "url": "https://edge.test",
                }
            ],
        }
    ]

    merged, added = merge_bookmarks(primary, secondary)
    guids = [
        node["guid"]
        for root in merged["roots"].values()
        for node in sync_module.walk_nodes(root)
        if node.get("guid")
    ]

    assert added == 1
    assert "11111111-1111-4111-8111-111111111111" in guids
    assert "22222222-2222-4222-8222-222222222222" not in guids
    assert "33333333-3333-4333-8333-333333333333" not in guids
    assert len(guids) == len(set(guid.casefold() for guid in guids))
    for guid in guids:
        uuid.UUID(guid)


def test_guid_validation_rejects_duplicates():
    bookmarks = data("https://one.test", "https://two.test")
    for child in bookmarks["roots"]["bookmark_bar"]["children"]:
        child["guid"] = "11111111-1111-4111-8111-111111111111"

    with pytest.raises(RuntimeError, match="duplicate GUID values"):
        validate_unique_guids(bookmarks)


def test_export_html(tmp_path: Path):
    destination = tmp_path / "bookmarks.html"
    count = export_html(data("https://example.test/?a=1&b=2"), destination)
    assert count == 1
    assert "NETSCAPE-Bookmark-file-1" in destination.read_text()
    assert "&" in destination.read_text()


def test_firefox_profile_discovery_uses_explicit_profiles_ini(tmp_path: Path):
    source_profile = firefox_profile(tmp_path / "source", "https://firefox.test")
    firefox_root = tmp_path / "Mozilla" / "Firefox"
    relative_profile = firefox_root / "Profiles" / "default-release"
    absolute_profile = tmp_path / "absolute-profile"
    shutil.copytree(source_profile, relative_profile)
    shutil.copytree(source_profile, absolute_profile)
    profiles_ini = firefox_root / "profiles.ini"
    profiles_ini.write_text(
        "[Profile0]\nName=Default\nIsRelative=1\nPath=Profiles/default-release\nDefault=1\n\n"
        f"[Profile1]\nName=Absolute\nIsRelative=0\nPath={absolute_profile.as_posix()}\n"
    )

    assert discover_firefox_profiles(profiles_ini) == [relative_profile.resolve(), absolute_profile.resolve()]


def test_macos_discovers_standard_chromium_and_firefox_profiles(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
):
    monkeypatch.setattr(sync_module, "is_macos", lambda: True)
    monkeypatch.setattr(sync_module.Path, "home", lambda: tmp_path)
    application_support = tmp_path / "Library" / "Application Support"
    chrome = application_support / "Google" / "Chrome" / "Default"
    edge = application_support / "Microsoft Edge" / "Profile 1"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    (chrome / "Bookmarks").write_text(json.dumps(data()))
    (edge / "Bookmarks").write_text(json.dumps(data()))
    firefox_root = application_support / "Firefox"
    firefox = firefox_root / "Profiles" / "test.default-release"
    firefox.mkdir(parents=True)
    (firefox / "places.sqlite").touch()
    (firefox_root / "profiles.ini").write_text(
        "[Profile0]\nName=default-release\nIsRelative=1\nPath=Profiles/test.default-release\nDefault=1\n"
    )

    assert discover_profiles("Chrome") == [chrome]
    assert discover_profiles("Edge") == [edge]
    assert discover_firefox_profiles() == [firefox.resolve()]


def test_firefox_import_uses_selected_duplicate_mode(tmp_path: Path, capsys: pytest.CaptureFixture[str]):
    profile = firefox_profile(tmp_path, "https://EXAMPLE.test/Path/")
    firefox = read_firefox_bookmarks(profile)

    conservative, conservative_preview = prepare_merged_data(
        data("https://example.test/path"),
        data(),
        duplicate_mode="conservative",
        firefox=firefox,
    )
    aggressive, aggressive_preview = prepare_merged_data(
        data("https://example.test/path"),
        data(),
        duplicate_mode="aggressive",
        firefox=firefox,
    )

    assert len([node for root in conservative["roots"].values() for node in iter_urls(root)]) == 2
    assert len([node for root in aggressive["roots"].values() for node in iter_urls(root)]) == 1
    assert conservative_preview.firefox_count == aggressive_preview.firefox_count == 1
    assert conservative_preview.firefox_enabled and aggressive_preview.firefox_enabled

    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    (chrome / "Bookmarks").write_text(json.dumps(data("https://chrome.test")))
    (edge / "Bookmarks").write_text(json.dumps(data("https://edge.test")))
    assert main(
        [
            "--dry-run",
            "--chrome-profile",
            str(chrome),
            "--edge-profile",
            str(edge),
            "--firefox-profile",
            str(profile),
        ]
    ) == 0
    assert "Firefox bookmarks: 1" in capsys.readouterr().out


def test_firefox_can_be_disabled_without_entering_firefox_code(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    (chrome / "Bookmarks").write_text(json.dumps(data("https://chrome.test")))
    (edge / "Bookmarks").write_text(json.dumps(data("https://edge.test")))
    monkeypatch.setattr(sync_module, "read_firefox_bookmarks", lambda _profile: pytest.fail("Firefox was read"))

    result = synchronize(chrome, edge, tmp_path / "backups", write=False)

    assert result.firefox_count == 0
    assert not list((tmp_path / "backups").glob("Firefox_*.sqlite"))
    assert "firefox_count" not in json.loads(result.manifest_path.read_text())["summary"]
    assert "firefox_count" not in result.log_path.read_text()
    assert result.preview.render() == prepare_merged_data(data("https://chrome.test"), data("https://edge.test"))[1].render()


def test_firefox_export_backs_up_before_write_and_adds_missing_bookmarks(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    (chrome / "Bookmarks").write_text(json.dumps(data("https://chrome.test")))
    (edge / "Bookmarks").write_text(json.dumps(data("https://edge.test")))
    firefox = firefox_profile(tmp_path, "https://firefox.test")
    backup_dir = tmp_path / "backups"
    original_checkpoint = sync_module.checkpoint_firefox_database

    def assert_backup_precedes_write(path: Path):
        firefox_backups = list(backup_dir.glob("Firefox_*.sqlite"))
        manifests = list(backup_dir.glob("Manifest_*.json"))
        assert len(firefox_backups) == len(manifests) == 1
        validate_backup_manifest(manifests[0])
        assert firefox_backups[0].name in {
            entry["name"] for entry in json.loads(manifests[0].read_text())["files"]
        }
        original_checkpoint(path)

    monkeypatch.setattr(sync_module, "checkpoint_firefox_database", assert_backup_precedes_write)

    result = synchronize(
        chrome,
        edge,
        backup_dir,
        write=True,
        firefox_profile=firefox,
        firefox_export=True,
    )

    assert result.firefox_added == 2
    assert {node["url"] for root in read_firefox_bookmarks(firefox)["roots"].values() for node in iter_urls(root)} == {
        "https://chrome.test",
        "https://edge.test",
        "https://firefox.test",
    }
    firefox_backups = list(backup_dir.glob("Firefox_*.sqlite"))
    assert len(firefox_backups) == 1
    manifest = json.loads(result.manifest_path.read_text())
    assert firefox_backups[0].name in {entry["name"] for entry in manifest["files"]}
    validate_backup_manifest(result.manifest_path)
    assert not list(firefox.glob("places.pending.*"))


def test_firefox_running_blocks_export_after_backups(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    (chrome / "Bookmarks").write_text(json.dumps(data("https://chrome.test")))
    (edge / "Bookmarks").write_text(json.dumps(data("https://edge.test")))
    firefox = firefox_profile(tmp_path, "https://firefox.test")
    backup_dir = tmp_path / "backups"
    monkeypatch.setattr(sync_module, "running_firefox_processes", lambda: ["firefox.exe"])

    with pytest.raises(RuntimeError, match="firefox.exe"):
        synchronize(
            chrome,
            edge,
            backup_dir,
            write=True,
            firefox_profile=firefox,
            firefox_export=True,
        )

    assert len(list(backup_dir.glob("Firefox_*.sqlite"))) == 1
    assert len(list(backup_dir.glob("Manifest_*.json"))) == 1


def test_firefox_replacement_failure_restores_chrome_and_edge(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    chrome_file = chrome / "Bookmarks"
    edge_file = edge / "Bookmarks"
    chrome_original = data("https://chrome.test")
    edge_original = data("https://edge.test")
    chrome_file.write_text(json.dumps(chrome_original))
    edge_file.write_text(json.dumps(edge_original))
    firefox = firefox_profile(tmp_path, "https://firefox.test")
    firefox_file = firefox / "places.sqlite"
    firefox_staged = firefox / "places.pending.sqlite"
    shutil.copy2(firefox_file, firefox_staged)
    original_replace = sync_module.os.replace

    def fail_firefox(source: Path | str, destination: Path | str):
        if Path(destination) == firefox_file:
            raise OSError("simulated Firefox replacement failure")
        return original_replace(source, destination)

    monkeypatch.setattr(sync_module.os, "replace", fail_firefox)

    with pytest.raises(RuntimeError, match="Chrome and Edge were restored automatically"):
        transactional_firefox_write(chrome_file, edge_file, firefox_file, data("https://merged.test"), firefox_staged)

    assert json.loads(chrome_file.read_text()) == chrome_original
    assert json.loads(edge_file.read_text()) == edge_original


def test_deduplicate_bookmarks_removes_normalized_urls_across_folders():
    bookmarks = data("https://first.test", "https://duplicate.test/")
    bookmarks["roots"]["other"]["children"] = [
        {
            "type": "folder",
            "id": "20",
            "name": "Nested",
            "children": [
                {"type": "url", "id": "21", "name": "Duplicate", "url": "https://duplicate.test"},
                {"type": "url", "id": "22", "name": "Unique", "url": "https://unique.test"},
            ],
        }
    ]

    removed = deduplicate_bookmarks(bookmarks, mode="aggressive")
    urls = [node["url"] for root in bookmarks["roots"].values() for node in iter_urls(root)]

    assert removed == 1
    assert urls == ["https://first.test", "https://duplicate.test/", "https://unique.test"]


def test_alphabetize_bookmarks_sorts_folders_first_and_recursively():
    bookmarks = data()
    bookmarks["roots"]["bookmark_bar"]["children"] = [
        {"type": "url", "id": "10", "name": "Zulu", "url": "https://zulu.test"},
        {
            "type": "folder",
            "id": "11",
            "name": "beta folder",
            "children": [
                {"type": "url", "id": "12", "name": "Zulu", "url": "https://nested-zulu.test"},
                {"type": "url", "id": "13", "name": "Alpha", "url": "https://nested-alpha.test"},
            ],
        },
        {"type": "url", "id": "14", "name": "alpha", "url": "https://alpha.test"},
        {"type": "folder", "id": "15", "name": "Alpha folder", "children": []},
    ]

    alphabetize_bookmarks(bookmarks)
    children = bookmarks["roots"]["bookmark_bar"]["children"]

    assert [child["name"] for child in children] == ["Alpha folder", "beta folder", "alpha", "Zulu"]
    assert [child["name"] for child in children[1]["children"]] == ["Alpha", "Zulu"]


def test_organization_options_are_disabled_by_default():
    args = parse_args([])

    assert args.keep == 50
    assert not args.deduplicate
    assert not args.alphabetize
    assert not args.force
    assert not args.close_browsers


def test_conservative_url_matching_preserves_potentially_distinct_urls():
    assert normalized_url(" HTTPS://Example.Test/Path?Value=One ") == "https://example.test/Path?Value=One"
    assert normalized_url("https://example.test/Path") != normalized_url("https://example.test/path")
    assert normalized_url("https://example.test/") != normalized_url("https://example.test")
    assert normalized_url("https://example.test/Path/", mode="aggressive") == normalized_url(
        "https://example.test/path",
        mode="aggressive",
    )


def test_sync_and_dry_run_are_mutually_exclusive():
    with pytest.raises(SystemExit):
        parse_args(["--sync", "--dry-run"])


def test_backup_retention_rejects_values_above_50():
    with pytest.raises(SystemExit):
        parse_args(["--keep", "51"])


def test_backup_retention_keeps_at_most_50_html_backups(tmp_path: Path):
    for index in range(51):
        path = tmp_path / f"Bookmarks_2026-08-07_12-00-00_{index:06}.html"
        path.write_text(str(index))
        os.utime(path, (index + 1, index + 1))

    prune_backups(tmp_path, 50)

    backups = sorted(tmp_path.glob("Bookmarks_*.html"))
    assert len(backups) == 50
    assert not (tmp_path / "Bookmarks_2026-08-07_12-00-00_000000.html").exists()


def test_backup_retention_uses_filename_timestamp_instead_of_file_mtime(tmp_path: Path):
    older = tmp_path / "Chrome_2026-08-07_12-00-00_000001.json"
    newer = tmp_path / "Chrome_2026-08-07_12-00-00_000002.json"
    older.write_text("older")
    newer.write_text("newer")
    os.utime(older, (200, 200))
    os.utime(newer, (100, 100))

    prune_backups(tmp_path, 1)

    assert not older.exists()
    assert newer.exists()


def test_backup_retention_ignores_unrecognized_files_and_directories(tmp_path: Path):
    unrelated = [
        tmp_path / "Chrome_notes.json",
        tmp_path / "Edge_backup.json",
        tmp_path / "Bookmarks_readme.html",
    ]
    for path in unrelated:
        path.write_text("keep")
    directory = tmp_path / "Chrome_2026-08-07_12-00-00_000001.json"
    directory.mkdir()

    prune_backups(tmp_path, 1)

    assert all(path.exists() for path in unrelated)
    assert directory.is_dir()


def test_backup_retention_prunes_old_manifests(tmp_path: Path):
    older = tmp_path / "Manifest_2026-08-07_12-00-00_000001.json"
    newer = tmp_path / "Manifest_2026-08-07_12-00-00_000002.json"
    older.write_text("{}")
    newer.write_text("{}")

    prune_backups(tmp_path, 1)

    assert not older.exists()
    assert newer.exists()


def test_force_and_close_browsers_are_mutually_exclusive():
    assert parse_args(["--close-browsers"]).close_browsers
    with pytest.raises(SystemExit):
        parse_args(["--force", "--close-browsers"])


def test_synchronize_backs_up_and_writes_both(tmp_path: Path):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    (chrome / "Bookmarks").write_text(json.dumps(data("https://chrome.test")))
    (edge / "Bookmarks").write_text(json.dumps(data("https://edge.test")))
    result = synchronize(chrome, edge, tmp_path / "backups", keep=10, write=True)
    assert result.merged_count == 2
    assert json.loads((chrome / "Bookmarks").read_text()) == json.loads((edge / "Bookmarks").read_text())
    assert len(list((tmp_path / "backups").glob("Chrome_*.json"))) == 1
    assert len(list((tmp_path / "backups").glob("Edge_*.json"))) == 1
    assert result.manifest_path.exists()
    assert result.html_path.exists()


def test_synchronize_applies_optional_deduplication_and_alphabetizing(tmp_path: Path):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    (chrome / "Bookmarks").write_text(
        json.dumps(data("https://zulu.test", "https://alpha.test/", "https://alpha.test"))
    )
    (edge / "Bookmarks").write_text(json.dumps(data("https://bravo.test")))

    result = synchronize(
        chrome,
        edge,
        tmp_path / "backups",
        write=True,
        deduplicate=True,
        alphabetize=True,
        duplicate_mode="aggressive",
    )
    written = json.loads((chrome / "Bookmarks").read_text())
    bookmark_bar = written["roots"]["bookmark_bar"]["children"]
    imported = written["roots"]["other"]["children"][0]["children"]

    assert result.duplicates_removed == 1
    assert result.alphabetized
    assert [child["name"] for child in bookmark_bar] == ["https://alpha.test/", "https://zulu.test"]
    assert [child["name"] for child in imported] == ["https://bravo.test"]
    assert written == json.loads((edge / "Bookmarks").read_text())


def test_repeated_synchronization_preserves_unique_guids(tmp_path: Path):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    chrome_data = data("https://chrome.test")
    edge_data = data("https://edge.test")
    chrome_data["roots"]["bookmark_bar"]["guid"] = "00000000-0000-4000-a000-000000000002"
    chrome_data["roots"]["other"]["guid"] = "00000000-0000-4000-a000-000000000003"
    chrome_data["roots"]["bookmark_bar"]["children"][0]["guid"] = "11111111-1111-4111-8111-111111111111"
    edge_data["roots"]["bookmark_bar"]["guid"] = "00000000-0000-4000-a000-000000000002"
    edge_data["roots"]["other"]["guid"] = "00000000-0000-4000-a000-000000000003"
    edge_data["roots"]["bookmark_bar"]["children"][0]["guid"] = "22222222-2222-4222-8222-222222222222"
    (chrome / "Bookmarks").write_text(json.dumps(chrome_data))
    (edge / "Bookmarks").write_text(json.dumps(edge_data))

    synchronize(chrome, edge, tmp_path / "backups", write=True)
    first = json.loads((chrome / "Bookmarks").read_text())
    first_guids = [
        node["guid"]
        for root in first["roots"].values()
        for node in sync_module.walk_nodes(root)
        if node.get("guid")
    ]
    synchronize(chrome, edge, tmp_path / "backups", write=True)
    second = json.loads((chrome / "Bookmarks").read_text())
    second_guids = [
        node["guid"]
        for root in second["roots"].values()
        for node in sync_module.walk_nodes(root)
        if node.get("guid")
    ]

    assert second == json.loads((edge / "Bookmarks").read_text())
    assert second_guids == first_guids
    assert len(second_guids) == len(set(guid.casefold() for guid in second_guids))
    assert json.dumps(second).count("Imported from other browser") == 1


def test_synchronize_first_write_failure_changes_neither_browser(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    chrome_path = chrome / "Bookmarks"
    edge_path = edge / "Bookmarks"
    chrome_original = json.dumps(data("https://chrome.test"))
    edge_original = json.dumps(data("https://edge.test"))
    chrome_path.write_text(chrome_original)
    edge_path.write_text(edge_original)
    real_replace = os.replace

    def fail_chrome_replace(source: str | Path, destination: str | Path) -> None:
        if Path(source).name.startswith("Bookmarks.pending.") and Path(destination) == chrome_path:
            raise OSError("simulated Chrome replacement failure")
        real_replace(source, destination)

    monkeypatch.setattr(sync_module.os, "replace", fail_chrome_replace)

    with pytest.raises(RuntimeError, match="Neither browser was changed"):
        synchronize(chrome, edge, tmp_path / "backups", write=True)

    assert chrome_path.read_text() == chrome_original
    assert edge_path.read_text() == edge_original
    assert not list(chrome.glob("Bookmarks.pending.*"))
    assert not list(edge.glob("Bookmarks.pending.*"))
    assert not list(chrome.glob("Bookmarks.rollback.*"))


def test_synchronize_second_write_failure_restores_chrome(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    chrome_path = chrome / "Bookmarks"
    edge_path = edge / "Bookmarks"
    chrome_original = json.dumps(data("https://chrome.test"))
    edge_original = json.dumps(data("https://edge.test"))
    chrome_path.write_text(chrome_original)
    edge_path.write_text(edge_original)
    real_replace = os.replace

    def fail_edge_replace(source: str | Path, destination: str | Path) -> None:
        if Path(source).name.startswith("Bookmarks.pending.") and Path(destination) == edge_path:
            raise OSError("simulated Edge replacement failure")
        real_replace(source, destination)

    monkeypatch.setattr(sync_module.os, "replace", fail_edge_replace)

    with pytest.raises(RuntimeError, match="Chrome was restored automatically"):
        synchronize(chrome, edge, tmp_path / "backups", write=True)

    assert chrome_path.read_text() == chrome_original
    assert edge_path.read_text() == edge_original
    assert not list(chrome.glob("Bookmarks.pending.*"))
    assert not list(edge.glob("Bookmarks.pending.*"))
    assert not list(chrome.glob("Bookmarks.rollback.*"))


def test_running_browser_processes_detects_chrome_and_edge(monkeypatch: pytest.MonkeyPatch):
    output = (
        '"chrome.exe","100","Console","1","10,000 K"\n'
        '"unrelated.exe","200","Console","1","10,000 K"\n'
        '"msedge.exe","300","Console","1","10,000 K"\n'
        '"chrome.exe","400","Console","1","10,000 K"\n'
    )
    completed = sync_module.subprocess.CompletedProcess([], 0, stdout=output, stderr="")
    monkeypatch.setattr(sync_module.subprocess, "run", lambda *args, **kwargs: completed)

    assert running_browser_processes() == ["chrome.exe", "msedge.exe"]


def test_macos_process_detection_uses_executable_names(monkeypatch: pytest.MonkeyPatch):
    monkeypatch.setattr(sync_module, "is_macos", lambda: True)
    output = (
        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome\n"
        "/Applications/Google Chrome.app/Contents/Frameworks/Google Chrome Helper\n"
        "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge\n"
        "/Applications/Firefox.app/Contents/MacOS/firefox\n"
    )
    completed = sync_module.subprocess.CompletedProcess([], 0, stdout=output, stderr="")
    monkeypatch.setattr(sync_module.subprocess, "run", lambda *args, **kwargs: completed)

    assert running_browser_processes() == ["Google Chrome", "Microsoft Edge"]
    assert sync_module.running_macos_processes(("firefox",), "Firefox") == ["firefox"]


@pytest.mark.parametrize(
    "processes",
    [["chrome.exe"], ["msedge.exe"], ["chrome.exe", "msedge.exe"]],
    ids=["chrome-running", "edge-running", "both-running"],
)
def test_synchronize_blocks_running_browsers_after_export(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    processes: list[str],
):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    backup_dir = tmp_path / "backups"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    chrome_path = chrome / "Bookmarks"
    edge_path = edge / "Bookmarks"
    chrome_original = json.dumps(data("https://chrome.test"))
    edge_original = json.dumps(data("https://edge.test"))
    chrome_path.write_text(chrome_original)
    edge_path.write_text(edge_original)
    monkeypatch.setattr(sync_module, "running_browser_processes", lambda: processes)

    with pytest.raises(RuntimeError) as error:
        synchronize(chrome, edge, backup_dir, write=True)

    assert all(process in str(error.value) for process in processes)
    assert chrome_path.read_text() == chrome_original
    assert edge_path.read_text() == edge_original
    assert len(list(backup_dir.glob("Chrome_*.json"))) == 1
    assert len(list(backup_dir.glob("Edge_*.json"))) == 1
    assert len(list(backup_dir.glob("Manifest_*.json"))) == 1
    assert len(list(backup_dir.glob("*.html"))) == 1


def test_export_only_ignores_running_browsers(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    chrome_path = chrome / "Bookmarks"
    edge_path = edge / "Bookmarks"
    chrome_original = json.dumps(data("https://chrome.test"))
    edge_original = json.dumps(data("https://edge.test"))
    chrome_path.write_text(chrome_original)
    edge_path.write_text(edge_original)

    def unexpected_detection() -> list[str]:
        raise AssertionError("Export-only mode must not check browser processes")

    monkeypatch.setattr(sync_module, "running_browser_processes", unexpected_detection)

    result = synchronize(chrome, edge, tmp_path / "backups", write=False, close_browsers=True)

    assert result.html_path.exists()
    assert chrome_path.read_text() == chrome_original
    assert edge_path.read_text() == edge_original


def test_rapid_exports_create_distinct_html_backups(tmp_path: Path):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    backup_dir = tmp_path / "backups"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    (chrome / "Bookmarks").write_text(json.dumps(data("https://chrome.test")))
    (edge / "Bookmarks").write_text(json.dumps(data("https://edge.test")))

    first = synchronize(chrome, edge, backup_dir, write=False)
    second = synchronize(chrome, edge, backup_dir, write=False)

    assert first.html_path != second.html_path
    assert len(list(backup_dir.glob("Bookmarks_*.html"))) == 2
    assert len(list(backup_dir.glob("Chrome_*.json"))) == 2
    assert len(list(backup_dir.glob("Edge_*.json"))) == 2
    assert len(list(backup_dir.glob("Manifest_*.json"))) == 2


def test_force_synchronizes_without_process_detection(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    chrome_path = chrome / "Bookmarks"
    edge_path = edge / "Bookmarks"
    chrome_path.write_text(json.dumps(data("https://chrome.test")))
    edge_path.write_text(json.dumps(data("https://edge.test")))

    def unexpected_detection() -> list[str]:
        raise AssertionError("Forced synchronization must bypass process detection")

    monkeypatch.setattr(sync_module, "running_browser_processes", unexpected_detection)

    synchronize(chrome, edge, tmp_path / "backups", write=True, force=True)

    assert json.loads(chrome_path.read_text()) == json.loads(edge_path.read_text())


def test_edge_wins_uses_edge_as_primary_structure():
    chrome = data("https://chrome.test")
    edge = data("https://edge.test")

    merged, preview = prepare_merged_data(chrome, edge, merge_strategy="edge-wins")
    bookmark_bar_urls = [node["url"] for node in iter_urls(merged["roots"]["bookmark_bar"])]
    imported_urls = [node["url"] for node in iter_urls(merged["roots"]["other"])]

    assert bookmark_bar_urls == ["https://edge.test"]
    assert imported_urls == ["https://chrome.test"]
    assert merged["roots"]["other"]["children"][0]["name"] == "Imported from Chrome"
    assert preview.merge_strategy == "edge-wins"


def test_merge_folders_reports_no_new_wrapper_folder():
    chrome = data()
    edge = data()
    chrome["roots"]["bookmark_bar"]["children"] = [
        {
            "type": "folder",
            "id": "10",
            "name": "Shared",
            "children": [{"type": "url", "id": "11", "name": "Chrome", "url": "https://chrome.test"}],
        }
    ]
    edge["roots"]["bookmark_bar"]["children"] = [
        {
            "type": "folder",
            "id": "20",
            "name": "shared",
            "children": [{"type": "url", "id": "21", "name": "Edge", "url": "https://edge.test"}],
        }
    ]

    merged, preview = prepare_merged_data(chrome, edge, merge_strategy="merge-folders")
    shared = merged["roots"]["bookmark_bar"]["children"][0]

    assert [node["url"] for node in iter_urls(shared)] == ["https://chrome.test", "https://edge.test"]
    assert not merged["roots"]["other"]["children"]
    assert preview.folders_added == 0


def test_cli_dry_run_does_not_create_backups_or_write_profiles(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    backup_dir = tmp_path / "backups"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    chrome_path = chrome / "Bookmarks"
    edge_path = edge / "Bookmarks"
    chrome_original = json.dumps(data("https://chrome.test"))
    edge_original = json.dumps(data("https://edge.test"))
    chrome_path.write_text(chrome_original)
    edge_path.write_text(edge_original)

    exit_code = main(
        [
            "--dry-run",
            "--chrome-profile",
            str(chrome),
            "--edge-profile",
            str(edge),
            "--backup-dir",
            str(backup_dir),
        ]
    )

    assert exit_code == 0
    assert "Strategy: chrome-wins" in capsys.readouterr().out
    assert chrome_path.read_text() == chrome_original
    assert edge_path.read_text() == edge_original
    assert not backup_dir.exists()


def test_close_browsers_terminates_detected_processes_then_synchronizes(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    chrome_path = chrome / "Bookmarks"
    edge_path = edge / "Bookmarks"
    chrome_path.write_text(json.dumps(data("https://chrome.test")))
    edge_path.write_text(json.dumps(data("https://edge.test")))
    detections = iter([["chrome.exe", "msedge.exe"], []])
    closed: list[str] = []
    monkeypatch.setattr(sync_module, "running_browser_processes", lambda: next(detections))
    monkeypatch.setattr(sync_module, "close_browser_processes", lambda processes: closed.extend(processes))

    result = synchronize(chrome, edge, tmp_path / "backups", write=True, close_browsers=True)

    assert closed == ["chrome.exe", "msedge.exe"]
    assert result.closed_processes == ("chrome.exe", "msedge.exe")
    assert json.loads(chrome_path.read_text()) == json.loads(edge_path.read_text())


def test_close_browsers_blocks_when_processes_remain(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    backup_dir = tmp_path / "backups"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    chrome_path = chrome / "Bookmarks"
    edge_path = edge / "Bookmarks"
    chrome_original = json.dumps(data("https://chrome.test"))
    edge_original = json.dumps(data("https://edge.test"))
    chrome_path.write_text(chrome_original)
    edge_path.write_text(edge_original)
    monkeypatch.setattr(sync_module, "running_browser_processes", lambda: ["chrome.exe"])
    monkeypatch.setattr(sync_module, "close_browser_processes", lambda processes: None)
    monkeypatch.setattr(sync_module, "wait_for_browsers_to_close", lambda: ["chrome.exe"])

    with pytest.raises(RuntimeError, match="Could not close these browser processes: chrome.exe"):
        synchronize(chrome, edge, backup_dir, write=True, close_browsers=True)

    assert chrome_path.read_text() == chrome_original
    assert edge_path.read_text() == edge_original
    assert len(list(backup_dir.glob("Bookmarks_*.html"))) == 1


def test_close_browser_processes_uses_forceful_taskkill(monkeypatch: pytest.MonkeyPatch):
    commands: list[list[str]] = []
    completed = sync_module.subprocess.CompletedProcess([], 0, stdout="", stderr="")

    def record_run(command, **kwargs):
        commands.append(command)
        return completed

    monkeypatch.setattr(sync_module.subprocess, "run", record_run)

    close_browser_processes(["chrome.exe", "msedge.exe", "notepad.exe"])

    assert commands == [
        ["taskkill", "/IM", "chrome.exe", "/T", "/F"],
        ["taskkill", "/IM", "msedge.exe", "/T", "/F"],
    ]


def test_close_browser_processes_uses_exact_macos_names(monkeypatch: pytest.MonkeyPatch):
    monkeypatch.setattr(sync_module, "is_macos", lambda: True)
    commands: list[list[str]] = []
    completed = sync_module.subprocess.CompletedProcess([], 0, stdout="", stderr="")
    monkeypatch.setattr(
        sync_module.subprocess,
        "run",
        lambda command, **kwargs: commands.append(command) or completed,
    )

    close_browser_processes(["Google Chrome", "Microsoft Edge", "firefox", "Finder"])

    assert commands == [
        ["pkill", "-x", "Google Chrome"],
        ["pkill", "-x", "Microsoft Edge"],
        ["pkill", "-x", "firefox"],
    ]


def test_cli_running_browser_error_returns_nonzero(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    capsys: pytest.CaptureFixture[str],
):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    (chrome / "Bookmarks").write_text(json.dumps(data("https://chrome.test")))
    (edge / "Bookmarks").write_text(json.dumps(data("https://edge.test")))
    monkeypatch.setattr(sync_module, "running_browser_processes", lambda: ["chrome.exe"])

    exit_code = main(
        [
            "--sync",
            "--chrome-profile",
            str(chrome),
            "--edge-profile",
            str(edge),
            "--backup-dir",
            str(tmp_path / "backups"),
        ]
    )
    captured = capsys.readouterr()

    assert exit_code == 1
    assert captured.out == ""
    assert "Error: Synchronization blocked" in captured.err
    assert "chrome.exe" in captured.err


def test_gui_error_shows_detected_browser_processes(monkeypatch: pytest.MonkeyPatch):
    class Value:
        def __init__(self, value):
            self.value = value

        def get(self):
            return self.value

    app = object.__new__(App)
    app.chrome = Value("Chrome profile")
    app.edge = Value("Edge profile")
    app.backups = Value("Backup directory")
    app.keep = Value(30)
    app.deduplicate = Value(False)
    app.alphabetize = Value(False)
    app.duplicate_mode = Value("conservative")
    app.merge_strategy = Value("chrome-wins")
    errors: list[tuple[str, str]] = []
    monkeypatch.setattr(sync_module.messagebox, "askyesno", lambda *args: True)
    monkeypatch.setattr(sync_module.messagebox, "showerror", lambda title, message: errors.append((title, message)))

    def blocked_sync(*args, **kwargs):
        raise RuntimeError("Synchronization blocked: chrome.exe, msedge.exe")

    monkeypatch.setattr(sync_module, "synchronize", blocked_sync)

    App._run(app, True)

    assert errors == [(sync_module.APP_NAME, "Synchronization blocked: chrome.exe, msedge.exe")]


def test_conservative_url_matching_preserves_case_and_trailing_slash():
    assert normalized_url("HTTPS://Example.COM/Reports/Q1") == "https://example.com/Reports/Q1"
    assert normalized_url("https://example.com/reports/q1") != normalized_url("https://example.com/Reports/Q1")
    assert normalized_url("https://example.com/") != normalized_url("https://example.com")


def test_aggressive_url_matching_is_explicit():
    assert normalized_url("HTTPS://Example.COM/Reports/Q1/", "aggressive") == normalized_url(
        "https://example.com/reports/q1", "aggressive"
    )


@pytest.mark.parametrize("strategy", sync_module.MERGE_STRATEGIES)
def test_all_merge_strategies_produce_a_union(strategy: str):
    merged, preview = prepare_merged_data(
        data("https://chrome.test"),
        data("https://edge.test"),
        merge_strategy=strategy,
    )
    urls = {node["url"] for root in merged["roots"].values() for node in iter_urls(root)}

    assert urls == {"https://chrome.test", "https://edge.test"}
    assert preview.merge_strategy == strategy
    assert preview.merged_count == 2


def test_merge_folders_combines_matching_folder_names():
    chrome = data()
    edge = data()
    chrome["roots"]["bookmark_bar"]["children"] = [
        {"type": "folder", "id": "10", "name": "Shared", "children": [{"type": "url", "id": "11", "name": "A", "url": "https://a.test"}]}
    ]
    edge["roots"]["bookmark_bar"]["children"] = [
        {"type": "folder", "id": "20", "name": "shared", "children": [{"type": "url", "id": "21", "name": "B", "url": "https://b.test"}]}
    ]

    merged, _ = prepare_merged_data(chrome, edge, merge_strategy="merge-folders")
    folders = merged["roots"]["bookmark_bar"]["children"]

    assert len(folders) == 1
    assert {node["url"] for node in iter_urls(folders[0])} == {"https://a.test", "https://b.test"}


def test_dry_run_creates_no_backup_or_write(tmp_path: Path, capsys: pytest.CaptureFixture[str]):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    chrome_path = chrome / "Bookmarks"
    edge_path = edge / "Bookmarks"
    chrome_original = json.dumps(data("https://chrome.test"))
    edge_original = json.dumps(data("https://edge.test"))
    chrome_path.write_text(chrome_original)
    edge_path.write_text(edge_original)

    exit_code = main(["--dry-run", "--chrome-profile", str(chrome), "--edge-profile", str(edge), "--backup-dir", str(tmp_path / "backups")])

    assert exit_code == 0
    assert "Final bookmark count: 2" in capsys.readouterr().out
    assert not (tmp_path / "backups").exists()
    assert chrome_path.read_text() == chrome_original
    assert edge_path.read_text() == edge_original


def preview_report_profiles(tmp_path: Path) -> tuple[Path, Path, Path, Path, str, str]:
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    chrome_path = chrome / "Bookmarks"
    edge_path = edge / "Bookmarks"
    chrome_data = data("https://private-chrome.test/token=secret")
    chrome_data["roots"]["bookmark_bar"]["children"][0]["name"] = "Private Chrome Bookmark"
    edge_data = data("https://private-edge.test/account")
    edge_data["roots"]["bookmark_bar"]["children"][0]["name"] = "Private Edge Bookmark"
    chrome_original = json.dumps(chrome_data)
    edge_original = json.dumps(edge_data)
    chrome_path.write_text(chrome_original)
    edge_path.write_text(edge_original)
    return chrome, edge, chrome_path, edge_path, chrome_original, edge_original


def test_json_preview_report_defaults_to_counts_and_does_not_change_browser_or_backup_files(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
):
    chrome, edge, chrome_path, edge_path, chrome_original, edge_original = preview_report_profiles(tmp_path)
    backup_dir = tmp_path / "backups"
    report = tmp_path / "private" / "browser-bookmark-preview.json"
    monkeypatch.setattr(sync_module, "prune_backups", lambda *_args, **_kwargs: pytest.fail("pruning called"))

    exit_code = main(
        [
            "--dry-run",
            "--preview-report",
            str(report),
            "--chrome-profile",
            str(chrome),
            "--edge-profile",
            str(edge),
            "--backup-dir",
            str(backup_dir),
        ]
    )
    document = json.loads(report.read_text())
    serialized = json.dumps(document)

    assert exit_code == 0
    assert document["schema_version"] == 1
    assert document["kind"] == "preview-report"
    assert not document["bookmark_details_included"]
    assert document["mappings"][0]["mapping"] == "direct"
    assert document["mappings"][0]["counts"]["final_bookmarks"] == 2
    assert document["mappings"][0]["changes"]["chrome_only_urls"] == 1
    assert "bookmarks" not in document["mappings"][0]
    assert "private-chrome.test" not in serialized
    assert "Private Chrome Bookmark" not in serialized
    assert str(chrome) not in serialized
    assert chrome_path.read_text() == chrome_original
    assert edge_path.read_text() == edge_original
    assert not backup_dir.exists()
    assert [path.name for path in report.parent.iterdir()] == [report.name]


def test_json_preview_report_includes_private_details_only_with_explicit_option(tmp_path: Path):
    chrome, edge, _, _, _, _ = preview_report_profiles(tmp_path)
    report = tmp_path / "browser-bookmark-preview-details.json"

    exit_code = main(
        [
            "--dry-run",
            "--preview-report",
            str(report),
            "--include-bookmark-details",
            "--chrome-profile",
            str(chrome),
            "--edge-profile",
            str(edge),
        ]
    )
    document = json.loads(report.read_text())
    details = document["mappings"][0]["bookmarks"]

    assert exit_code == 0
    assert document["bookmark_details_included"]
    assert {item["name"] for item in details} == {"Private Chrome Bookmark", "Private Edge Bookmark"}
    assert {item["url"] for item in details} == {
        "https://private-chrome.test/token=secret",
        "https://private-edge.test/account",
    }
    assert {item["folder_path"] for item in details} == {"Bookmarks bar", "Other bookmarks/Imported from other browser"}


def test_csv_preview_reports_cover_default_and_explicit_detail_schemas(tmp_path: Path):
    chrome, edge, _, _, _, _ = preview_report_profiles(tmp_path)
    report = tmp_path / "browser-bookmark-preview.csv"

    assert main(
        [
            "--dry-run",
            "--preview-report",
            str(report),
            "--chrome-profile",
            str(chrome),
            "--edge-profile",
            str(edge),
        ]
    ) == 0
    with report.open(newline="", encoding="utf-8") as stream:
        rows = list(csv.DictReader(stream))
        fieldnames = rows[0].keys()
    assert list(fieldnames) == ["mapping", "category", "metric", "value"]
    assert any(row["category"] == "changes" and row["metric"] == "edge_only_urls" for row in rows)
    assert "private-edge.test" not in report.read_text()

    assert main(
        [
            "--dry-run",
            "--preview-report",
            str(report),
            "--include-bookmark-details",
            "--chrome-profile",
            str(chrome),
            "--edge-profile",
            str(edge),
        ]
    ) == 0
    with report.open(newline="", encoding="utf-8") as stream:
        detailed_rows = list(csv.DictReader(stream))
    assert "url" in detailed_rows[0]
    assert any(row["category"] == "bookmark" and row["url"] == "https://private-edge.test/account" for row in detailed_rows)


def test_preview_report_options_reject_unsafe_or_incomplete_requests(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
):
    chrome, edge, _, _, _, _ = preview_report_profiles(tmp_path)
    report = tmp_path / "preview.json"

    assert main(["--preview-report", str(report)]) == 1
    assert "--preview-report requires --dry-run" in capsys.readouterr().err
    assert main(["--include-bookmark-details"]) == 1
    assert "--include-bookmark-details requires --preview-report" in capsys.readouterr().err
    assert main(
        [
            "--dry-run",
            "--preview-report",
            str(tmp_path / "preview.txt"),
            "--chrome-profile",
            str(chrome),
            "--edge-profile",
            str(edge),
        ]
    ) == 1
    assert "must end in .json or .csv" in capsys.readouterr().err
    assert main(
        [
            "--dry-run",
            "--preview-report",
            str(chrome / "preview.json"),
            "--chrome-profile",
            str(chrome),
            "--edge-profile",
            str(edge),
        ]
    ) == 1
    assert "cannot be written inside a selected browser profile" in capsys.readouterr().err


def comparison_entry(
    name: str,
    *,
    final_bookmarks: int = 2,
    planned_additions: int = 2,
    duplicates_removed: int = 0,
    folders_added: int = 0,
    folders_reordered: int = 0,
    merge_strategy: str = "chrome-wins",
    details: bool = False,
) -> dict:
    entry = {
        "mapping": name,
        "settings": {
            "merge_strategy": merge_strategy,
            "duplicate_mode": "conservative",
            "firefox_enabled": False,
        },
        "counts": {
            "chrome_bookmarks": 1,
            "edge_favorites": 1,
            "firefox_bookmarks": 0,
            "final_bookmarks": final_bookmarks,
        },
        "changes": {
            "chrome_only_urls": planned_additions,
            "edge_only_urls": 0,
            "firefox_only_urls": 0,
            "input_duplicates": duplicates_removed,
            "duplicates_removed": duplicates_removed,
            "folders_added": folders_added,
            "folders_reordered": folders_reordered,
        },
    }
    if details:
        entry["bookmarks"] = [
            {
                "name": "Private comparison bookmark",
                "url": "https://private-comparison.test/token=secret",
                "folder_path": "Private folder",
            }
        ]
    return entry


def write_preview_policy(
    path: Path,
    baseline: Path,
    expected_mappings: list[str],
    aggregate_limits: dict[str, int] | None = None,
    mapping_limits: list[dict] | None = None,
) -> Path:
    document = {
        "schema_version": 1,
        "kind": "preview-policy",
        "baseline_sha256": hashlib.sha256(baseline.read_bytes()).hexdigest(),
        "expected_mappings": expected_mappings,
        "aggregate_limits": aggregate_limits or {},
        "mapping_limits": mapping_limits or [],
    }
    path.write_text(json.dumps(document, indent=2))
    return path


def test_preview_report_comparison_matches_json_and_csv_mappings_and_reports_differences(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
):
    older = tmp_path / "older.json"
    newer = tmp_path / "newer.csv"
    sync_module.write_preview_report(
        older,
        [comparison_entry("Personal"), comparison_entry("Removed")],
    )
    sync_module.write_preview_report(
        newer,
        [
            comparison_entry(
                "Personal",
                final_bookmarks=5,
                planned_additions=4,
                duplicates_removed=2,
                folders_added=1,
                folders_reordered=1,
                merge_strategy="merge-folders",
            ),
            comparison_entry("Added"),
        ],
    )

    assert main(["--compare-preview-reports", str(older), str(newer)]) == 0
    output = capsys.readouterr().out

    assert "Removed: missing from newer report" in output
    assert "Added: missing from older report" in output
    assert "settings.merge_strategy: chrome-wins to merge-folders" in output
    assert "counts.final_bookmarks: 2 to 5 (+3)" in output
    assert "changes.duplicates_removed: 0 to 2 (+2)" in output
    assert "changes.folders_reordered: 0 to 1 (+1)" in output
    assert "No browser profiles, backups, or input reports were changed." in output


def test_preview_report_comparison_policy_thresholds_return_exit_code_two(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
):
    older = tmp_path / "older.json"
    newer = tmp_path / "newer.json"
    sync_module.write_preview_report(older, [comparison_entry("Personal")])
    sync_module.write_preview_report(
        newer,
        [
            comparison_entry(
                "Personal",
                planned_additions=5,
                duplicates_removed=2,
                folders_added=2,
                folders_reordered=1,
            )
        ],
    )
    arguments = [
        "--compare-preview-reports",
        str(older),
        str(newer),
        "--max-planned-additions",
        "5",
        "--max-duplicate-removals",
        "2",
        "--max-folder-changes",
        "3",
    ]

    assert main(arguments) == 0
    assert "Policy gate passed." in capsys.readouterr().out
    arguments[-1] = "2"
    assert main(arguments) == 2
    output = capsys.readouterr().out
    assert "Policy gate failed: folder changes 3 exceeds 2." in output


def test_preview_report_comparison_rejects_details_without_explicit_acknowledgment(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
):
    older = tmp_path / "older-private.json"
    newer = tmp_path / "newer-private.csv"
    sync_module.write_preview_report(older, [comparison_entry("Personal", details=True)], True)
    sync_module.write_preview_report(newer, [comparison_entry("Personal", details=True)], True)

    arguments = ["--compare-preview-reports", str(older), str(newer)]
    assert main(arguments) == 1
    error = capsys.readouterr().err
    assert "--acknowledge-private-preview-details" in error
    assert "private-comparison.test" not in error

    assert main([*arguments, "--acknowledge-private-preview-details"]) == 0
    output = capsys.readouterr().out
    assert "private-comparison.test" not in output
    assert "Private comparison bookmark" not in output


@pytest.mark.parametrize(
    "document",
    [
        {
            "schema_version": 2,
            "kind": "preview-report",
            "generated_at": "2026-08-09T00:00:00+00:00",
            "bookmark_details_included": False,
            "mappings": [comparison_entry("Personal")],
        },
        {
            "schema_version": 1,
            "kind": "preview-report",
            "generated_at": "2026-08-09T00:00:00+00:00",
            "bookmark_details_included": False,
            "mappings": [comparison_entry("Personal"), comparison_entry("Personal")],
        },
    ],
)
def test_preview_report_comparison_rejects_unsupported_or_duplicate_json_schema(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
    document: dict,
):
    invalid = tmp_path / "invalid.json"
    valid = tmp_path / "valid.json"
    invalid.write_text(json.dumps(document))
    sync_module.write_preview_report(valid, [comparison_entry("Personal")])

    assert main(["--compare-preview-reports", str(invalid), str(valid)]) == 1
    assert "Error:" in capsys.readouterr().err


def test_preview_report_comparison_reads_only_input_reports(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
):
    directory = tmp_path / "reports"
    older = directory / "older.json"
    newer = directory / "newer.json"
    sync_module.write_preview_report(older, [comparison_entry("Personal")])
    sync_module.write_preview_report(newer, [comparison_entry("Personal", final_bookmarks=3)])
    before = {path.name: path.read_bytes() for path in directory.iterdir()}
    monkeypatch.setattr(
        sync_module,
        "preview_synchronization_data",
        lambda *_args, **_kwargs: pytest.fail("browser profile opened"),
    )
    monkeypatch.setattr(sync_module, "prune_backups", lambda *_args, **_kwargs: pytest.fail("backup changed"))

    assert main(["--compare-preview-reports", str(older), str(newer)]) == 0
    after = {path.name: path.read_bytes() for path in directory.iterdir()}
    assert after == before


def test_preview_policy_enforces_aggregate_and_per_mapping_overrides(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
):
    older = tmp_path / "older.json"
    newer = tmp_path / "newer.csv"
    policy = tmp_path / "preview-policy.private.json"
    sync_module.write_preview_report(
        older,
        [comparison_entry("Personal"), comparison_entry("Work")],
    )
    sync_module.write_preview_report(
        newer,
        [
            comparison_entry("Personal", planned_additions=5, duplicates_removed=1),
            comparison_entry("Work", planned_additions=2, folders_added=1),
        ],
    )
    arguments = ["--compare-preview-reports", str(older), str(newer), "--preview-policy", str(policy)]

    write_preview_policy(
        policy,
        older,
        ["Personal", "Work"],
        {"max_planned_additions": 6, "max_duplicate_removals": 1, "max_folder_changes": 1},
    )
    assert main(arguments) == 2
    assert "planned additions 7 exceeds 6" in capsys.readouterr().out

    write_preview_policy(
        policy,
        older,
        ["Personal", "Work"],
        {"max_planned_additions": 7, "max_duplicate_removals": 1, "max_folder_changes": 1},
        [{"mapping": "Work", "max_planned_additions": 1}],
    )
    assert main(arguments) == 2
    assert "Work planned additions 2 exceeds 1" in capsys.readouterr().out

    write_preview_policy(
        policy,
        older,
        ["Personal", "Work"],
        {"max_planned_additions": 7, "max_duplicate_removals": 1, "max_folder_changes": 1},
        [{"mapping": "Work", "max_planned_additions": 2}],
    )
    assert main(arguments) == 0
    output = capsys.readouterr().out
    assert "Preview policy: preview-policy.private.json; baseline SHA-256 verified." in output
    assert "Policy gate passed." in output


def test_preview_policy_rejects_baseline_hash_mismatch(tmp_path: Path, capsys: pytest.CaptureFixture[str]):
    older = tmp_path / "older.json"
    newer = tmp_path / "newer.json"
    policy = tmp_path / "preview-policy.private.json"
    sync_module.write_preview_report(older, [comparison_entry("Personal")])
    sync_module.write_preview_report(newer, [comparison_entry("Personal")])
    write_preview_policy(policy, older, ["Personal"], {"max_planned_additions": 5})
    document = json.loads(policy.read_text())
    document["baseline_sha256"] = "f" * 64
    policy.write_text(json.dumps(document))

    assert main(["--compare-preview-reports", str(older), str(newer), "--preview-policy", str(policy)]) == 1
    assert "baseline SHA-256 does not match" in capsys.readouterr().err


@pytest.mark.parametrize(
    ("expected", "entries", "message"),
    [
        (["Personal", "Work"], ["Personal"], "mapping(s) missing from older report: Work"),
        (["Personal"], ["Personal", "Work"], "unexpected mapping(s) in older report: Work"),
    ],
)
def test_preview_policy_fails_closed_for_missing_or_unexpected_mappings(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
    expected: list[str],
    entries: list[str],
    message: str,
):
    older = tmp_path / "older.json"
    newer = tmp_path / "newer.json"
    policy = tmp_path / "preview-policy.private.json"
    report_entries = [comparison_entry(name) for name in entries]
    sync_module.write_preview_report(older, report_entries)
    sync_module.write_preview_report(newer, report_entries)
    write_preview_policy(policy, older, expected, {"max_planned_additions": 10})

    assert main(["--compare-preview-reports", str(older), str(newer), "--preview-policy", str(policy)]) == 1
    assert message in capsys.readouterr().err


@pytest.mark.parametrize(
    "change",
    [
        {"schema_version": 2},
        {"baseline_sha256": "not-a-sha256"},
        {"expected_mappings": ["Personal", "Personal"]},
        {"aggregate_limits": {"max_planned_additions": -1}},
        {"mapping_limits": [{"mapping": "Unknown", "max_folder_changes": 1}]},
    ],
)
def test_preview_policy_rejects_malformed_documents(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
    change: dict,
):
    older = tmp_path / "older.json"
    newer = tmp_path / "newer.json"
    policy = tmp_path / "preview-policy.private.json"
    sync_module.write_preview_report(older, [comparison_entry("Personal")])
    sync_module.write_preview_report(newer, [comparison_entry("Personal")])
    write_preview_policy(policy, older, ["Personal"], {"max_planned_additions": 5})
    document = json.loads(policy.read_text())
    document.update(change)
    policy.write_text(json.dumps(document))

    assert main(["--compare-preview-reports", str(older), str(newer), "--preview-policy", str(policy)]) == 1
    assert "Error: Preview policy" in capsys.readouterr().err


def test_preview_policy_comparison_is_private_and_read_only(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
    monkeypatch: pytest.MonkeyPatch,
):
    directory = tmp_path / "private-reports"
    older = directory / "older-private.json"
    newer = directory / "newer-private.json"
    policy = directory / "preview-policy.private.json"
    sync_module.write_preview_report(older, [comparison_entry("Personal", details=True)], True)
    sync_module.write_preview_report(newer, [comparison_entry("Personal", details=True)], True)
    write_preview_policy(policy, older, ["Personal"], {"max_planned_additions": 5})
    before = {path.name: path.read_bytes() for path in directory.iterdir()}
    monkeypatch.setattr(
        sync_module,
        "preview_synchronization_data",
        lambda *_args, **_kwargs: pytest.fail("browser profile opened"),
    )
    monkeypatch.setattr(sync_module, "prune_backups", lambda *_args, **_kwargs: pytest.fail("backup changed"))

    assert main(
        [
            "--compare-preview-reports",
            str(older),
            str(newer),
            "--preview-policy",
            str(policy),
            "--acknowledge-private-preview-details",
        ]
    ) == 0
    output = capsys.readouterr().out
    assert "private-comparison.test" not in output
    assert "Private comparison bookmark" not in output
    assert str(directory) not in output
    assert {path.name: path.read_bytes() for path in directory.iterdir()} == before


def test_preview_policy_example_is_valid_and_private_variants_are_ignored():
    example = Path("preview-policy.example.json")
    policy = sync_module.load_preview_policy(example)
    ignore = Path(".gitignore").read_text()

    assert policy.expected_mappings == ("Personal", "Work")
    assert "preview-policy*.json" in ignore
    assert "!preview-policy.example.json" in ignore
    assert "preview-result*.json" in ignore


def test_preview_policy_cli_rejects_incomplete_or_conflicting_options(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
):
    policy = tmp_path / "preview-policy.private.json"
    assert main(["--preview-policy", str(policy)]) == 1
    assert "require --compare-preview-reports" in capsys.readouterr().err

    older = tmp_path / "older.json"
    newer = tmp_path / "newer.json"
    sync_module.write_preview_report(older, [comparison_entry("Personal")])
    sync_module.write_preview_report(newer, [comparison_entry("Personal")])
    write_preview_policy(policy, older, ["Personal"], {"max_planned_additions": 5})
    assert main(
        [
            "--compare-preview-reports",
            str(older),
            str(newer),
            "--preview-policy",
            str(policy),
            "--max-planned-additions",
            "5",
        ]
    ) == 1
    assert "cannot be combined" in capsys.readouterr().err


def test_preview_result_pass_has_stable_count_only_schema(tmp_path: Path):
    older = tmp_path / "older.json"
    newer = tmp_path / "newer.json"
    policy = tmp_path / "preview-policy.private.json"
    result = tmp_path / "preview-result.private.json"
    sync_module.write_preview_report(
        older,
        [comparison_entry("Personal"), comparison_entry("Work")],
    )
    sync_module.write_preview_report(
        newer,
        [
            comparison_entry("Personal", planned_additions=2, duplicates_removed=1),
            comparison_entry("Work", planned_additions=3, folders_added=1),
        ],
    )
    write_preview_policy(
        policy,
        older,
        ["Personal", "Work"],
        {"max_planned_additions": 5, "max_duplicate_removals": 1, "max_folder_changes": 1},
        [{"mapping": "Work", "max_planned_additions": 3}],
    )

    assert main(
        [
            "--compare-preview-reports",
            str(older),
            str(newer),
            "--preview-policy",
            str(policy),
            "--preview-result",
            str(result),
        ]
    ) == 0
    document = json.loads(result.read_text())

    assert set(document) == {
        "schema_version",
        "kind",
        "generated_at",
        "status",
        "exit_code",
        "input_report_sha256",
        "policy_sha256",
        "expected_mappings",
        "aggregate",
        "mappings",
    }
    assert document["schema_version"] == 1
    assert document["kind"] == "preview-policy-result"
    assert document["status"] == "passed"
    assert document["exit_code"] == 0
    assert document["input_report_sha256"] == {
        "older": hashlib.sha256(older.read_bytes()).hexdigest(),
        "newer": hashlib.sha256(newer.read_bytes()).hexdigest(),
    }
    assert document["policy_sha256"] == hashlib.sha256(policy.read_bytes()).hexdigest()
    assert document["expected_mappings"] == ["Personal", "Work"]
    assert set(document["aggregate"]) == {"counts", "limits", "violations"}
    assert document["aggregate"]["counts"] == {
        "planned_additions": 5,
        "duplicate_removals": 1,
        "folder_changes": 1,
    }
    assert document["aggregate"]["limits"] == {
        "max_planned_additions": 5,
        "max_duplicate_removals": 1,
        "max_folder_changes": 1,
    }
    assert document["aggregate"]["violations"] == []
    assert all(set(item) == {"mapping", "counts", "limits", "violations"} for item in document["mappings"])
    personal, work = document["mappings"]
    assert personal["mapping"] == "Personal"
    assert personal["limits"] == {
        "max_planned_additions": None,
        "max_duplicate_removals": None,
        "max_folder_changes": None,
    }
    assert work["mapping"] == "Work"
    assert work["limits"] == {
        "max_planned_additions": 3,
        "max_duplicate_removals": 1,
        "max_folder_changes": 1,
    }


def test_preview_result_records_threshold_failure_and_atomic_replacement(tmp_path: Path):
    older = tmp_path / "older.json"
    newer = tmp_path / "newer.json"
    result = tmp_path / "preview-result.private.json"
    sync_module.write_preview_report(older, [comparison_entry("Personal")])
    sync_module.write_preview_report(newer, [comparison_entry("Personal", folders_added=2)])
    result.write_text("stale private result")

    assert main(
        [
            "--compare-preview-reports",
            str(older),
            str(newer),
            "--max-folder-changes",
            "1",
            "--preview-result",
            str(result),
        ]
    ) == 2
    document = json.loads(result.read_text())

    assert document["status"] == "failed"
    assert document["exit_code"] == 2
    assert document["policy_sha256"] is None
    assert document["expected_mappings"] == ["Personal"]
    assert document["aggregate"]["violations"] == [
        {"metric": "folder_changes", "actual": 2, "limit": 1}
    ]
    assert not list(tmp_path.glob("*.pending"))


@pytest.mark.parametrize("protected_name", ["older", "newer", "policy"])
def test_preview_result_cannot_replace_inputs_or_policy(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
    protected_name: str,
):
    older = tmp_path / "older.json"
    newer = tmp_path / "newer.json"
    policy = tmp_path / "preview-policy.private.json"
    sync_module.write_preview_report(older, [comparison_entry("Personal")])
    sync_module.write_preview_report(newer, [comparison_entry("Personal")])
    write_preview_policy(policy, older, ["Personal"], {"max_planned_additions": 2})
    before = {path.name: path.read_bytes() for path in (older, newer, policy)}
    protected = {"older": older, "newer": newer, "policy": policy}[protected_name]

    assert main(
        [
            "--compare-preview-reports",
            str(older),
            str(newer),
            "--preview-policy",
            str(policy),
            "--preview-result",
            str(protected),
        ]
    ) == 1
    assert "cannot replace an input report or preview policy" in capsys.readouterr().err
    assert {path.name: path.read_bytes() for path in (older, newer, policy)} == before


def test_preview_result_from_detailed_reports_is_private_and_uses_no_browser_or_backup_access(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
    monkeypatch: pytest.MonkeyPatch,
):
    directory = tmp_path / "private-reports"
    older = directory / "older-private.json"
    newer = directory / "newer-private.json"
    result = directory / "preview-result.private.json"
    sync_module.write_preview_report(older, [comparison_entry("Personal", details=True)], True)
    sync_module.write_preview_report(newer, [comparison_entry("Personal", details=True)], True)
    monkeypatch.setattr(
        sync_module,
        "preview_synchronization_data",
        lambda *_args, **_kwargs: pytest.fail("browser profile opened"),
    )
    monkeypatch.setattr(sync_module, "prune_backups", lambda *_args, **_kwargs: pytest.fail("backup changed"))
    arguments = [
        "--compare-preview-reports",
        str(older),
        str(newer),
        "--preview-result",
        str(result),
    ]

    assert main(arguments) == 1
    assert "--acknowledge-private-preview-details" in capsys.readouterr().err
    assert not result.exists()
    assert main([*arguments, "--acknowledge-private-preview-details"]) == 0
    serialized = result.read_text()

    assert "Private comparison bookmark" not in serialized
    assert "private-comparison.test" not in serialized
    assert "Private folder" not in serialized
    assert str(directory) not in serialized


def test_preview_result_cli_rejects_incomplete_or_non_json_destination(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
):
    result = tmp_path / "preview-result.private.json"
    assert main(["--preview-result", str(result)]) == 1
    assert "require --compare-preview-reports" in capsys.readouterr().err

    older = tmp_path / "older.json"
    newer = tmp_path / "newer.json"
    sync_module.write_preview_report(older, [comparison_entry("Personal")])
    sync_module.write_preview_report(newer, [comparison_entry("Personal")])
    assert main(
        [
            "--compare-preview-reports",
            str(older),
            str(newer),
            "--preview-result",
            str(tmp_path / "preview-result.txt"),
        ]
    ) == 1
    assert "must end in .json" in capsys.readouterr().err


def test_manifest_validates_and_detects_tampering(tmp_path: Path):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    (chrome / "Bookmarks").write_text(json.dumps(data("https://chrome.test")))
    (edge / "Bookmarks").write_text(json.dumps(data("https://edge.test")))

    result = synchronize(chrome, edge, tmp_path / "backups", write=False)
    validate_backup_manifest(result.manifest_path)
    result.html_path.write_text("tampered")

    with pytest.raises(RuntimeError, match="integrity validation failed"):
        validate_backup_manifest(result.manifest_path)

    result.manifest_path.write_text(
        json.dumps({"files": [{"name": "../outside.json", "size": 0, "sha256": "0" * 64}]})
    )
    with pytest.raises(RuntimeError, match="invalid file entry"):
        validate_backup_manifest(result.manifest_path)


def verification_files(tmp_path: Path, document: dict | str) -> tuple[Path, Path]:
    stamp = "2026-08-08_12-00-00_000001"
    backup = tmp_path / f"Chrome_{stamp}.json"
    backup.write_text(document if isinstance(document, str) else json.dumps(document))
    manifest = tmp_path / f"Manifest_{stamp}.json"
    sync_module.write_backup_manifest(manifest, [backup])
    return backup, manifest


def catalog_files(
    directory: Path,
    stamp: str,
    chrome_urls: tuple[str, ...] = ("https://chrome.test",),
    edge_urls: tuple[str, ...] = ("https://edge.test",),
    firefox: Path | None = None,
    safari: Path | None = None,
) -> dict[str, Path]:
    directory.mkdir(parents=True, exist_ok=True)
    files = {
        "Chrome": directory / f"Chrome_{stamp}.json",
        "Edge": directory / f"Edge_{stamp}.json",
        "Bookmarks": directory / f"Bookmarks_{stamp}.html",
    }
    files["Chrome"].write_text(json.dumps(data(*chrome_urls)))
    files["Edge"].write_text(json.dumps(data(*edge_urls)))
    files["Bookmarks"].write_text("<!DOCTYPE NETSCAPE-Bookmark-file-1>")
    if firefox:
        files["Firefox"] = directory / f"Firefox_{stamp}.sqlite"
        shutil.copy2(firefox / "places.sqlite", files["Firefox"])
    if safari:
        files["Safari"] = directory / f"Safari_{stamp}.plist"
        shutil.copy2(safari, files["Safari"])
    files["Manifest"] = sync_module.write_backup_manifest(
        directory / f"Manifest_{stamp}.json",
        [path for name, path in files.items() if name != "Manifest"],
    )
    return files


def test_backup_catalog_groups_complete_sets_and_compares_verified_counts(tmp_path: Path):
    older_stamp = "2026-08-08_12-00-00_000001"
    newer_stamp = "2026-08-08_13-00-00_000001"
    catalog_files(tmp_path, older_stamp)
    firefox = firefox_profile(tmp_path / "firefox-source", "https://firefox.test")
    catalog_files(
        tmp_path,
        newer_stamp,
        chrome_urls=("https://chrome.test", "https://new.test"),
        firefox=firefox,
    )
    before = {path.name: path.read_bytes() for path in tmp_path.iterdir() if path.is_file()}

    catalog = catalog_backup_sets(tmp_path)
    comparison = compare_backup_sets(catalog, older_stamp, newer_stamp)

    assert [item.stamp for item in catalog.sets] == [newer_stamp, older_stamp]
    assert all(item.complete and item.valid for item in catalog.sets)
    assert [(item.browser, item.bookmark_count, item.folder_count) for item in catalog.sets[0].artifacts] == [
        ("Chrome", 2, 2),
        ("Edge", 1, 2),
        ("Firefox", 1, 3),
    ]
    rendered = catalog.render()
    assert "change +1 bookmarks, +0 folders" in rendered
    assert "https://" not in rendered
    assert "Chrome: bookmarks 1 to 2 (+1)" in comparison.render()
    assert before == {path.name: path.read_bytes() for path in tmp_path.iterdir() if path.is_file()}


def test_backup_catalog_flags_missing_and_extra_members(tmp_path: Path):
    missing_stamp = "2026-08-08_12-00-00_000001"
    extra_stamp = "2026-08-08_13-00-00_000001"
    missing = catalog_files(tmp_path, missing_stamp)
    missing["Edge"].unlink()
    catalog_files(tmp_path, extra_stamp)
    firefox = firefox_profile(tmp_path / "extra-firefox", "https://firefox.test")
    shutil.copy2(firefox / "places.sqlite", tmp_path / f"Firefox_{extra_stamp}.sqlite")

    catalog = catalog_backup_sets(tmp_path)
    by_stamp = {item.stamp: item for item in catalog.sets}

    assert by_stamp[missing_stamp].missing_members == ("Edge",)
    assert not by_stamp[missing_stamp].complete
    assert by_stamp[extra_stamp].extra_members == ("Firefox",)
    assert not by_stamp[extra_stamp].complete
    assert catalog.filtered("incomplete") == catalog.sets
    with pytest.raises(RuntimeError, match="complete, valid"):
        compare_backup_sets(catalog, missing_stamp, extra_stamp)


def test_backup_catalog_filters_manifest_mismatch_as_invalid(tmp_path: Path):
    stamp = "2026-08-08_12-00-00_000001"
    files = catalog_files(tmp_path, stamp)
    files["Chrome"].write_text(json.dumps(data("https://tampered.test")))

    catalog = catalog_backup_sets(tmp_path)

    assert catalog.sets[0].complete
    assert not catalog.sets[0].valid
    assert catalog.sets[0].manifest_status == "invalid"
    assert catalog.filtered("invalid") == catalog.sets
    assert catalog.filtered("valid") == ()


def test_backup_catalog_ignores_unrelated_files_and_directories(tmp_path: Path):
    stamp = "2026-08-08_12-00-00_000001"
    catalog_files(tmp_path, stamp)
    (tmp_path / "Chrome_backup.json").write_text("private")
    (tmp_path / "notes.txt").write_text("private")
    (tmp_path / f"Edge_{stamp}.sqlite").write_text("not a generated member")
    (tmp_path / "Manifest_2026-08-08_14-00-00_000001.json").mkdir()

    catalog = catalog_backup_sets(tmp_path)

    assert len(catalog.sets) == 1
    assert catalog.sets[0].complete
    assert catalog.sets[0].valid


def test_cli_backup_catalog_filters_and_compares(tmp_path: Path, capsys: pytest.CaptureFixture[str]):
    older_stamp = "2026-08-08_12-00-00_000001"
    newer_stamp = "2026-08-08_13-00-00_000001"
    catalog_files(tmp_path, older_stamp)
    catalog_files(tmp_path, newer_stamp, chrome_urls=("https://one.test", "https://two.test"))

    assert main(["--catalog-backups", "--catalog-filter", "complete", "--backup-dir", str(tmp_path)]) == 0
    output = capsys.readouterr().out
    assert "Backup catalog: 2 set(s), filter complete" in output
    assert "No live browser files or backup files were changed" in output

    assert main(["--compare-backups", older_stamp, newer_stamp, "--backup-dir", str(tmp_path)]) == 0
    assert "Chrome: bookmarks 1 to 2 (+1)" in capsys.readouterr().out

    assert main(["--catalog-filter", "valid"]) == 1
    assert "--catalog-filter requires --catalog-backups" in capsys.readouterr().err


@pytest.mark.parametrize("macos", [False, True])
def test_recovery_rehearsal_restores_mixed_set_without_live_access(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
    macos: bool,
):
    stamp = "2026-08-10_12-00-00_000001"
    firefox = firefox_profile(tmp_path / "firefox-source", "https://firefox.test")
    safari = write_safari_plist(tmp_path / "safari-source" / "Bookmarks.plist")
    catalog_files(tmp_path / "backups", stamp, firefox=firefox, safari=safari)
    backups = tmp_path / "backups"
    before = {path.name: path.read_bytes() for path in backups.iterdir() if path.is_file()}
    monkeypatch.setattr(sync_module, "is_macos", lambda: macos)

    def unexpected(*_args, **_kwargs):
        raise AssertionError("recovery rehearsal accessed live browser state")

    monkeypatch.setattr(sync_module, "discover_profiles", unexpected)
    monkeypatch.setattr(sync_module, "discover_firefox_profiles", unexpected)
    monkeypatch.setattr(sync_module, "discover_safari_bookmarks", unexpected)
    monkeypatch.setattr(sync_module, "running_browser_processes", unexpected)
    monkeypatch.setattr(sync_module, "running_firefox_processes", unexpected)

    result = sync_module.rehearse_backup_set(backups, stamp)

    assert [(item.browser, item.bookmark_count) for item in result.artifacts] == [
        ("Chrome", 1),
        ("Edge", 1),
        ("Firefox", 1),
        ("Safari", 1),
    ]
    rendered = result.render()
    assert "Recovery rehearsal passed" in rendered
    assert "Manifest: valid" in rendered
    assert "https://" not in rendered
    assert str(tmp_path) not in rendered
    assert before == {path.name: path.read_bytes() for path in backups.iterdir() if path.is_file()}
    assert not list(backups.glob("*.sqlite-wal"))
    assert not list(backups.glob("*.sqlite-shm"))


def test_recovery_rehearsal_reports_incomplete_and_corrupt_stages(tmp_path: Path):
    incomplete_stamp = "2026-08-10_12-00-00_000001"
    incomplete = catalog_files(tmp_path, incomplete_stamp)
    incomplete["Edge"].unlink()

    with pytest.raises(sync_module.RecoveryRehearsalError, match="failed at membership") as error:
        sync_module.rehearse_backup_set(tmp_path, incomplete_stamp)
    assert error.value.stage == "membership"
    assert str(tmp_path) not in str(error.value)

    corrupt_stamp = "2026-08-10_13-00-00_000001"
    corrupt = catalog_files(tmp_path, corrupt_stamp)
    corrupt["Chrome"].write_text("corrupt")

    with pytest.raises(sync_module.RecoveryRehearsalError, match="failed at manifest") as error:
        sync_module.rehearse_backup_set(tmp_path, corrupt_stamp)
    assert error.value.stage == "manifest"
    assert str(tmp_path) not in str(error.value)


def test_recovery_rehearsal_reports_invalid_firefox_content_stage(tmp_path: Path):
    stamp = "2026-08-10_12-00-00_000001"
    firefox = firefox_profile(tmp_path / "firefox-source", "https://firefox.test")
    files = catalog_files(tmp_path / "backups", stamp, firefox=firefox)
    connection = sqlite3.connect(files["Firefox"])
    connection.execute("DROP TABLE moz_keywords")
    connection.commit()
    connection.close()
    sync_module.write_backup_manifest(
        files["Manifest"],
        [path for name, path in files.items() if name != "Manifest"],
    )

    with pytest.raises(sync_module.RecoveryRehearsalError, match="failed at firefox_validation") as error:
        sync_module.rehearse_backup_set(tmp_path / "backups", stamp)
    assert error.value.stage == "firefox_validation"
    assert str(tmp_path) not in str(error.value)


def test_recovery_rehearsal_cli_is_count_only_and_rejects_live_options(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
):
    stamp = "2026-08-10_12-00-00_000001"
    catalog_files(tmp_path, stamp)

    assert main(["--rehearse-recovery", stamp, "--backup-dir", str(tmp_path)]) == 0
    output = capsys.readouterr().out
    assert "Recovery rehearsal passed" in output
    assert "Chrome: 1 bookmarks" in output
    assert "https://" not in output
    assert str(tmp_path) not in output

    assert main(
        [
            "--rehearse-recovery",
            stamp,
            "--backup-dir",
            str(tmp_path),
            "--chrome-profile",
            str(tmp_path / "private-profile"),
        ]
    ) == 1
    error = capsys.readouterr().err
    assert "cannot be combined with browser profiles" in error
    assert str(tmp_path) not in error


def test_recovery_rehearsal_reports_restore_stage_without_private_details(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
):
    stamp = "2026-08-10_12-00-00_000001"
    catalog_files(tmp_path, stamp)

    def fail_restore(*_args, **_kwargs):
        raise RuntimeError(f"private failure in {tmp_path}")

    monkeypatch.setattr(sync_module, "restore_json_backup", fail_restore)

    with pytest.raises(sync_module.RecoveryRehearsalError, match="failed at chrome_restore") as error:
        sync_module.rehearse_backup_set(tmp_path, stamp)
    assert error.value.stage == "chrome_restore"
    assert str(tmp_path) not in str(error.value)


def test_gui_backup_catalog_uses_selected_filter(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    class Value:
        def __init__(self, value: str):
            self.value = value

        def get(self):
            return self.value

        def set(self, value: str):
            self.value = value

    catalog_files(tmp_path, "2026-08-08_12-00-00_000001")
    app = object.__new__(App)
    app.backups = Value(str(tmp_path))
    app.catalog_filter = Value("valid")
    app.status = Value("")
    messages: list[tuple[str, str]] = []
    monkeypatch.setattr(sync_module.messagebox, "showinfo", lambda title, message: messages.append((title, message)))

    App._catalog_backups(app)

    assert app.status.get() == "Cataloged 1 backup set(s) with the valid filter. No files were changed."
    assert messages[0][0] == f"{sync_module.APP_NAME} Backup Catalog"
    assert "filter valid" in messages[0][1]


def test_verify_json_backup_is_non_destructive_and_reports_counts(tmp_path: Path):
    backup, manifest = verification_files(tmp_path, data("https://verified.test"))
    live_profile = tmp_path / "Live" / "Default"
    live_profile.mkdir(parents=True)
    live_file = live_profile / "Bookmarks"
    live_content = json.dumps(data("https://live.test"))
    live_file.write_text(live_content)

    report = verify_json_backup(backup)

    assert report.backup_path == backup
    assert report.manifest_path == manifest
    assert report.bookmark_count == 1
    assert report.folder_count == 2
    assert live_file.read_text() == live_content
    assert "No live browser files were changed" in report.render()


def test_verify_json_backup_rejects_invalid_json(tmp_path: Path):
    backup, _ = verification_files(tmp_path, "{invalid")

    with pytest.raises(RuntimeError, match="not valid JSON"):
        verify_json_backup(backup)


def test_verify_json_backup_rejects_invalid_chromium_schema(tmp_path: Path):
    backup, _ = verification_files(
        tmp_path,
        {"roots": {"bookmark_bar": {"type": "folder", "id": "1", "name": "Bookmarks bar", "children": []}}},
    )

    with pytest.raises(RuntimeError, match="missing required Chromium root"):
        verify_json_backup(backup)


def test_verify_json_backup_rejects_duplicate_guids(tmp_path: Path):
    document = data("https://one.test", "https://two.test")
    for child in document["roots"]["bookmark_bar"]["children"]:
        child["guid"] = "11111111-1111-4111-8111-111111111111"
    backup, _ = verification_files(tmp_path, document)

    with pytest.raises(RuntimeError, match="duplicate GUID values"):
        verify_json_backup(backup)


def test_verify_json_backup_rejects_manifest_mismatch(tmp_path: Path):
    backup, _ = verification_files(tmp_path, data("https://original.test"))
    backup.write_text(json.dumps(data("https://changed.test")))

    with pytest.raises(RuntimeError, match="integrity validation failed"):
        verify_json_backup(backup)


def test_verify_json_backup_checks_selected_file_against_explicit_manifest(tmp_path: Path):
    manifest_dir = tmp_path / "manifest-set"
    manifest_dir.mkdir()
    original, manifest = verification_files(manifest_dir, data("https://original.test"))
    selected_dir = tmp_path / "selected"
    selected_dir.mkdir()
    selected = selected_dir / original.name
    selected.write_text(json.dumps(data("https://different.test")))

    with pytest.raises(RuntimeError, match="integrity validation failed"):
        verify_json_backup(selected, manifest)


def firefox_recovery_files(tmp_path: Path, *urls: str) -> tuple[Path, Path]:
    profile = firefox_profile(tmp_path / "source", *urls)
    backup_dir = tmp_path / "backups"
    backup_dir.mkdir()
    backup = backup_dir / "Firefox_2026-08-09_12-00-00_000000.sqlite"
    sync_module.backup_firefox_database(profile, backup)
    manifest = backup_dir / "Manifest_2026-08-09_12-00-00_000000.json"
    sync_module.write_backup_manifest(manifest, [backup])
    return backup, manifest


def test_verify_firefox_backup_is_isolated_and_count_only(tmp_path: Path):
    backup, manifest = firefox_recovery_files(tmp_path, "https://firefox.test")
    before = {path.name: path.read_bytes() for path in backup.parent.iterdir()}

    report = verify_firefox_backup(backup)

    assert report.manifest_path == manifest
    assert report.bookmark_count == 1
    assert report.folder_count >= 3
    assert {path.name: path.read_bytes() for path in backup.parent.iterdir()} == before
    assert "No live browser files were changed" in report.render()


def test_verify_firefox_backup_rejects_corrupt_mismatched_and_unsupported_snapshots(tmp_path: Path):
    corrupt, corrupt_manifest = firefox_recovery_files(tmp_path / "corrupt", "https://firefox.test")
    corrupt.write_bytes(b"not sqlite")
    with pytest.raises(RuntimeError):
        verify_firefox_backup(corrupt, corrupt_manifest)

    mismatched, mismatched_manifest = firefox_recovery_files(tmp_path / "mismatch", "https://firefox.test")
    with mismatched.open("ab") as stream:
        stream.write(b"changed")
    with pytest.raises(RuntimeError, match="integrity validation failed"):
        verify_firefox_backup(mismatched, mismatched_manifest)

    unsupported, unsupported_manifest = firefox_recovery_files(tmp_path / "unsupported", "https://firefox.test")
    connection = sqlite3.connect(unsupported)
    connection.execute("DROP TABLE moz_keywords")
    connection.commit()
    connection.close()
    sync_module.write_backup_manifest(unsupported_manifest, [unsupported])
    with pytest.raises(RuntimeError, match="unsupported moz_keywords schema"):
        verify_firefox_backup(unsupported, unsupported_manifest)


def test_cli_verify_backup_prints_concise_report(tmp_path: Path, capsys: pytest.CaptureFixture[str]):
    backup, manifest = verification_files(tmp_path, data("https://verified.test"))

    exit_code = main(["--verify-backup", str(backup)])
    captured = capsys.readouterr()

    assert exit_code == 0
    assert captured.err == ""
    assert "Backup verification passed" in captured.out
    assert "Bookmarks: 1" in captured.out
    assert "Folders: 2" in captured.out
    assert "No live browser files were changed" in captured.out

    assert main(["--verify-manifest", str(manifest)]) == 1
    assert "--verify-manifest requires --verify-backup" in capsys.readouterr().err


def test_gui_verify_backup_shows_concise_report(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    class Value:
        def __init__(self, value: str):
            self.value = value

        def get(self):
            return self.value

        def set(self, value: str):
            self.value = value

    backup, _ = verification_files(tmp_path, data("https://verified.test"))
    app = object.__new__(App)
    app.backups = Value(str(tmp_path))
    app.status = Value("")
    messages: list[tuple[str, str]] = []
    monkeypatch.setattr(sync_module.filedialog, "askopenfilename", lambda **_kwargs: str(backup))
    monkeypatch.setattr(sync_module.messagebox, "showinfo", lambda title, message: messages.append((title, message)))

    App._verify_backup(app)

    assert app.status.get() == "Verified 1 bookmarks and 2 folders. No live browser files were changed."
    assert messages == [(f"{sync_module.APP_NAME} Verification", sync_module.verify_json_backup(backup).render())]


def test_gui_verifies_and_restores_firefox_snapshot(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    class Value:
        def __init__(self, value: str):
            self.value = value

        def get(self):
            return self.value

        def set(self, value: str):
            self.value = value

    profile = firefox_profile(tmp_path / "live", "https://current.test")
    backup, _manifest = firefox_recovery_files(tmp_path / "recovery", "https://restored.test")
    app = object.__new__(App)
    app.chrome = Value("")
    app.edge = Value("")
    app.firefox = Value(str(profile))
    app.backups = Value(str(tmp_path / "preserved"))
    app.status = Value("")
    messages: list[tuple[str, str]] = []
    monkeypatch.setattr(sync_module.filedialog, "askopenfilename", lambda **_kwargs: str(backup))
    monkeypatch.setattr(sync_module.messagebox, "askyesno", lambda *_args: True)
    monkeypatch.setattr(sync_module.messagebox, "showinfo", lambda title, message: messages.append((title, message)))

    App._verify_backup(app)
    App._restore(app, "Firefox")

    assert messages[0] == (f"{sync_module.APP_NAME} Verification", verify_firefox_backup(backup).render())
    assert messages[1][0] == sync_module.APP_NAME
    assert "Firefox was restored" in messages[1][1]
    restored_urls = {node["url"] for root in sync_module.read_firefox_bookmarks(profile)["roots"].values() for node in iter_urls(root)}
    assert restored_urls == {"https://restored.test"}


def test_operation_log_does_not_include_bookmark_urls(tmp_path: Path):
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    (chrome / "Bookmarks").write_text(json.dumps(data("https://private.example/token=secret")))
    (edge / "Bookmarks").write_text(json.dumps(data("https://edge.test")))

    result = synchronize(chrome, edge, tmp_path / "backups", write=False, verbose=True)
    log = result.log_path.read_text()

    assert "backup_export_complete" in log
    assert "private.example" not in log
    assert "secret" not in log


def test_profile_mapping_round_trip(tmp_path: Path):
    path = tmp_path / "profile-mappings.json"
    save_profile_mapping(
        path,
        ProfileMapping(
            "Personal",
            Path("C:/Chrome"),
            Path("C:/Edge"),
            Path("D:/Backups"),
            Path("C:/Firefox"),
        ),
    )
    save_profile_mapping(path, ProfileMapping("Work", Path("W:/Chrome"), Path("W:/Edge"), Path("W:/Backups")))

    mappings = load_profile_mappings(path)

    assert sorted(mappings) == ["Personal", "Work"]
    assert mappings["Personal"].backup_dir == Path("D:/Backups")
    assert mappings["Personal"].firefox_profile == Path("C:/Firefox")
    assert mappings["Work"].firefox_profile is None


def test_profile_mapping_rejects_invalid_document_shape(tmp_path: Path):
    path = tmp_path / "profile-mappings.json"
    path.write_text("[]")

    with pytest.raises(RuntimeError, match="must contain a mappings list"):
        load_profile_mappings(path)


def test_restore_json_backup_preserves_current_file(tmp_path: Path):
    profile = tmp_path / "Chrome" / "Default"
    profile.mkdir(parents=True)
    current = data("https://current.test")
    replacement = data("https://restored.test")
    (profile / "Bookmarks").write_text(json.dumps(current))
    backup = tmp_path / "Chrome_backup.json"
    backup.write_text(json.dumps(replacement))

    preserved = restore_json_backup(backup, profile, "Chrome", tmp_path / "recovery")

    assert json.loads((profile / "Bookmarks").read_text()) == replacement
    assert json.loads(preserved.read_text()) == current


def test_restore_rejects_html_backup(tmp_path: Path):
    html_backup = tmp_path / "Bookmarks_backup.html"
    html_backup.write_text("<html></html>")

    with pytest.raises(RuntimeError, match="requires a raw JSON"):
        restore_json_backup(html_backup, tmp_path, "Chrome", tmp_path)


def test_macos_restore_blocks_running_target(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    monkeypatch.setattr(sync_module, "is_macos", lambda: True)
    monkeypatch.setattr(sync_module, "running_browser_processes", lambda: ["Google Chrome"])
    profile = tmp_path / "Default"
    profile.mkdir()
    current = data("https://current.test")
    backup = data("https://backup.test")
    (profile / "Bookmarks").write_text(json.dumps(current))
    backup_path = tmp_path / "Chrome_backup.json"
    backup_path.write_text(json.dumps(backup))

    with pytest.raises(RuntimeError, match="Google Chrome is running"):
        restore_json_backup(backup_path, profile, "Chrome", tmp_path / "Recovery")

    assert json.loads((profile / "Bookmarks").read_text()) == current


def test_restore_firefox_backup_preserves_current_and_removes_sidecars(tmp_path: Path):
    profile = firefox_profile(tmp_path / "live", "https://current.test")
    backup, _manifest = firefox_recovery_files(tmp_path / "recovery", "https://restored.test")
    database = profile / "places.sqlite"
    for sidecar in sync_module.firefox_sidecars(database):
        sidecar.touch()
    snapshot_before = backup.read_bytes()

    preserved = restore_firefox_backup(backup, profile, tmp_path / "preserved")
    assert all(not sidecar.exists() for sidecar in sync_module.firefox_sidecars(database))

    restored_urls = {node["url"] for root in sync_module.read_firefox_bookmarks(profile)["roots"].values() for node in iter_urls(root)}
    preserved_urls = {
        node["url"]
        for root in sync_module.read_firefox_database(preserved)["roots"].values()
        for node in iter_urls(root)
    }
    assert restored_urls == {"https://restored.test"}
    assert preserved_urls == {"https://current.test"}
    assert backup.read_bytes() == snapshot_before
    assert not list(profile.glob("places.pending.*"))
    assert not list(profile.glob("places.rollback.*"))


def test_restore_firefox_blocks_running_process_before_preserving_current(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
):
    profile = firefox_profile(tmp_path / "live", "https://current.test")
    backup, _manifest = firefox_recovery_files(tmp_path / "recovery", "https://restored.test")
    original = (profile / "places.sqlite").read_bytes()
    monkeypatch.setattr(sync_module, "running_firefox_processes", lambda: ["firefox.exe"])

    with pytest.raises(RuntimeError, match="firefox.exe is running"):
        restore_firefox_backup(backup, profile, tmp_path / "preserved")

    assert (profile / "places.sqlite").read_bytes() == original
    assert not (tmp_path / "preserved").exists()


def test_restore_firefox_replacement_failure_keeps_current_database(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
):
    profile = firefox_profile(tmp_path / "live", "https://current.test")
    backup, _manifest = firefox_recovery_files(tmp_path / "recovery", "https://restored.test")
    database = profile / "places.sqlite"
    original = database.read_bytes()
    real_replace = os.replace

    def fail_replacement(source: str | Path, destination: str | Path):
        if Path(destination) == database and Path(source).name.startswith("places.pending."):
            raise OSError("simulated replacement failure")
        return real_replace(source, destination)

    monkeypatch.setattr(sync_module.os, "replace", fail_replacement)

    with pytest.raises(RuntimeError, match="previous database was preserved"):
        restore_firefox_backup(backup, profile, tmp_path / "preserved")

    assert database.read_bytes() == original
    assert len(list((tmp_path / "preserved").glob("Firefox_PreRestore_*.sqlite"))) == 1
    assert not list(profile.glob("places.pending.*"))
    assert not list(profile.glob("places.rollback.*"))


def test_cli_verifies_and_restores_firefox_snapshot(tmp_path: Path, capsys: pytest.CaptureFixture[str]):
    profile = firefox_profile(tmp_path / "live", "https://current.test")
    backup, manifest = firefox_recovery_files(tmp_path / "recovery", "https://restored.test")

    assert main(["--verify-backup", str(backup), "--verify-manifest", str(manifest)]) == 0
    assert "Backup verification passed" in capsys.readouterr().out
    assert main(
        [
            "--restore-backup",
            str(backup),
            "--restore-browser",
            "Firefox",
            "--firefox-profile",
            str(profile),
            "--backup-dir",
            str(tmp_path / "preserved"),
        ]
    ) == 0
    assert "Restored Firefox" in capsys.readouterr().out
    restored_urls = {node["url"] for root in sync_module.read_firefox_bookmarks(profile)["roots"].values() for node in iter_urls(root)}
    assert restored_urls == {"https://restored.test"}


def test_task_scheduler_script_defaults_to_backup_only(tmp_path: Path):
    destination = tmp_path / "register-task.ps1"
    write_task_scheduler_script(
        destination,
        Path("C:/Chrome Profile"),
        Path("C:/Edge Profile"),
        Path("D:/Backups"),
        "Bookmark Backup",
        "03:30",
    )
    script = destination.read_text()

    assert "Register-ScheduledTask" in script
    assert "--sync" not in script
    assert "03:30" in script


def test_task_scheduler_sync_requires_explicit_opt_in(tmp_path: Path):
    destination = tmp_path / "register-sync-task.ps1"
    write_task_scheduler_script(
        destination,
        Path("C:/Chrome"),
        Path("C:/Edge"),
        Path("D:/Backups"),
        "Bookmark Sync",
        "04:00",
        synchronize_task=True,
    )

    assert "--sync" in destination.read_text()


def test_task_scheduler_uses_standalone_executable_when_frozen(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    destination = tmp_path / "standalone-task.ps1"
    monkeypatch.setattr(sync_module.sys, "frozen", True, raising=False)
    monkeypatch.setattr(sync_module.sys, "executable", "C:/Tools/BrowserBookmarkTool.exe")

    write_task_scheduler_script(
        destination,
        Path("C:/Chrome"),
        Path("C:/Edge"),
        Path("D:/Backups"),
        "Bookmark Backup",
        "02:00",
    )
    script = destination.read_text()

    assert "C:/Tools/BrowserBookmarkTool.exe" in script
    assert "browser_bookmark_sync" not in script


def test_task_scheduler_rejects_invalid_time(tmp_path: Path):
    with pytest.raises(RuntimeError, match="24-hour HH:MM"):
        write_task_scheduler_script(
            tmp_path / "task.ps1",
            Path("C:/Chrome"),
            Path("C:/Edge"),
            Path("D:/Backups"),
            "Bookmark Backup",
            "25:99",
        )


def test_launchd_plist_defaults_to_backup_only(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    monkeypatch.setattr(sync_module.sys, "executable", "/usr/local/bin/python3")
    destination = tmp_path / "com.browser-bookmark-tool.backup.plist"

    write_launchd_plist(
        destination,
        Path("/Users/test/Library/Application Support/Google/Chrome/Default"),
        Path("/Users/test/Library/Application Support/Microsoft Edge/Default"),
        Path("/Users/test/Documents/Browser Bookmark Backups"),
        "Bookmark Backup",
        "03:30",
    )

    with destination.open("rb") as stream:
        document = plistlib.load(stream)
    assert document["Label"] == "com.browser-bookmark-tool.bookmark-backup"
    assert document["StartCalendarInterval"] == {"Hour": 3, "Minute": 30}
    assert document["ProgramArguments"][:3] == [
        str(Path("/usr/local/bin/python3").resolve()),
        "-m",
        "browser_bookmark_sync",
    ]
    assert "--sync" not in document["ProgramArguments"]


def test_launchd_plist_supports_opt_in_firefox_sync(tmp_path: Path):
    destination = tmp_path / "bookmark-sync.plist"
    write_launchd_plist(
        destination,
        Path("/Chrome"),
        Path("/Edge"),
        Path("/Backups"),
        "Bookmark Sync",
        "04:00",
        synchronize_task=True,
        firefox_profile=Path("/Firefox"),
        firefox_export=True,
    )

    with destination.open("rb") as stream:
        arguments = plistlib.load(stream)["ProgramArguments"]
    assert "--sync" in arguments
    assert "--firefox-profile" in arguments
    assert "--firefox-export" in arguments


def test_cli_dry_run_processes_multiple_named_mappings(tmp_path: Path, capsys: pytest.CaptureFixture[str]):
    mapping_file = tmp_path / "profile-mappings.json"
    report_file = tmp_path / "browser-bookmark-preview.json"
    for name in ("Personal", "Work"):
        chrome = tmp_path / name / "Chrome"
        edge = tmp_path / name / "Edge"
        chrome.mkdir(parents=True)
        edge.mkdir(parents=True)
        (chrome / "Bookmarks").write_text(json.dumps(data(f"https://{name.casefold()}-chrome.test")))
        (edge / "Bookmarks").write_text(json.dumps(data(f"https://{name.casefold()}-edge.test")))
        save_profile_mapping(mapping_file, ProfileMapping(name, chrome, edge, tmp_path / name / "Backups"))

    exit_code = main(
        [
            "--dry-run",
            "--profile-map",
            str(mapping_file),
            "--preview-report",
            str(report_file),
        ]
    )
    output = capsys.readouterr().out
    report = json.loads(report_file.read_text())

    assert exit_code == 0
    assert "[Personal]" in output
    assert "[Work]" in output
    assert output.count("Final bookmark count: 2") == 2
    assert [item["mapping"] for item in report["mappings"]] == ["Personal", "Work"]


def automation_files(
    tmp_path: Path,
    operation: str = "backup",
    browser_behavior: str = "block",
) -> tuple[Path, Path, Path, Path, Path]:
    chrome = tmp_path / "Chrome" / "Default"
    edge = tmp_path / "Edge" / "Default"
    chrome.mkdir(parents=True)
    edge.mkdir(parents=True)
    (chrome / "Bookmarks").write_text(json.dumps(data("https://chrome.private.test")))
    (edge / "Bookmarks").write_text(json.dumps(data("https://edge.private.test")))
    backup_dir = tmp_path / "Backups"
    mapping_file = tmp_path / "profile-mappings.private.json"
    save_profile_mapping(mapping_file, ProfileMapping("Personal", chrome, edge, backup_dir))
    result_file = tmp_path / "automation-result.json"
    lock_file = tmp_path / "automation.lock"
    config_file = tmp_path / "automation-config.private.json"
    config_file.write_text(
        json.dumps(
            {
                "schema_version": 1,
                "operation": operation,
                "profile_map": mapping_file.name,
                "mappings": ["Personal"],
                "keep": 50,
                "deduplicate": False,
                "alphabetize": False,
                "duplicate_mode": "conservative",
                "merge_strategy": "chrome-wins",
                "browser_behavior": browser_behavior,
                "result_file": result_file.name,
                "lock_file": lock_file.name,
                "lock_timeout_minutes": 5,
            }
        )
    )
    return config_file, chrome, edge, backup_dir, result_file


def test_load_automation_config_resolves_private_relative_paths(tmp_path: Path):
    config_file, _, _, _, result_file = automation_files(tmp_path)

    config = load_automation_config(config_file)

    assert config.operation == "backup"
    assert config.profile_map == tmp_path / "profile-mappings.private.json"
    assert config.result_file == result_file
    assert config.lock_file == tmp_path / "automation.lock"
    assert config.mappings == ("Personal",)
    assert config.health_file == tmp_path / "browser-bookmark-automation-health.json"
    assert config.health_history_limit == 100
    assert not config.firefox_enabled
    assert not config.firefox_export
    assert not config.notifications_enabled
    assert config.notification_command == ()


def test_automation_requires_absolute_profile_mapping_paths(tmp_path: Path):
    config_file, _, _, _, _ = automation_files(tmp_path)
    mapping_file = tmp_path / "profile-mappings.private.json"
    mapping_file.write_text(
        json.dumps(
            {
                "mappings": [
                    {
                        "name": "Personal",
                        "chrome_profile": "relative/chrome",
                        "edge_profile": "relative/edge",
                        "backup_dir": "relative/backups",
                    }
                ]
            }
        )
    )

    with pytest.raises(RuntimeError, match="absolute"):
        sync_module.selected_automation_mappings(load_automation_config(config_file))


@pytest.mark.parametrize(
    ("field", "value", "message"),
    [
        ("schema_version", 2, "schema_version"),
        ("operation", "delete", "operation"),
        ("keep", 51, "keep"),
        ("mappings", ["Personal", "Personal"], "unique"),
        ("duplicate_mode", "unsafe", "duplicate_mode"),
        ("merge_strategy", "replace", "merge_strategy"),
        ("lock_timeout_minutes", 1, "lock_timeout_minutes"),
    ],
)
def test_automation_config_rejects_invalid_values(tmp_path: Path, field: str, value: object, message: str):
    config_file, _, _, _, _ = automation_files(tmp_path)
    document = json.loads(config_file.read_text())
    document[field] = value
    config_file.write_text(json.dumps(document))

    with pytest.raises(RuntimeError, match=message):
        load_automation_config(config_file)


def test_automation_config_allows_close_only_for_sync(tmp_path: Path):
    config_file, _, _, _, _ = automation_files(tmp_path, browser_behavior="close")

    with pytest.raises(RuntimeError, match="only when operation is sync"):
        load_automation_config(config_file)

    document = json.loads(config_file.read_text())
    document["operation"] = "sync"
    config_file.write_text(json.dumps(document))
    assert load_automation_config(config_file).browser_behavior == "close"


def test_automation_lock_blocks_concurrent_runs_and_cleans_up(tmp_path: Path):
    lock_file = tmp_path / "automation.lock"

    with AutomationRunLock(lock_file, 5):
        assert lock_file.exists()
        with pytest.raises(RuntimeError, match="already active"):
            with AutomationRunLock(lock_file, 5):
                pass

    assert not lock_file.exists()


def test_automation_lock_replaces_stale_lock(tmp_path: Path):
    lock_file = tmp_path / "automation.lock"
    lock_file.write_text("stale")
    old = sync_module.time.time() - 600
    os.utime(lock_file, (old, old))

    with AutomationRunLock(lock_file, 5):
        assert json.loads(lock_file.read_text())["pid"] == os.getpid()

    assert not lock_file.exists()


def test_automation_readiness_reports_process_warning_without_private_paths(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
):
    config_file, chrome, _, _, _ = automation_files(tmp_path, operation="sync")
    monkeypatch.setattr(sync_module, "running_browser_processes", lambda: ["chrome.exe"])

    document = automation_readiness(load_automation_config(config_file))
    serialized = json.dumps(document)

    assert document["status"] == "ready"
    assert document["detected_processes"] == ["chrome.exe"]
    assert "block synchronization" in document["warnings"][0]
    assert str(chrome) not in serialized


def test_run_backup_automation_writes_privacy_safe_result(tmp_path: Path):
    config_file, chrome, edge, backup_dir, result_file = automation_files(tmp_path)
    chrome_before = (chrome / "Bookmarks").read_text()
    edge_before = (edge / "Bookmarks").read_text()

    exit_code, document = run_automation(load_automation_config(config_file))
    written = json.loads(result_file.read_text())
    serialized = json.dumps(written)

    assert exit_code == 0
    assert document == written
    assert written["status"] == "success"
    assert written["mappings"][0]["backup_created"]
    assert not written["mappings"][0]["synchronized"]
    assert (chrome / "Bookmarks").read_text() == chrome_before
    assert (edge / "Bookmarks").read_text() == edge_before
    assert len(list(backup_dir.glob("Chrome_*.json"))) == 1
    assert "https://" not in serialized
    assert str(chrome) not in serialized
    health = json.loads((tmp_path / "browser-bookmark-automation-health.json").read_text())
    health_serialized = json.dumps(health)
    record = health["records"][-1]
    assert record["status"] == "success"
    assert record["operation"] == "backup"
    assert record["mappings"] == ["Personal"]
    assert record["counts"]["mapping_succeeded"] == 1
    assert record["error_category"] == "none"
    assert set(record) == {
        "operation",
        "status",
        "mappings",
        "counts",
        "duration_seconds",
        "processes",
        "error_category",
    }
    assert "https://" not in health_serialized
    assert str(chrome) not in health_serialized
    assert str(edge) not in health_serialized
    assert str(backup_dir) not in health_serialized


def test_run_dry_run_automation_creates_no_backups(tmp_path: Path):
    config_file, _, _, backup_dir, result_file = automation_files(tmp_path, operation="dry-run")

    exit_code, document = run_automation(load_automation_config(config_file))

    assert exit_code == 0
    assert document["mappings"][0]["merged_count"] == 2
    assert not backup_dir.exists()
    assert result_file.exists()


def test_run_sync_automation_blocks_browsers_after_backup(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
):
    config_file, _, _, backup_dir, result_file = automation_files(tmp_path, operation="sync")
    monkeypatch.setattr(sync_module, "running_browser_processes", lambda: ["chrome.exe"])

    exit_code, document = run_automation(load_automation_config(config_file))

    assert exit_code == 1
    assert document["status"] == "failed"
    assert document["mappings"][0]["backup_created"]
    assert not document["mappings"][0]["synchronized"]
    assert "chrome.exe" in document["error"]
    assert len(list(backup_dir.glob("Chrome_*.json"))) == 1
    assert json.loads(result_file.read_text()) == document
    record = json.loads((tmp_path / "browser-bookmark-automation-health.json").read_text())["records"][-1]
    assert record["status"] == "blocked"
    assert record["processes"] == ["chrome.exe"]
    assert record["error_category"] == "browser_running"
    assert record["counts"]["backups_created"] == 1


def test_run_automation_records_stale_lock_recovery(tmp_path: Path):
    config_file, _, _, _, _ = automation_files(tmp_path)
    config = load_automation_config(config_file)
    config.lock_file.write_text("stale")
    old = sync_module.time.time() - 600
    os.utime(config.lock_file, (old, old))

    exit_code, _ = run_automation(config)

    record = json.loads(config.health_file.read_text())["records"][-1]
    assert exit_code == 0
    assert record["status"] == "success"
    assert record["counts"]["stale_locks_replaced"] == 1
    assert record["error_category"] == "none"


def test_repeated_failures_are_suppressed_until_recovery(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
):
    config_file, _, _, _, _ = automation_files(tmp_path, operation="sync")
    config_document = json.loads(config_file.read_text())
    config_document["notifications_enabled"] = True
    config_document["notification_command"] = ["local-notifier"]
    config_file.write_text(json.dumps(config_document))
    detections = iter([["chrome.exe"], ["chrome.exe"], [], ["chrome.exe"]])
    monkeypatch.setattr(sync_module, "running_browser_processes", lambda: next(detections))
    notifications: list[dict[str, object]] = []
    monkeypatch.setattr(
        sync_module,
        "deliver_failure_notification",
        lambda _command, record: notifications.append(record) or True,
    )
    config = load_automation_config(config_file)

    assert run_automation(config)[0] == 1
    assert run_automation(config)[0] == 1
    assert len(notifications) == 1
    assert run_automation(config)[0] == 0
    assert run_automation(config)[0] == 1

    assert len(notifications) == 2
    assert notifications[0]["error_category"] == "browser_running"
    statuses = [record["status"] for record in json.loads(config.health_file.read_text())["records"]]
    assert statuses == ["blocked", "blocked", "success", "blocked"]


def test_notification_payload_redacts_private_failure_details(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
):
    config_file, chrome, _, backup_dir, _ = automation_files(tmp_path, operation="sync")
    config_document = json.loads(config_file.read_text())
    config_document["notifications_enabled"] = True
    config_document["notification_command"] = ["local-notifier", "credential-value"]
    config_file.write_text(json.dumps(config_document))
    private_url = "https://secret.example.test/private"
    private_title = "Confidential bookmark title"
    (chrome / "Bookmarks").write_text(json.dumps(data(private_url, private_title)))
    private_failure = f"write failed for {chrome} into {backup_dir}: {private_url} credential-value"
    monkeypatch.setattr(
        sync_module,
        "synchronize",
        lambda *_args, **_kwargs: (_ for _ in ()).throw(RuntimeError(private_failure)),
    )
    notifications: list[dict[str, object]] = []
    monkeypatch.setattr(
        sync_module,
        "deliver_failure_notification",
        lambda _command, record: notifications.append(record) or True,
    )

    exit_code, _ = run_automation(load_automation_config(config_file))

    config = load_automation_config(config_file)
    serialized = json.dumps(notifications[0])
    health_serialized = config.health_file.read_text()
    assert exit_code == 1
    assert private_url not in serialized
    assert private_title not in serialized
    assert str(chrome) not in serialized
    assert str(backup_dir) not in serialized
    assert "credential-value" not in serialized
    assert "notification_command" not in serialized
    assert notifications[0]["error_category"] == "automation"
    assert private_url not in health_serialized
    assert private_title not in health_serialized
    assert str(chrome) not in health_serialized
    assert str(backup_dir) not in health_serialized
    assert "credential-value" not in health_serialized


def test_run_sync_automation_reports_backups_after_transaction_failure(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
):
    config_file, _, _, _, _ = automation_files(tmp_path, operation="sync")

    def fail_write(*_args: object) -> None:
        raise RuntimeError("simulated write failure")

    monkeypatch.setattr(sync_module, "transactional_json_write", fail_write)

    exit_code, document = run_automation(load_automation_config(config_file))

    result = document["mappings"][0]
    assert exit_code == 1
    assert result["backup_created"]
    assert result["html_created"]
    assert result["manifest_validated"]
    assert not result["synchronized"]


def test_run_sync_automation_can_explicitly_close_browsers(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
):
    config_file, chrome, edge, _, _ = automation_files(tmp_path, operation="sync", browser_behavior="close")
    process_checks = iter([["chrome.exe", "msedge.exe"], []])
    closed: list[str] = []
    monkeypatch.setattr(sync_module, "running_browser_processes", lambda: next(process_checks, []))
    monkeypatch.setattr(sync_module, "close_browser_processes", lambda processes: closed.extend(processes))

    exit_code, document = run_automation(load_automation_config(config_file))

    assert exit_code == 0
    assert closed == ["chrome.exe", "msedge.exe"]
    assert document["mappings"][0]["synchronized"]
    assert document["mappings"][0]["browsers_closed"] == ["chrome.exe", "msedge.exe"]
    assert json.loads((chrome / "Bookmarks").read_text()) == json.loads((edge / "Bookmarks").read_text())


def test_cli_checks_and_runs_automation_config(tmp_path: Path, capsys: pytest.CaptureFixture[str]):
    config_file, _, _, _, result_file = automation_files(tmp_path)

    assert main(["--check-automation", str(config_file)]) == 0
    readiness = json.loads(capsys.readouterr().out)
    assert readiness["status"] == "ready"

    assert main(["--run-automation", str(config_file)]) == 0
    result = json.loads(capsys.readouterr().out)
    assert result["status"] == "success"
    assert result_file.exists()


def test_cli_concurrent_automation_does_not_replace_active_result(
    tmp_path: Path,
    capsys: pytest.CaptureFixture[str],
):
    config_file, _, _, _, result_file = automation_files(tmp_path)
    result_file.write_text(json.dumps({"active_run": True}))
    config = load_automation_config(config_file)

    with AutomationRunLock(config.lock_file, config.lock_timeout_minutes):
        exit_code = main(["--run-automation", str(config_file)])

    output = json.loads(capsys.readouterr().out)
    assert exit_code == 1
    assert output["status"] == "failed"
    assert "already active" in output["error"]
    assert json.loads(result_file.read_text()) == {"active_run": True}


def test_cli_automation_rejects_process_overrides(tmp_path: Path, capsys: pytest.CaptureFixture[str]):
    config_file, _, _, _, result_file = automation_files(tmp_path)

    exit_code = main(["--run-automation", str(config_file), "--force"])

    output = json.loads(capsys.readouterr().out)
    assert exit_code == 1
    assert "private configuration" in output["error"]
    assert not result_file.exists()


def test_powershell_automation_wrapper_runs_readiness_check(tmp_path: Path):
    powershell = shutil.which("pwsh") or shutil.which("powershell")
    if not powershell:
        pytest.skip("PowerShell is unavailable")
    config_file, _, _, _, _ = automation_files(tmp_path)
    script = Path(__file__).with_name("Invoke-BrowserBookmarkAutomation.ps1")

    completed = subprocess.run(
        [powershell, "-NoProfile", "-File", script, "-ConfigPath", config_file, "-Mode", "Check"],
        capture_output=True,
        text=True,
        check=False,
    )

    assert completed.returncode == 0, completed.stderr
    assert json.loads(completed.stdout)["status"] == "ready"

    completed = subprocess.run(
        [powershell, "-NoProfile", "-File", script, "-ConfigPath", config_file, "-Mode", "Run"],
        capture_output=True,
        text=True,
        check=False,
    )

    assert completed.returncode == 0, completed.stderr
    assert json.loads(completed.stdout)["status"] == "success"
    assert (tmp_path / "automation-result.json").exists()


def test_safari_discovers_only_the_standard_macos_bookmark_file(tmp_path: Path):
    expected = write_safari_plist(tmp_path / "Library" / "Safari" / "Bookmarks.plist")
    assert safari_adapter.discover_safari_bookmarks(tmp_path, "darwin") == expected
    with pytest.raises(RuntimeError, match="only on macOS"):
        safari_adapter.discover_safari_bookmarks(tmp_path, "win32")


def test_safari_parser_preserves_nested_bookmarks_and_excludes_reading_list(tmp_path: Path):
    model = safari_adapter.read_safari_bookmarks(write_safari_plist(tmp_path / "Bookmarks.plist"))
    urls = [node["url"] for root in model["roots"].values() for node in iter_urls(root)]
    assert urls == ["https://safari.test/path"]
    assert model["roots"]["bookmark_bar"]["children"][0]["name"] == "Nested"


@pytest.mark.parametrize(
    ("document", "message"),
    [
        ({"WebBookmarkFileVersion": 99, "Children": []}, "version 99"),
        ({"WebBookmarkFileVersion": 1, "Children": "bad"}, "root structure"),
        ({"WebBookmarkFileVersion": 1, "Children": [{"WebBookmarkType": "Unknown"}]}, "unsupported node type"),
    ],
)
def test_safari_parser_fails_safely_for_unsupported_or_malformed_data(tmp_path: Path, document: dict, message: str):
    path = write_safari_plist(tmp_path / "Bookmarks.plist", document)
    with pytest.raises(RuntimeError, match=message):
        safari_adapter.read_safari_bookmarks(path)


def test_safari_backup_is_manifested_verified_and_live_file_unchanged(tmp_path: Path):
    source = write_safari_plist(tmp_path / "live" / "Bookmarks.plist")
    before = source.read_bytes()
    destination = tmp_path / "Safari_2026-08-09_12-00-00_000001.plist"
    safari_adapter.backup_safari_bookmarks(source, destination)
    manifest = sync_module.write_backup_manifest(tmp_path / "Manifest_2026-08-09_12-00-00_000001.json", [destination])
    report = sync_module.verify_backup(destination, manifest)
    assert (report.backup_path, report.bookmark_count) == (destination, 1)
    assert source.read_bytes() == before
    destination.write_bytes(b"tampered")
    with pytest.raises(RuntimeError, match="integrity validation failed"):
        sync_module.verify_backup(destination, manifest)


def test_safari_merge_duplicate_organization_and_html_export(tmp_path: Path):
    safari = safari_adapter.read_safari_bookmarks(write_safari_plist(tmp_path / "Bookmarks.plist"))
    merged, preview = prepare_merged_data(data("https://safari.test/path"), data("https://edge.test"), deduplicate=True, alphabetize=True, safari=safari)
    html_path = tmp_path / "portable.html"
    assert (preview.safari_count, preview.safari_only, preview.merged_count) == (1, 0, 2)
    assert export_html(merged, html_path) == 2
    assert "https://safari.test/path" in html_path.read_text()


def test_safari_full_backup_export_has_manifest_and_private_log(tmp_path: Path):
    chrome = tmp_path / "Chrome"
    edge = tmp_path / "Edge"
    chrome.mkdir()
    edge.mkdir()
    (chrome / "Bookmarks").write_text(json.dumps(data("https://chrome.test")))
    (edge / "Bookmarks").write_text(json.dumps(data("https://edge.test")))
    safari = write_safari_plist(tmp_path / "live" / "Bookmarks.plist")
    before = safari.read_bytes()
    result = synchronize(chrome, edge, tmp_path / "backups", write=False, safari_bookmarks=safari)
    sync_module.validate_backup_manifest(result.manifest_path)
    manifest = json.loads(result.manifest_path.read_text())
    assert any(item["name"].startswith("Safari_") for item in manifest["files"])
    catalog = catalog_backup_sets(result.backup_dir)
    assert catalog.sets[0].valid
    assert any(artifact.browser == "Safari" for artifact in catalog.sets[0].artifacts)
    log = result.log_path.read_text()
    assert "https://safari.test" not in log
    assert "Private Safari title" not in log
    assert str(safari) not in log
    assert safari.read_bytes() == before


def test_safari_cli_preview_is_macos_only_and_warns_about_icloud(tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]):
    chrome = tmp_path / "Chrome"
    edge = tmp_path / "Edge"
    chrome.mkdir()
    edge.mkdir()
    (chrome / "Bookmarks").write_text(json.dumps(data("https://chrome.test")))
    (edge / "Bookmarks").write_text(json.dumps(data("https://edge.test")))
    safari = write_safari_plist(tmp_path / "Bookmarks.plist")
    args = ["--chrome-profile", str(chrome), "--edge-profile", str(edge), "--safari-bookmarks", str(safari), "--dry-run"]
    assert main(args) == 1
    assert "only on macOS" in capsys.readouterr().err
    monkeypatch.setattr(sync_module, "is_macos", lambda: True)
    assert main(args) == 0
    output = capsys.readouterr().out
    assert "Safari bookmarks: 1" in output
    assert "iCloud" in output
    assert "https://safari.test" not in output


def test_safari_gui_discovers_read_only_source_without_enabling_it(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    safari = write_safari_plist(tmp_path / "Bookmarks.plist")
    monkeypatch.setattr(sync_module, "discover_profiles", lambda _browser: [])
    monkeypatch.setattr(sync_module, "discover_firefox_profiles", lambda: [])
    monkeypatch.setattr(sync_module, "discover_safari_bookmarks", lambda: safari)
    monkeypatch.setattr(sync_module, "is_macos", lambda: True)
    root = sync_module.tk.Tk()
    root.withdraw()
    try:
        app = App(root)
        assert app.safari.get() == str(safari)
        assert app.safari_enabled.get() is False
    finally:
        root.destroy()


def test_cli_prepares_user_controlled_safari_import_without_writing_safari(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
):
    chrome = tmp_path / "Chrome"
    edge = tmp_path / "Edge"
    chrome.mkdir()
    edge.mkdir()
    (chrome / "Bookmarks").write_text(json.dumps(data("https://chrome.test")))
    (edge / "Bookmarks").write_text(json.dumps(data("https://edge.test")))
    safari = write_safari_plist(tmp_path / "live" / "Bookmarks.plist")
    before = safari.read_bytes()
    monkeypatch.setattr(sync_module, "is_macos", lambda: True)

    assert main(
        [
            "--prepare-safari-import",
            "--chrome-profile",
            str(chrome),
            "--edge-profile",
            str(edge),
            "--safari-bookmarks",
            str(safari),
            "--backup-dir",
            str(tmp_path / "backups"),
        ]
    ) == 0

    output = capsys.readouterr().out
    assert "Safari was not changed" in output
    assert "File > Import From > Bookmarks HTML File" in output
    assert "iCloud" in output
    assert safari.read_bytes() == before


def test_gui_guided_safari_import_rejects_unsupported_platform(monkeypatch: pytest.MonkeyPatch):
    app = object.__new__(App)
    errors: list[tuple[str, str]] = []
    monkeypatch.setattr(sync_module, "is_macos", lambda: False)
    monkeypatch.setattr(sync_module.messagebox, "showerror", lambda title, message: errors.append((title, message)))

    assert App._run(app, False, True) is None
    assert errors == [(sync_module.APP_NAME, "Guided Safari import is available only on macOS.")]