#include "sync.h"
#include "json.hpp"
#include <iostream>
using namespace ks;
using Json = nlohmann::json;
namespace
{
int checks{};
void require(bool condition, const char *message)
{
    if (!condition) throw std::runtime_error(message);
    ++checks;
}
template<class F> void rejects(F f, const char *message)
{
    bool rejected = false;
    try { f(); } catch (const std::exception &) { rejected = true; }
    require(rejected, message);
}
Bytes bytes(const Json &j) { auto s = j.dump(); return {s.begin(), s.end()}; }
Json parse(const Bytes &b) { return Json::parse(b.begin(), b.end()); }
struct FakeProvider : SyncProvider
{
    SyncDocument remote;
    int writes{};
    bool race{};
    SyncDocument read() override { return remote; }
    uint64_t write(const Bytes &b, uint64_t expected) override
    {
        if (race) ++remote.revision;
        if (expected != remote.revision) throw std::runtime_error("CAS conflict");
        ++writes; remote = {remote.revision + 1, b}; return remote.revision;
    }
};
}
int main()
{
    auto root = std::filesystem::temp_directory_path() / (L"ks-sync-test-" + std::to_wstring(GetCurrentProcessId()));
    try
    {
        std::filesystem::create_directories(root);
        require(!syncVisible(root), "hidden without opt-in file");
        require(!loadSyncConfig(root).enabled, "disabled by default");
        SyncConfig config; config.server = L"https://bao.example.com"; config.username = L"person"; config.enabled = true;
        validateSyncConfig(config);
        for (const auto *server : {L"http://bao.example.com", L"https://user:pass@bao.example.com", L"https://bao.example.com/x", L"https://bao.example.com?x=1"})
        {
            auto invalid = config; invalid.server = server;
            rejects([&] { validateSyncConfig(invalid); }, "reject unsafe endpoint");
        }
        auto invalid = config; invalid.path = L"../other";
        rejects([&] { validateSyncConfig(invalid); }, "reject traversal");
        invalid = config; invalid.provider = L"unknown";
        rejects([&] { validateSyncConfig(invalid); }, "reject unsupported provider");
        saveSyncConfig(root, config);
        require(syncVisible(root) && loadSyncConfig(root) == config, "connection round trip");
        auto partialConfig = config; partialConfig.keepLocalLayouts = true;
        saveSyncConfig(root, partialConfig);
        require(loadSyncConfig(root).keepLocalLayouts, "partial sync mode survives restart");
        saveSyncConfig(root, config);
        auto rawConfig = parse(readFile(root / L"sync.json", 16384));
        require(!rawConfig.contains("password") && !rawConfig.contains("token"), "no secrets in config");
        Settings local;
        local.autostart = true; local.elevatedAutostart = true; local.tesseractPath = L"C:\\private\\tesseract.exe";
        local.history = false;
        local.snippets.push_back({L"test", L"private snippet"});
        auto base = sharedSyncSettings(local);
        Settings ordered = local, reordered = local;
        ordered.directIds = {L"00000409", L"00000422"}; ordered.direct = {L"Ctrl+1", L"Ctrl+2"};
        reordered.directIds = {L"00000422", L"00000409"}; reordered.direct = {L"Ctrl+2", L"Ctrl+1"};
        require(sharedSyncSettings(ordered) == sharedSyncSettings(reordered), "layout enumeration does not cause sync churn");
        auto j = parse(base);
        require(!j.contains("startWithSystem") && !j.contains("tesseractPath") && !j.contains("historyEnabled"), "local-only fields excluded");
        auto restored = restoreSyncSettings(base, local, {});
        require(restored.autostart && restored.elevatedAutostart && !restored.history && restored.tesseractPath == local.tesseractPath, "preserve device settings");
        auto hostile = j; hostile["startWithSystem"] = false;
        rejects([&] { restoreSyncSettings(bytes(hostile), local, {}); }, "reject injected device setting");
        hostile = j; hostile["schemaVersion"] = 2;
        rejects([&] { restoreSyncSettings(bytes(hostile), local, {}); }, "reject future schema");
        hostile = j; hostile["layouts"] = Json::array({"00000422"});
        rejects([&] { restoreSyncSettings(bytes(hostile), local, {}); }, "missing layouts block destructive normalization");
        auto left = j, right = j;
        left["convertLastWord"] = false; right["switchSystemLayout"] = false;
        auto merged = parse(mergeSyncSettings(base, bytes(left), bytes(right)));
        require(merged["convertLastWord"] == false && merged["switchSystemLayout"] == false, "merge independent edits");
        left = right = j; left["autoCorrectMinLength"] = 4; right["autoCorrectMinLength"] = 5;
        rejects([&] { mergeSyncSettings(base, bytes(left), bytes(right)); }, "same field conflict");
        left = right = j; left["snippets"].push_back({{"trigger", "aaa"}, {"text", "one"}});
        right["snippets"].push_back({{"trigger", "bbb"}, {"text", "two"}});
        require(parse(mergeSyncSettings(base, bytes(left), bytes(right)))["snippets"].size() == 3, "independent snippet additions merge");
        require(parse(mergeSyncSettings({}, bytes(left), base))["snippets"].size() == 2,
                "first sync merges independent additions without choosing a whole profile");
        require(parse(mergeSyncSettings({}, base, base)) == j, "identical first sync safe");
        {
            auto l = j, r = j;
            l["autoCorrectMinLength"] = 4; r["autoCorrectMinLength"] = 5;
            l["autoCorrectNever"].push_back("localword");
            r["autoCorrectNever"].push_back("remoteword");
            auto plan = mergeSyncProfile({}, bytes(l), bytes(r));
            require(plan.conflicts.size() == 1 && parse(plan.local)["autoCorrectNever"].size() == 2 &&
                    parse(plan.remote)["autoCorrectNever"].size() == 2,
                    "first sync merges lists while preserving scalar conflicts");
            require(parse(plan.local)["autoCorrectMinLength"] == 4 && parse(plan.remote)["autoCorrectMinLength"] == 5,
                    "first sync never guesses between different scalar values");
            auto again = mergeSyncProfile(plan.base, plan.local, plan.remote);
            require(again.conflicts.size() == 1, "first-sync conflicts survive saving the ancestor");
            auto resolved = mergeSyncProfile(plan.base, plan.local, plan.remote, {{plan.conflicts[0], false}});
            require(resolved.conflicts.empty() && parse(resolved.local)["autoCorrectMinLength"] == 5,
                    "first-sync conflict can be resolved independently");
        }
        require(SyncIntervalMs == 600000, "background interval is ten minutes");
        {
            auto l = j, r = j;
            l["autoCorrectReplacements"]["helo"] = "hello";
            r["autoCorrectReplacements"]["wrold"] = "world";
            auto paired = mergeSyncSettings(base, bytes(l), bytes(r));
            require(parse(paired)["autoCorrectReplacements"].size() == 2, "independent replacement pairs merge");
            l = r = parse(paired);
            l["autoCorrectReplacements"].erase("helo");
            r["autoCorrectReplacements"]["wrold"] = "worlds";
            auto removed = mergeSyncSettings(paired, bytes(l), bytes(r));
            auto restored = restoreSyncSettings(removed, local, {});
            require(restored.autoReplacements.size() == 1 && restored.autoReplacements.at(L"wrold") == L"worlds",
                    "replacement deletion merges with an independent edit and remains loadable");
            r["autoCorrectReplacements"]["helo"] = "help";
            require(mergeSyncProfile(paired, bytes(l), bytes(r)).conflicts.size() == 1,
                    "replacement deletion versus edit is a conflict");
            auto legacy = j;
            for (auto key : {"autoCorrectReplace", "autoCorrectTypos", "autoCorrectReplacements"}) legacy.erase(key);
            auto migrated = restoreSyncSettings(bytes(legacy), local, {});
            require(!migrated.autoReplace && !migrated.autoTypos && migrated.autoReplacements.empty(),
                    "older synchronized profiles default new typo modes off");
        }
        {
            auto l = j, r = j;
            l["autoCorrectMinLength"] = 4; r["autoCorrectMinLength"] = 5;
            l["convertLastWord"] = false; r["switchSystemLayout"] = false;
            auto plan = mergeSyncProfile(base, bytes(l), bytes(r));
            require(plan.conflicts.size() == 1, "one conflict reported independently");
            require(parse(plan.local)["switchSystemLayout"] == false && parse(plan.remote)["convertLastWord"] == false,
                "nonconflicting changes reach both copies");
            require(parse(plan.local)["autoCorrectMinLength"] == 4 && parse(plan.remote)["autoCorrectMinLength"] == 5,
                "unresolved scalar retains both values");
            require(parse(plan.base)["autoCorrectMinLength"] == j["autoCorrectMinLength"], "ancestor retained for unresolved setting");
            saveSyncBase(root, config, plan.base);
            auto again = mergeSyncProfile(loadSyncBase(root, config), plan.local, plan.remote);
            require(again.conflicts.size() == 1, "conflict survives restart checkpoint");
            auto choice = SyncChoice{plan.conflicts.front(), true};
            auto resolved = mergeSyncProfile(plan.base, plan.local, plan.remote, {choice});
            require(resolved.conflicts.empty() && parse(resolved.remote)["autoCorrectMinLength"] == 4,
                "resolve only selected setting");
            require(parse(resolved.remote)["switchSystemLayout"] == false, "choice preserves independent server change");
            auto changed = parse(plan.remote); changed["autoCorrectMinLength"] = 6;
            require(mergeSyncProfile(plan.base, plan.local, bytes(changed), {choice}).conflicts.size() == 1,
                "stale conflict choice never overwrites new server value");
            FakeProvider partial; partial.remote = {7, bytes(r)};
            auto result = synchronize(partial, base, bytes(l), SyncAction::Automatic);
            require(result.success && result.conflicts.size() == 1 && partial.writes == 1,
                "partial synchronization commits independent fields with CAS");
            auto encoded = encodeSyncChoices({choice});
            require(decodeSyncChoices(encoded).front().conflict.key == choice.conflict.key, "choice IPC round trip");
        }
        {
            auto id = j["snippets"][0]["id"].get<std::string>();
            auto l = j, r = j;
            l["snippets"][0]["trigger"] = "renamed";
            r["snippets"][0]["text"] = "edited remotely";
            auto merged = parse(mergeSyncSettings(base, bytes(l), bytes(r)));
            require(merged["snippets"][0]["id"] == id && merged["snippets"][0]["trigger"] == "renamed" &&
                merged["snippets"][0]["text"] == "edited remotely", "stable ID merges rename and text edit");
            l = r = j; l["snippets"] = Json::array(); l["snippetTombstones"] = Json::array({id});
            auto deletion = mergeSyncProfile(base, bytes(l), bytes(r));
            require(deletion.conflicts.empty() && parse(deletion.remote)["snippets"].empty(), "delete beats unchanged snippet");
            require(parse(deletion.remote)["snippetTombstones"] == Json::array({id}), "deletion marker retained");
            auto offline = mergeSyncProfile(base, bytes(r), deletion.remote);
            require(offline.conflicts.empty() && parse(offline.local)["snippets"].empty(), "offline copy cannot resurrect deletion");
            r["snippets"][0]["text"] = "offline edit";
            auto conflict = mergeSyncProfile(base, bytes(l), bytes(r));
            require(conflict.conflicts.size() == 1, "delete versus edit is one snippet conflict");
            auto remove = mergeSyncProfile(conflict.base, conflict.local, conflict.remote, {{conflict.conflicts[0], true}});
            require(remove.conflicts.empty() && parse(remove.remote)["snippets"].empty(), "choose deletion");
            auto keep = mergeSyncProfile(conflict.base, conflict.local, conflict.remote, {{conflict.conflicts[0], false}});
            require(keep.conflicts.empty() && parse(keep.local)["snippetTombstones"].empty() &&
                parse(keep.local)["snippets"][0]["text"] == "offline edit", "choose edited snippet removes tombstone");
            require(mergeSyncProfile(base, bytes(l), bytes(l)).conflicts.empty(), "both delete converges");
            auto legacy = j; legacy.erase("snippetTombstones"); legacy["snippets"][0].erase("id");
            auto migrated = parse(mergeSyncSettings(bytes(legacy), base, bytes(legacy)));
            require(migrated["snippets"][0]["id"] == id, "legacy profiles migrate to identical IDs");
            auto roundtrip = decodeSettings(encodeSettings(restored), {});
            require(snippetId(roundtrip.snippets.front()) == wide(id), "ID survives settings serialization");
            require(newSnippetId() != newSnippetId(), "new snippet IDs are unique");
        }
        {
            auto l = j, r = j;
            l["snippets"].push_back({{"id", "new-a"}, {"trigger", "same"}, {"text", "A"}});
            r["snippets"].push_back({{"id", "new-b"}, {"trigger", "same"}, {"text", "B"}});
            auto collision = mergeSyncProfile(base, bytes(l), bytes(r));
            require(collision.conflicts.size() == 2, "duplicate new triggers expose individual choices");
            auto resolved = mergeSyncProfile(collision.base, collision.local, collision.remote,
                {{collision.conflicts[0], true}, {collision.conflicts[1], true}});
            require(resolved.conflicts.empty() && parse(resolved.remote)["snippets"].size() == 2, "choose one of colliding additions");
            l = r = j; l["toggleHotkey"] = "Ctrl+Alt+F11"; r["caseHotkey"] = "Ctrl+Alt+F11";
            require(mergeSyncProfile(base, bytes(l), bytes(r)).conflicts.size() == 2, "cross-field shortcut collisions exposed");
            l = r = j; l["excludedApps"].push_back("local-app"); r["excludedApps"].push_back("remote-app");
            require(parse(mergeSyncSettings(base, bytes(l), bytes(r)))["excludedApps"].size() == j["excludedApps"].size() + 2,
                "independent exclusion edits merge");
        }
        FakeProvider provider;
        rejects([&] { synchronize(provider, {}, base, SyncAction::Automatic); }, "empty server never auto-populated");
        auto result = synchronize(provider, {}, base, SyncAction::Upload);
        require(result.revision == 1 && provider.writes == 1, "initial upload CAS zero");
        result = synchronize(provider, base, base, SyncAction::Automatic);
        require(provider.writes == 1 && result.revision == 1, "no-op avoids versions");
        result = synchronize(provider, base, bytes(left), SyncAction::Download);
        require(parse(result.settings) == parse(base) && provider.writes == 1, "download never writes");
        provider.race = true;
        rejects([&] { synchronize(provider, base, bytes(left), SyncAction::Upload); }, "racing writer protected");
        require(provider.writes == 1 && provider.remote.settings == base, "CAS failure preserves remote");
        provider.race = false;
        {
            auto remoteProfile = j;
            remoteProfile["layouts"] = Json::array({"win:00000422"});
            remoteProfile["layoutHotkeys"] = Json::array({{{"layoutId", "win:00000422"}, {"hotkey", "Ctrl+Alt+9"}}});
            remoteProfile["autoCorrectNever"].push_back("remoteword");
            FakeProvider partial;
            partial.remote = {3, bytes(remoteProfile)};
            auto validate = [&](const Bytes &b) { restoreSyncSettings(b, local, {}, true); };
            auto result = synchronize(partial, {}, base, SyncAction::Automatic, validate, {}, true);
            auto restored = restoreSyncSettings(result.settings, local, {}, true);
            require(restored.cycle == local.cycle && restored.direct == local.direct &&
                    restored.autoNever == std::vector<std::wstring>{L"remoteword"},
                    "partial sync restores other settings and keeps local layout configuration");
            auto next = sharedSyncSettings(restored);
            result = synchronize(partial, result.base, next, SyncAction::Automatic, validate, {}, true);
            require(parse(partial.remote.settings)["layouts"] == remoteProfile["layouts"] &&
                    parse(partial.remote.settings)["layoutHotkeys"] == remoteProfile["layoutHotkeys"],
                    "repeated partial sync never deletes unavailable server layouts or shortcuts");
            auto changed = parse(next); changed["autoCorrectMinLength"] = 7;
            result = synchronize(partial, result.base, bytes(changed), SyncAction::Upload, validate, {}, true);
            require(parse(partial.remote.settings)["autoCorrectMinLength"] == 7 &&
                    parse(partial.remote.settings)["layoutHotkeys"] == remoteProfile["layoutHotkeys"],
                    "explicit partial upload preserves server layouts too");
            auto downloaded = synchronize(partial, result.base, base, SyncAction::Download, validate, {}, true);
            auto downloadedSettings = restoreSyncSettings(downloaded.settings, local, {}, true);
            require(downloadedSettings.autoMinLength == 7 && downloadedSettings.cycle == local.cycle &&
                    downloadedSettings.direct == local.direct, "partial Download applies other settings without replacing local layouts");
            try { restoreSyncSettings(bytes(remoteProfile), local, {}); require(false, "full sync must identify missing layouts"); }
            catch (const std::runtime_error &e) {
                std::string message = e.what();
                require(message.find("win:00000422") != message.npos && message.find("Keep this PC's layouts") != message.npos,
                        "missing-layout error identifies IDs and offers partial sync");
            }
        }
        rejects([&] { synchronize(provider, base, bytes(left), SyncAction::Upload,
            [](const Bytes &) { throw std::runtime_error("invalid"); }); }, "validate before upload");
        require(provider.writes == 1, "invalid data not uploaded");
        saveSyncBase(root, config, base);
        require(parse(loadSyncBase(root, config)) == j, "encrypted baseline round trip");
        auto other = config; other.path = L"other/settings";
        require(loadSyncBase(root, other).empty(), "baseline bound to connection");
        auto encrypted = readFile(root / L"sync-base.bin", 1024 * 1024);
        std::string disk(encrypted.begin(), encrypted.end());
        require(disk.find("private snippet") == disk.npos, "baseline encrypted on disk");
        // Exercise real Credential Manager with an isolated test target, never a user endpoint.
        config.username = L"ks-sync-test-" + std::to_wstring(GetCurrentProcessId());
        saveSyncPassword(config, L"test-only-password");
        int logins{}, revokes{}, reads{}, writes{};
        unsigned readStatus = 200, writeStatus = 200;
        bool deleted = false;
        auto transport = [&](const std::wstring &method, const std::wstring &path,
            const std::wstring &token, const Bytes &body) -> SyncHttpResponse {
            if (path == L"/v1/auth/userpass/login/" + config.username)
            {
                require(method == L"POST" && token.empty(), "login route and no bearer token");
                require(parse(body)["password"] == "test-only-password", "password sourced from credential manager");
                ++logins;
                return {200, bytes({{"auth", {{"client_token", "test-token"}}}})};
            }
            require(token == L"test-token", "authenticated requests use returned token");
            if (path == L"/v1/auth/token/revoke-self")
            {
                require(method == L"POST", "revoke method"); ++revokes; return {204, {}};
            }
            require(path == L"/v1/kswitcher/data/personal/settings", "KV v2 data route");
            if (method == L"GET")
            {
                ++reads;
                if (readStatus != 200 && !deleted) return {readStatus, bytes({{"errors", Json::array()}})};
                return {readStatus, bytes({{"data", {
                    {"metadata", {{"version", 7}, {"deletion_time", deleted ? "2026-01-01" : ""}, {"destroyed", false}}},
                    {"data", {{"syncSchema", 1}, {"settings", j}}}}}})};
            }
            require(method == L"POST", "write method");
            auto request = parse(body);
            require(request["options"]["cas"] == 7, "write includes exact CAS revision");
            require(request["data"]["syncSchema"] == 2 && request["data"]["settings"] == j, "versioned settings envelope");
            ++writes;
            return {writeStatus, bytes({{"data", {{"version", 8}}}})};
        };
        {
            auto bao = makeSyncProvider(config, transport);
            auto doc = bao->read();
            require(doc.revision == 7 && parse(doc.settings) == j, "read protocol response");
            require(bao->write(base, 7) == 8, "write protocol response");
            readStatus = 404;
            require(bao->read().revision == 0, "missing profile");
            deleted = true;
            rejects([&] { bao->read(); }, "soft deleted is not treated as absent");
            deleted = false; readStatus = 403;
            rejects([&] { bao->read(); }, "permission denied is not absent");
            readStatus = 302;
            rejects([&] { bao->read(); }, "redirect response rejected");
            writeStatus = 400;
            rejects([&] { bao->write(base, 7); }, "server CAS refusal propagated");
        }
        require(logins == 1 && revokes == 1 && reads == 5 && writes == 2, "temporary login lifecycle");
        forgetSyncPassword(config); forgetSyncPassword(config);
        ++checks;
        std::filesystem::remove_all(root);
        std::cout << checks << " sync checks passed\n";
        return 0;
    }
    catch (const std::exception &e)
    {
        std::cerr << e.what() << "\n";
        return 1;
    }
}