#include "embedded_resources.h"
#include "../util/platform.h"
#include "../util/logger.h"
#include <algorithm>
#include <cerrno>
#include <fstream>
#include <filesystem>
#include <functional>
#include <mutex>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cctype>
#include <chrono>

#ifdef _WIN32
#include <windows.h>
#include <shlobj.h>
#else
#include <fcntl.h>
#include <unistd.h>
#include <pwd.h>
#include <sys/types.h>
#include <sys/stat.h>
#endif

// Include generated resource data if available
#if __has_include("embedded_data.h")
#include "embedded_data.h"
#define HAS_EMBEDDED_RESOURCES 1
#else
#define HAS_EMBEDDED_RESOURCES 0
#endif

namespace dragonx {
namespace resources {

#if HAS_EMBEDDED_RESOURCES
// Resource table - populated by embedded_data.h (INCBIN symbols: g_NAME_data / g_NAME_size)
static const EmbeddedResource s_resources[] = {
    { g_sapling_spend_params_data,  g_sapling_spend_params_size,  RESOURCE_SAPLING_SPEND },
    { g_sapling_output_params_data, g_sapling_output_params_size, RESOURCE_SAPLING_OUTPUT },
    { g_asmap_dat_data,             g_asmap_dat_size,             RESOURCE_ASMAP },
#ifdef HAS_EMBEDDED_DAEMON
    { g_dragonxd_exe_data,          g_dragonxd_exe_size,          RESOURCE_DRAGONXD },
    { g_dragonx_cli_exe_data,       g_dragonx_cli_exe_size,       RESOURCE_DRAGONX_CLI },
    { g_dragonx_tx_exe_data,        g_dragonx_tx_exe_size,        RESOURCE_DRAGONX_TX },
#endif
#ifdef HAS_EMBEDDED_WALLET_REBUILD
    { g_dragonx_wallet_rebuild_exe_data, g_dragonx_wallet_rebuild_exe_size, RESOURCE_DRAGONX_WALLET_REBUILD },
#endif
#ifdef HAS_EMBEDDED_XMRIG
    { g_xmrig_exe_data,             g_xmrig_exe_size,             RESOURCE_XMRIG },
#endif
#ifdef HAS_EMBEDDED_GRADIENT
    { g_dark_gradient_png_data,     g_dark_gradient_png_size,     RESOURCE_DARK_GRADIENT },
#endif
#ifdef HAS_EMBEDDED_LOGO
    { g_logo_ObsidianDragon_dark_png_data,  g_logo_ObsidianDragon_dark_png_size,  RESOURCE_LOGO },
#endif
    { nullptr, 0, nullptr } // Sentinel
};
// Embedded themes table is generated by s_embedded_themes[] in embedded_data.h
#else
static const EmbeddedResource s_resources[] = {
    { nullptr, 0, nullptr } // No embedded resources
};
// No embedded themes on non-Windows builds (themes live on disk)
struct EmbeddedThemeEntry { const uint8_t* data; unsigned int size; const char* filename; };
static const EmbeddedThemeEntry s_embedded_themes[] = {
    { nullptr, 0, nullptr }
};
// No embedded images on non-Windows builds (images live on disk)
struct EmbeddedImageEntry { const uint8_t* data; unsigned int size; const char* filename; };
static const EmbeddedImageEntry s_embedded_images[] = {
    { nullptr, 0, nullptr }
};
#endif

bool hasEmbeddedResources()
{
#if HAS_EMBEDDED_RESOURCES
    return true;
#else
    return false;
#endif
}

const EmbeddedResource* getEmbeddedResource(const std::string& name)
{
    // Search static resource table (params, daemon binaries, etc.)
    for (const auto* res = s_resources; res->filename != nullptr; ++res) {
        if (res->data && res->size && name == res->filename) {
            return res;
        }
    }
    // Search dynamically generated image table (backgrounds + logos)
    // These are generated by build.sh from res/img/ contents.
    for (const auto* img = s_embedded_images; img->data != nullptr; ++img) {
        if (name == img->filename) {
            static thread_local EmbeddedResource imageResult;
            imageResult = { img->data, img->size, img->filename };
            return &imageResult;
        }
    }
    return nullptr;
}

const EmbeddedTheme* getEmbeddedThemes()
{
    // Map from generated table to public struct
    // s_embedded_themes is generated by build.sh (or empty fallback)
    static std::vector<EmbeddedTheme> themes;
    static bool init = false;
    if (!init) {
        for (const auto* t = s_embedded_themes; t->data != nullptr; ++t) {
            themes.push_back({ t->data, t->size, t->filename });
        }
        themes.push_back({ nullptr, 0, nullptr }); // Sentinel
        init = true;
    }
    return themes.data();
}

int writeFileIfDifferent(const std::string& path, const uint8_t* data, size_t size)
{
    {
        std::ifstream cur(path, std::ios::binary | std::ios::ate);
        if (cur.is_open()) {
            const std::streamoff len = cur.tellg();
            if (len >= 0 && static_cast<size_t>(len) == size) {
                std::string buf(size, '\0');
                cur.seekg(0);
                if (size == 0 || (cur.read(&buf[0], static_cast<std::streamsize>(size)) &&
                                  std::memcmp(buf.data(), data, size) == 0))
                    return 0;
            }
        }
    }   // reader closed before the writer opens (Windows sharing)
    std::ofstream f(path, std::ios::binary | std::ios::trunc);
    if (!f.is_open()) return -1;
    f.write(reinterpret_cast<const char*>(data), static_cast<std::streamsize>(size));
    return f.good() ? 1 : -1;
}

int extractBundledThemes(const std::string& destDir)
{
    namespace fs = std::filesystem;
    int count = 0;

    const auto* themes = getEmbeddedThemes();
    if (!themes || !themes->data) return 0;

    // Ensure destination exists
    std::error_code ec;
    fs::create_directories(destDir, ec);
    if (ec) {
        DEBUG_LOGF("[ERROR] EmbeddedResources: Failed to create theme dir: %s\n", destDir.c_str());
        return 0;
    }

    for (const auto* t = themes; t->data != nullptr; ++t) {
        fs::path dest = fs::path(destDir) / t->filename;
        // Bundled themes must match the binary version: rewrite only when the bytes differ (not size-only:
        // a same-length palette edit must still update).
        const int w = writeFileIfDifferent(dest.string(), t->data, t->size);
        if (w >= 0) {
            if (w == 1) DEBUG_LOGF("[INFO] EmbeddedResources: Extracted theme: %s (%zu bytes)\n", t->filename, t->size);
            count++;   // present and current (caller only checks > 0)
        } else {
            DEBUG_LOGF("[ERROR] EmbeddedResources: Failed to write theme: %s\n", dest.string().c_str());
        }
    }
    return count;
}

int updateBundledThemes(const std::string& dir)
{
    namespace fs = std::filesystem;
    int count = 0;

    const auto* themes = getEmbeddedThemes();
    if (!themes || !themes->data) return 0;
    if (!fs::exists(dir)) return 0;

    for (const auto* t = themes; t->data != nullptr; ++t) {
        fs::path dest = fs::path(dir) / t->filename;
        if (!fs::exists(dest)) {
            // New theme not yet on disk — extract it
        } else {
            std::error_code ec;
            auto diskSize = fs::file_size(dest, ec);
            if (!ec && diskSize == static_cast<std::uintmax_t>(t->size))
                continue; // up to date
        }
        std::ofstream f(dest, std::ios::binary);
        if (f.is_open()) {
            f.write(reinterpret_cast<const char*>(t->data), t->size);
            f.close();
            DEBUG_LOGF("[INFO] EmbeddedResources: Updated stale theme: %s (%zu bytes)\n",
                   t->filename, t->size);
            count++;
        }
    }
    return count;
}

std::string getParamsDirectory()
{
#ifdef _WIN32
    char appdata[MAX_PATH];
    if (SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_APPDATA, NULL, 0, appdata))) {
        return std::string(appdata) + "\\ZcashParams";
    }
    return "";
#elif defined(__APPLE__)
    const char* home = getenv("HOME");
    if (!home) {
        struct passwd* pw = getpwuid(getuid());
        home = pw ? pw->pw_dir : "/tmp";
    }
    return std::string(home) + "/Library/Application Support/ZcashParams";
#else
    const char* home = getenv("HOME");
    if (!home) {
        struct passwd* pw = getpwuid(getuid());
        home = pw ? pw->pw_dir : "/tmp";
    }
    return std::string(home) + "/.zcash-params";
#endif
}

// ---------------------------------------------------------------------------------------------------
// Writing into the daemon directory: one lock, atomic (temp + flush + rename) files.
// ---------------------------------------------------------------------------------------------------
namespace {

// Every writer of the daemon directory (startup job, getDaemonPath(), getXmrigPath(), forceExtractXmrig(),
// reextractBundledDaemon(), ensureWalletRebuildHelperExtracted(), copyBundledFiles()) holds this for its whole
// write; whoever comes second finds the files complete and does nothing. Never taken re-entrantly. Lock order:
// provisionMutex -> Logger mutex (DEBUG_LOGF) only. The in-app updaters do not take it (see residual risks).
std::mutex& provisionMutex() { static std::mutex m; return m; }

struct ProvisionEntry {
    const char* name;
    bool refreshOnSizeMismatch;   // re-extract when the bundled size differs (params, asmap)
    bool executable;
    bool fullNodeOnly;            // not written by Lite builds (the lite backend bakes in its own params)
    bool startupTrigger;          // makes needsParamsExtraction() true
};

// Params and asmap follow the bundled size; the node binaries, the rebuild helper and the miner are placed only
// when MISSING (user-updatable via the updaters: the user may run a specific dragonxd or an "Update miner..."
// build; replacing the node is the explicit Settings action). asmap/cli/tx/rebuild are written along, never a trigger.
const ProvisionEntry kProvisionEntries[] = {
    { RESOURCE_SAPLING_SPEND,  true,  false, true,  true  },
    { RESOURCE_SAPLING_OUTPUT, true,  false, true,  true  },
    { RESOURCE_ASMAP,          true,  false, true,  false },
#ifdef HAS_EMBEDDED_DAEMON
    { RESOURCE_DRAGONXD,       false, true,  true,  true  },
    { RESOURCE_DRAGONX_CLI,    false, true,  true,  false },
    { RESOURCE_DRAGONX_TX,     false, true,  true,  false },
#endif
#ifdef HAS_EMBEDDED_XMRIG
    { RESOURCE_XMRIG,          kXmrigRefreshOnSizeMismatch, true, false, true },
#endif
#ifdef HAS_EMBEDDED_WALLET_REBUILD
    { RESOURCE_DRAGONX_WALLET_REBUILD, false, true, true, false },
#endif
};

bool entryActive(const ProvisionEntry& e)
{
#if defined(DRAGONX_LITE_BUILD) && DRAGONX_LITE_BUILD
    return !e.fullNodeOnly;
#else
    (void)e;
    return true;
#endif
}

std::string joinDir(const std::string& dir, const char* name)
{
#ifdef _WIN32
    return dir + "\\" + name;
#else
    return dir + "/" + name;
#endif
}

constexpr std::size_t kCopyChunk = 4u * 1024u * 1024u;

bool prepareParentDir(const std::string& destPath)
{
    const std::filesystem::path dest(destPath);
    if (!dest.has_parent_path()) return true;
    std::error_code ec;
    std::filesystem::create_directories(dest.parent_path(), ec);
    if (ec) {
        DEBUG_LOGF("[ERROR] Failed to create directory %s: %s\n", dest.parent_path().string().c_str(),
                   ec.message().c_str());
        return false;
    }
    return true;
}

// Temp-file sink for writeFileAtomic / copyFileAtomic. Windows: ONE CreateFileA handle with no SECURITY_ATTRIBUTES,
// i.e. NOT inheritable: std::ofstream's CRT handle is, and a child created with bInheritHandles=TRUE meanwhile
// (xmrig, runHiddenCapture) would hold "<name>.partial" without FILE_SHARE_DELETE, so the MoveFileEx in
// replaceFromTemp fails while it runs (same fix as Platform::writeFileAtomically). commit() flushes on the same
// handle (FlushFileBuffers / fsync) before close, so the bytes are on disk before the rename. POSIX: O_CLOEXEC.
class TempSink {
public:
    explicit TempSink(const std::string& path)
    {
#ifdef _WIN32
        h_ = CreateFileA(path.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
#else
        fd_ = ::open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
#endif
    }
    ~TempSink() { (void)close(); }
    TempSink(const TempSink&) = delete;
    TempSink& operator=(const TempSink&) = delete;

    bool ok() const
    {
#ifdef _WIN32
        return h_ != INVALID_HANDLE_VALUE;
#else
        return fd_ >= 0;
#endif
    }
    bool write(const void* data, std::size_t n)
    {
        const char* p = static_cast<const char*>(data);
        while (n > 0) {
#ifdef _WIN32
            const DWORD chunk = static_cast<DWORD>(n > (1u << 30) ? (1u << 30) : n);
            DWORD w = 0;
            if (!WriteFile(h_, p, chunk, &w, nullptr) || w == 0) return false;
#else
            const ssize_t w = ::write(fd_, p, n);
            if (w < 0) { if (errno == EINTR) continue; return false; }
            if (w == 0) return false;
#endif
            p += w;
            n -= static_cast<std::size_t>(w);
        }
        return true;
    }
    // Flush to stable storage, then close. False on any error.
    bool commit()
    {
        bool good = ok();
#ifdef _WIN32
        if (good && !FlushFileBuffers(h_)) good = false;
#else
        if (good && ::fsync(fd_) != 0) good = false;
#endif
        if (!close()) good = false;
        return good;
    }

private:
    bool close()
    {
#ifdef _WIN32
        if (h_ == INVALID_HANDLE_VALUE) return true;
        const bool r = CloseHandle(h_) != 0;
        h_ = INVALID_HANDLE_VALUE;
        return r;
#else
        if (fd_ < 0) return true;
        const bool r = ::close(fd_) == 0;
        fd_ = -1;
        return r;
#endif
    }
#ifdef _WIN32
    HANDLE h_ = INVALID_HANDLE_VALUE;
#else
    int fd_ = -1;
#endif
};

// Move `tmp` over `dest`. POSIX: rename() replaces atomically (even a running binary) + best-effort dir fsync.
// Windows (same primitive as Platform::writeFileAtomically): MoveFileEx REPLACE_EXISTING|WRITE_THROUGH. A
// running .exe cannot be replaced but can be renamed, so it is moved aside to ".old" once (the running process
// keeps it; cleaned on a later run). A just-closed file is often held for a moment by antivirus (sharing
// violation), so retry for up to ~2 s, but stop at once if the temp vanished (quarantined). On failure the
// temp is removed and a moved-aside original is put back.
bool replaceFromTemp(const std::string& tmp, const std::string& dest)
{
#ifdef _WIN32
    const std::string aside = dest + ".old";
    bool movedAside = false;
    DWORD err = 0;
    for (int attempt = 0; attempt < 20; ++attempt) {
        if (MoveFileExA(tmp.c_str(), dest.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH))
            return true;
        err = GetLastError();
        if (GetFileAttributesA(tmp.c_str()) == INVALID_FILE_ATTRIBUTES) break;   // temp gone (AV quarantine)
        if (!movedAside && GetFileAttributesA(dest.c_str()) != INVALID_FILE_ATTRIBUTES) {
            DeleteFileA(aside.c_str());
            if (MoveFileExA(dest.c_str(), aside.c_str(), MOVEFILE_REPLACE_EXISTING)) {
                movedAside = true;
                DEBUG_LOGF("[INFO] %s is in use - moved the old copy to .old\n", dest.c_str());
                continue;
            }
        }
        Sleep(100);
    }
    DEBUG_LOGF("[ERROR] Could not move %s into place (Win32 error %lu)\n", dest.c_str(), (unsigned long)err);
    DeleteFileA(tmp.c_str());
    if (movedAside) MoveFileExA(aside.c_str(), dest.c_str(), MOVEFILE_REPLACE_EXISTING);
    return false;
#else
    if (::rename(tmp.c_str(), dest.c_str()) != 0) {
        DEBUG_LOGF("[ERROR] Could not move %s into place: %s\n", dest.c_str(), std::strerror(errno));
        ::remove(tmp.c_str());
        return false;
    }
    const std::string dir = std::filesystem::path(dest).parent_path().string();
    const int dfd = ::open(dir.empty() ? "." : dir.c_str(), O_RDONLY | O_CLOEXEC);
    if (dfd >= 0) { ::fsync(dfd); ::close(dfd); }
    return true;
#endif
}

} // namespace

bool resourceNeedsWrite(std::uint64_t embeddedSize, bool refreshOnSizeMismatch, const std::string& destPath)
{
    if (embeddedSize == 0) return false;
    std::error_code ec;
    if (!std::filesystem::exists(destPath, ec)) return true;
    if (!refreshOnSizeMismatch) return false;
    const auto diskSize = std::filesystem::file_size(destPath, ec);
    if (ec) return true;   // can't stat -> rewrite
    return static_cast<std::uint64_t>(diskSize) != embeddedSize;
}

// Check if an on-disk file is missing or differs in size from the embedded resource.
// A size mismatch means the binary was updated in a newer wallet build.
[[maybe_unused]] static bool resourceNeedsUpdate(const EmbeddedResource* res, const std::string& destPath)
{
    if (!res || !res->data || res->size == 0) return false;
    return resourceNeedsWrite(res->size, /*refreshOnSizeMismatch=*/true, destPath);
}

bool needsParamsExtraction()
{
    if (!hasEmbeddedResources()) return false;
    const std::string dir = getDaemonDirectory();   // the only extraction target
    for (const auto& e : kProvisionEntries) {
        if (!entryActive(e) || !e.startupTrigger) continue;
        const EmbeddedResource* res = getEmbeddedResource(e.name);
        if (res && resourceNeedsWrite(res->size, e.refreshOnSizeMismatch, joinDir(dir, e.name))) return true;
    }
    return false;
}

bool writeFileAtomic(const std::string& destPath, const std::uint8_t* data, std::size_t size, bool executable,
                     ProvisionProgress* progress, const CancelFn& cancelled)
{
    if (!data || size == 0) return false;
    if (!prepareParentDir(destPath)) return false;
    const std::string tmp = destPath + kPartialFileSuffix;
    std::error_code ec;
    bool good = true;
    {
        TempSink f(tmp);
        if (!f.ok()) { DEBUG_LOGF("[ERROR] Failed to open %s for writing\n", tmp.c_str()); return false; }
        for (std::size_t off = 0; off < size; off += kCopyChunk) {
            if (cancelled && cancelled()) { good = false; break; }
            const std::size_t n = std::min(kCopyChunk, size - off);
            if (!f.write(data + off, n)) {
                DEBUG_LOGF("[ERROR] Failed to write %zu bytes to %s\n", n, tmp.c_str());
                good = false; break;
            }
            if (progress) progress->bytesDone.fetch_add(n, std::memory_order_relaxed);
        }
        // Flush on the same handle BEFORE the rename: a power cut can't leave a truncated file under the final name.
        if (good && !f.commit()) { DEBUG_LOGF("[ERROR] Failed to finish writing %s\n", tmp.c_str()); good = false; }
    }   // closed here: Windows can't delete a file that is still open without FILE_SHARE_DELETE
    if (!good) { std::filesystem::remove(tmp, ec); return false; }
#ifndef _WIN32
    if (executable) ::chmod(tmp.c_str(), 0755);   // before it becomes visible under the final name
#else
    (void)executable;
#endif
    if (!replaceFromTemp(tmp, destPath)) return false;
    DEBUG_LOGF("[INFO] Extracted %s (%zu bytes)\n", destPath.c_str(), size);
    return true;
}

bool copyFileAtomic(const std::string& srcPath, const std::string& destPath,
                    ProvisionProgress* progress, const CancelFn& cancelled)
{
    namespace fs = std::filesystem;
    if (!prepareParentDir(destPath)) return false;
    const std::string tmp = destPath + kPartialFileSuffix;
    std::error_code ec;
    bool good = true;
    {
        std::ifstream in(srcPath, std::ios::binary);   // a read handle on the source is harmless if inherited
        if (!in) { DEBUG_LOGF("[ERROR] Failed to open %s\n", srcPath.c_str()); return false; }
        TempSink out(tmp);
        if (!out.ok()) { DEBUG_LOGF("[ERROR] Failed to open %s for writing\n", tmp.c_str()); return false; }
        std::vector<char> buf(kCopyChunk);
        for (;;) {
            if (cancelled && cancelled()) { good = false; break; }
            in.read(buf.data(), static_cast<std::streamsize>(buf.size()));
            const std::streamsize got = in.gcount();
            if (got > 0) {
                if (!out.write(buf.data(), static_cast<std::size_t>(got))) {
                    DEBUG_LOGF("[ERROR] Failed to write %s\n", tmp.c_str());
                    good = false; break;
                }
                if (progress) progress->bytesDone.fetch_add(static_cast<std::uint64_t>(got), std::memory_order_relaxed);
            }
            if (!in) break;   // EOF (eof|fail) or a read error (bad, checked below)
        }
        if (good && in.bad()) {
            DEBUG_LOGF("[ERROR] Failed to read %s\n", srcPath.c_str());
            good = false;
        }
        // Flush on the same handle BEFORE the rename: a power cut can't leave a truncated file under the final name.
        if (good && !out.commit()) { DEBUG_LOGF("[ERROR] Failed to finish writing %s\n", tmp.c_str()); good = false; }
    }   // closed here: Windows can't delete a file that is still open without FILE_SHARE_DELETE
    if (!good) { fs::remove(tmp, ec); return false; }
    const auto st = fs::status(srcPath, ec);
    if (!ec) fs::permissions(tmp, st.permissions(), ec);   // keeps dragonxd/cli/tx executable (as copy_file did)
    return replaceFromTemp(tmp, destPath);
}

// Requires provisionMutex() held.
static bool extractResourceLocked(const EmbeddedResource* res, const std::string& destPath, bool executable,
                                  ProvisionProgress* progress = nullptr, const CancelFn& cancelled = {})
{
    if (!res || !res->data || res->size == 0) return false;
    return writeFileAtomic(destPath, res->data, res->size, executable, progress, cancelled);
}

bool extractEmbeddedResources(ProvisionProgress* progress, const CancelFn& cancelled)
{
    if (!hasEmbeddedResources()) {
        DEBUG_LOGF("[ERROR] No embedded resources available\n");
        return false;
    }
    std::lock_guard<std::mutex> lock(provisionMutex());

    // All files go to <ObsidianDragonDir>/dragonx/ — NOT the data directory (running dragonxd.exe from inside
    // the data directory, where it writes chain data / debug.log / lock files, crashes on some Windows machines).
    const std::string daemonDir = getDaemonDirectory();
    DEBUG_LOGF("[INFO] Daemon extraction directory: %s\n", daemonDir.c_str());
    std::error_code ec;
    std::filesystem::create_directories(daemonDir, ec);
    ec.clear();

    // Temp files left by an interrupted run (killed process, power cut). Only OUR suffix.
    for (const auto& e : kProvisionEntries) {
        std::filesystem::remove(joinDir(daemonDir, e.name) + kPartialFileSuffix, ec);
        ec.clear();
    }

    struct Todo { const ProvisionEntry* entry; const EmbeddedResource* res; std::string dest; };
    std::vector<Todo> todo;
    std::uint64_t total = 0;
    for (const auto& e : kProvisionEntries) {
        if (!entryActive(e)) continue;
        const EmbeddedResource* res = getEmbeddedResource(e.name);
        if (!res) continue;
        std::string dest = joinDir(daemonDir, e.name);
        if (!resourceNeedsWrite(res->size, e.refreshOnSizeMismatch, dest)) continue;
        total += res->size;
        todo.push_back({ &e, res, std::move(dest) });
    }
    if (progress) {
        progress->bytesDone.store(0, std::memory_order_relaxed);
        progress->bytesTotal.store(total, std::memory_order_relaxed);
        progress->setPhase(ProvisionPhase::Extracting);
    }

    bool success = true;
    for (const auto& t : todo) {
        if (cancelled && cancelled()) return false;
        DEBUG_LOGF("[INFO] Extracting %s (%zu MB)...\n", t.entry->name, t.res->size / (1024 * 1024));
        if (!extractResourceLocked(t.res, t.dest, t.entry->executable, progress, cancelled)) {
            if (cancelled && cancelled()) return false;
            success = false;
        }
    }

    // Best-effort cleanup of ".old" copies left by an in-use replacement. Once the old process has exited the
    // file is no longer locked and removes cleanly; if it still runs, the remove fails and we retry next run.
    for (const auto& e : kProvisionEntries) {
        std::filesystem::remove(joinDir(daemonDir, e.name) + std::string(".old"), ec);
        ec.clear();
    }
    return success;
}

std::vector<std::string> bundleSearchDirs()
{
    std::vector<std::string> dirs;
    const std::string exeDir = util::Platform::getExecutableDirectory();
    if (exeDir.empty()) return dirs;
#ifdef __APPLE__
    // Inside a .app the params live in Contents/Resources while the executable is in Contents/MacOS.
    std::error_code ec;
    const std::filesystem::path res = std::filesystem::path(exeDir).parent_path() / "Resources";
    if (std::filesystem::is_directory(res, ec)) dirs.push_back(res.string());
#endif
    dirs.push_back(exeDir);
    return dirs;
}

const std::vector<std::string>& saplingParamFileNames()
{
    static const std::vector<std::string> v = { "sapling-spend.params", "sapling-output.params" };
    return v;
}

const std::vector<std::string>& nodeBundleFileNames()
{
    static const std::vector<std::string> v = { "sapling-spend.params", "sapling-output.params", "asmap.dat",
                                                "dragonxd", "dragonx-cli", "dragonx-tx" };
    return v;
}

std::vector<BundleCopyItem> planBundleCopy(const std::vector<std::string>& searchDirs, const std::string& destDir,
                                           const std::vector<std::string>& names, bool replaceExisting)
{
    namespace fs = std::filesystem;
    std::vector<BundleCopyItem> plan;
    std::error_code ec;
    for (const auto& name : names) {
        const fs::path dst = fs::path(destDir) / name;
        if (!replaceExisting && fs::exists(dst, ec)) continue;
        for (const auto& dir : searchDirs) {
            const fs::path src = fs::path(dir) / name;
            if (fs::exists(src, ec)) { plan.push_back({ name, src.string(), dst.string() }); break; }
        }
    }
    return plan;
}

BundleCopyResult copyBundledFiles(const std::vector<std::string>& searchDirs, const std::string& destDir,
                                  const std::vector<std::string>& names, bool replaceExisting,
                                  ProvisionProgress* progress, const CancelFn& cancelled)
{
    BundleCopyResult r;
    // Stat-only check first: the steady-state call (every daemon start) never touches the lock.
    if (planBundleCopy(searchDirs, destDir, names, replaceExisting).empty()) return r;
    std::lock_guard<std::mutex> lock(provisionMutex());
    const auto plan = planBundleCopy(searchDirs, destDir, names, replaceExisting);   // re-check under the lock
    std::uint64_t total = 0;
    std::error_code ec;
    for (const auto& it : plan) {
        std::filesystem::remove(it.dst + kPartialFileSuffix, ec);   // stale temp from an interrupted copy
        ec.clear();
        const auto sz = std::filesystem::file_size(it.src, ec);
        if (!ec) total += sz;
        ec.clear();
    }
    if (progress) {
        progress->bytesDone.store(0, std::memory_order_relaxed);
        progress->bytesTotal.store(total, std::memory_order_relaxed);
        progress->setPhase(ProvisionPhase::Copying);
    }
    for (const auto& it : plan) {
        if (cancelled && cancelled()) { r.ok = false; return r; }
        DEBUG_LOGF("Copying bundled %s to %s\n", it.name.c_str(), destDir.c_str());
        if (copyFileAtomic(it.src, it.dst, progress, cancelled)) {
            ++r.copied;
        } else {
            if (cancelled && cancelled()) { r.ok = false; return r; }
            DEBUG_LOGF("[ERROR] Failed to copy %s\n", it.name.c_str());
            r.ok = false;
            if (r.firstFailure.empty()) r.firstFailure = it.name;
        }
    }
    return r;
}

std::string ensureWalletRebuildHelperExtracted()
{
#ifdef HAS_EMBEDDED_WALLET_REBUILD
    const EmbeddedResource* res = getEmbeddedResource(RESOURCE_DRAGONX_WALLET_REBUILD);
    if (!res || res->size == 0) return {};
#ifdef _WIN32
    const char sep = '\\';
#else
    const char sep = '/';
#endif
    const std::string dir  = getDaemonDirectory();
    const std::string dest = dir + sep + RESOURCE_DRAGONX_WALLET_REBUILD;
    std::error_code ec;
    if (std::filesystem::exists(dest, ec)) return dest;   // already extracted (atomic write: exists == complete)
    std::lock_guard<std::mutex> lock(provisionMutex());   // serialise with the startup job / other writers
    if (std::filesystem::exists(dest, ec)) return dest;   // written meanwhile by the startup job
    std::filesystem::create_directories(dir, ec);
    if (!extractResourceLocked(res, dest, /*executable=*/true)) return {};
    DEBUG_LOGF("[INFO] Extracted wallet-rebuild helper on demand: %s\n", dest.c_str());
    return dest;
#else
    return {};
#endif
}

std::string getDaemonDirectory()
{
    // Daemon binaries live in %APPDATA%/ObsidianDragon/dragonx/ (Windows) or
    // ~/.config/ObsidianDragon/dragonx/ (Linux) — separate from the blockchain
    // data directory to avoid lock-file conflicts.
    std::string obsidianDir = util::Platform::getObsidianDragonDir();
#ifdef _WIN32
    return obsidianDir + "\\dragonx";
#else
    return obsidianDir + "/dragonx";
#endif
}

bool needsDaemonExtraction()
{
#ifdef HAS_EMBEDDED_DAEMON
    std::string daemonDir = getDaemonDirectory();
#ifdef _WIN32
    std::string daemonPath = daemonDir + "\\dragonxd.exe";
#else
    std::string daemonPath = daemonDir + "/dragonxd";
#endif
    const auto* res = getEmbeddedResource(RESOURCE_DRAGONXD);
    return resourceNeedsUpdate(res, daemonPath);
#else
    return false;
#endif
}

bool hasDaemonAvailable()
{
#ifdef HAS_EMBEDDED_DAEMON
    return true;
#else
    // Check if daemon exists alongside the executable
#ifdef _WIN32
    return std::filesystem::exists("dragonxd.exe");
#else
    return std::filesystem::exists("dragonxd");
#endif
#endif
}

std::string getDaemonPath()
{
    std::string daemonDir = getDaemonDirectory();
#ifdef _WIN32
    const char pathSep = '\\';
    const char* daemonName = "dragonxd.exe";
#else
    const char pathSep = '/';
    const char* daemonName = "dragonxd";
#endif

    DEBUG_LOGF("[DEBUG] getDaemonPath: daemonDir=%s\n", daemonDir.c_str());

#ifdef HAS_EMBEDDED_DAEMON
    // Extract if needed
    std::string embeddedPath = daemonDir + pathSep + daemonName;
    DEBUG_LOGF("[DEBUG] getDaemonPath: checking embedded path %s\n", embeddedPath.c_str());
    if (!std::filesystem::exists(embeddedPath)) {
        DEBUG_LOGF("[INFO] getDaemonPath: daemon not found, extracting embedded resources...\n");
        extractEmbeddedResources();
    }
    if (std::filesystem::exists(embeddedPath)) {
        DEBUG_LOGF("[INFO] getDaemonPath: found at %s\n", embeddedPath.c_str());
        return embeddedPath;
    }
#endif

    // Check local directory
    if (std::filesystem::exists(daemonName)) {
        DEBUG_LOGF("[INFO] getDaemonPath: found in local directory\n");
        return daemonName;
    }
    
    DEBUG_LOGF("[ERROR] getDaemonPath: daemon binary not found anywhere\n");
    return "";
}

bool hasXmrigAvailable()
{
#ifdef HAS_EMBEDDED_XMRIG
    return true;
#else
    // Check if xmrig exists alongside the executable
#ifdef _WIN32
    return std::filesystem::exists("xmrig.exe");
#else
    return std::filesystem::exists("xmrig");
#endif
#endif
}

bool forceExtractXmrig()
{
#ifdef HAS_EMBEDDED_XMRIG
    std::string daemonDir = getDaemonDirectory();
#ifdef _WIN32
    std::string dest = daemonDir + "\\" + RESOURCE_XMRIG;
#else
    std::string dest = daemonDir + "/" + RESOURCE_XMRIG;
#endif
    const EmbeddedResource* xmrigRes = getEmbeddedResource(RESOURCE_XMRIG);
    if (!xmrigRes) {
        DEBUG_LOGF("[ERROR] forceExtractXmrig: no embedded xmrig resource\n");
        return false;
    }
    DEBUG_LOGF("[INFO] forceExtractXmrig: extracting xmrig (%zu MB) to %s\n",
            xmrigRes->size / (1024*1024), dest.c_str());
    std::lock_guard<std::mutex> lock(provisionMutex());
    if (!extractResourceLocked(xmrigRes, dest, /*executable=*/true)) {
        DEBUG_LOGF("[ERROR] forceExtractXmrig: extraction failed\n");
        return false;
    }
    return true;
#else
    return false;
#endif
}

// Scan a binary blob for the daemon's version stamp: 'v' <maj>.<min>.<rev> optionally followed by
// '-' <commit hash (>=6 hex)>, e.g. "v1.0.2-ddd851dc1". Returns the first match, or "" if none.
static std::string scanBinaryVersion(const uint8_t* data, std::size_t size,
                                     std::size_t lastStart = static_cast<std::size_t>(-1))
{
    if (!data || size < 6) return "";
    auto isdig = [](uint8_t c) { return std::isdigit(static_cast<unsigned char>(c)) != 0; };
    auto isxd  = [](uint8_t c) { return std::isxdigit(static_cast<unsigned char>(c)) != 0; };
    for (std::size_t i = 0; i + 5 < size && i <= lastStart; ++i) {
        if (data[i] != 'v') continue;
        std::size_t k = i + 1, s;
        s = k; while (k < size && isdig(data[k])) ++k; if (k == s) continue;   // major
        if (k >= size || data[k] != '.') continue; ++k;
        s = k; while (k < size && isdig(data[k])) ++k; if (k == s) continue;   // minor
        if (k >= size || data[k] != '.') continue; ++k;
        s = k; while (k < size && isdig(data[k])) ++k; if (k == s) continue;   // revision
        std::size_t end = k;
        if (k < size && data[k] == '-') {                                      // optional -<commit>
            std::size_t h = k + 1, hs = h;
            while (h < size && isxd(data[h])) ++h;
            if (h - hs >= 6) end = h;
        }
        return std::string(reinterpret_cast<const char*>(data) + i, end - i);
    }
    return "";
}

// Stream the file in 4 MiB chunks (bounded memory, stops at the first stamp). A non-final chunk only starts
// matches where a whole stamp (<= kStampMax bytes) still fits, and the last kStampMax-1 bytes are carried into the
// next chunk, so a stamp straddling a boundary is neither cut short nor missed.
static std::string scanFileVersion(const std::string& path)
{
    std::ifstream f(path, std::ios::binary);
    if (!f) return "";
    constexpr std::size_t kChunk = 4u << 20, kStampMax = 64;
    std::vector<uint8_t> buf(kChunk + kStampMax);
    std::size_t carry = 0;
    for (;;) {
        f.read(reinterpret_cast<char*>(buf.data() + carry), static_cast<std::streamsize>(kChunk));
        const std::size_t got = static_cast<std::size_t>(f.gcount());
        const std::size_t total = carry + got;
        const bool last = got < kChunk;   // short read => EOF
        const std::size_t lastStart = (last || total < kStampMax) ? static_cast<std::size_t>(-1) : total - kStampMax;
        std::string v = scanBinaryVersion(buf.data(), total, lastStart);
        if (!v.empty()) return v;
        if (last) return "";
        carry = kStampMax - 1;
        std::memmove(buf.data(), buf.data() + total - carry, carry);
    }
}

DaemonBinaryInfo getInstalledDaemonInfo(bool scanVersion)
{
    DaemonBinaryInfo info;
    std::string daemonDir = getDaemonDirectory();
#ifdef _WIN32
    info.path = daemonDir + "\\" + DAEMON_BINARY_NAME;
#else
    info.path = daemonDir + "/" + DAEMON_BINARY_NAME;   // was RESOURCE_DRAGONXD ("dragonxd.exe"): never existed on POSIX (C123)
#endif
    std::error_code ec;
    if (!std::filesystem::exists(info.path, ec)) return info;  // exists stays false
    info.exists = true;
    info.size = std::filesystem::file_size(info.path, ec);
    if (ec) info.size = 0;

    auto ftime = std::filesystem::last_write_time(info.path, ec);
    if (!ec) {
        // Convert filesystem clock → system_clock epoch (pre-C++20 portable approximation).
        auto sysTime = std::chrono::time_point_cast<std::chrono::system_clock::duration>(
            ftime - decltype(ftime)::clock::now() + std::chrono::system_clock::now());
        info.modifiedEpoch =
            static_cast<std::int64_t>(std::chrono::system_clock::to_time_t(sysTime));
    }

    // Scan for the version stamp (streamed; call off the UI thread). Cached by (path, size, mtime): Refresh and the
    // post-install reload only rescan when the file actually changed.
    if (!scanVersion) return info;
    {
        static std::mutex cacheMutex;
        static std::string cPath, cVersion;
        static std::uintmax_t cSize = 0;
        static std::int64_t cMtime = 0;
        {
            std::lock_guard<std::mutex> lock(cacheMutex);
            if (cPath == info.path && cSize == info.size && cMtime == info.modifiedEpoch && !cVersion.empty()) {
                info.version = cVersion;
                return info;
            }
        }
        info.version = scanFileVersion(info.path);
        std::lock_guard<std::mutex> lock(cacheMutex);
        cPath = info.path; cSize = info.size; cMtime = info.modifiedEpoch; cVersion = info.version;
    }
    return info;
}

BundledDaemonInfo getBundledDaemonInfo()
{
    BundledDaemonInfo info;
#ifdef HAS_EMBEDDED_DAEMON
    const EmbeddedResource* res = getEmbeddedResource(RESOURCE_DRAGONXD);
    if (res && res->data && res->size > 0) {
        info.available = true;
        info.size = res->size;
        // The embedded bytes are constant for this build — scan once.
        static const std::string cachedVersion = scanBinaryVersion(res->data, res->size);
        info.version = cachedVersion;
    }
#endif
    return info;
}

bool reextractBundledDaemon()
{
#ifdef HAS_EMBEDDED_DAEMON
    std::lock_guard<std::mutex> lock(provisionMutex());
    std::string daemonDir = getDaemonDirectory();
#ifdef _WIN32
    const char pathSep = '\\';
#else
    const char pathSep = '/';
#endif
    bool ok = true;
    bool wroteAny = false;
    const char* names[] = { RESOURCE_DRAGONXD, RESOURCE_DRAGONX_CLI, RESOURCE_DRAGONX_TX };
    for (const char* name : names) {
        const EmbeddedResource* res = getEmbeddedResource(name);
        if (!res) continue;
        std::string dest = daemonDir + pathSep + name;
        DEBUG_LOGF("[INFO] reextractBundledDaemon: writing %s (%zu MB)\n", name, res->size / (1024*1024));
        if (!extractResourceLocked(res, dest, /*executable=*/true)) {
            DEBUG_LOGF("[ERROR] reextractBundledDaemon: failed to write %s\n", name);
            ok = false;
            continue;
        }
        wroteAny = true;
    }
    return ok && wroteAny;
#else
    return false;
#endif
}

std::string getXmrigPath()
{
    std::string daemonDir = getDaemonDirectory();
#ifdef _WIN32
    const char pathSep = '\\';
    const char* xmrigName = "xmrig.exe";
#else
    const char pathSep = '/';
    const char* xmrigName = "xmrig";
#endif

    DEBUG_LOGF("[DEBUG] getXmrigPath: daemonDir=%s\n", daemonDir.c_str());

#ifdef HAS_EMBEDDED_XMRIG
    // Extract if needed — force re-extract in case Defender deleted it
    std::string embeddedPath = daemonDir + pathSep + xmrigName;
    DEBUG_LOGF("[DEBUG] getXmrigPath: checking embedded path %s\n", embeddedPath.c_str());
    if (!std::filesystem::exists(embeddedPath)) {
        // Serialise with the startup job: if it just wrote xmrig, the re-check finds it complete.
        std::lock_guard<std::mutex> lock(provisionMutex());
        if (!std::filesystem::exists(embeddedPath)) {
            DEBUG_LOGF("[DEBUG] getXmrigPath: not found, force re-extracting xmrig\n");
            const EmbeddedResource* xr = getEmbeddedResource(RESOURCE_XMRIG);
            if (xr) extractResourceLocked(xr, embeddedPath, /*executable=*/true);
        }
    }
    if (std::filesystem::exists(embeddedPath)) {
        DEBUG_LOGF("[INFO] getXmrigPath: found at %s\n", embeddedPath.c_str());
        return embeddedPath;
    }
#endif

    // Check local directory
    if (std::filesystem::exists(xmrigName)) {
        DEBUG_LOGF("[INFO] getXmrigPath: found in local directory\n");
        return xmrigName;
    }
    
    // Check alongside the wallet executable (zip / AppImage distributions)
    {
        std::string exeDir = util::Platform::getExecutableDirectory();
        if (!exeDir.empty()) {
            std::string exeDirPath = exeDir + "/" + xmrigName;
            if (std::filesystem::exists(exeDirPath)) {
                DEBUG_LOGF("[INFO] getXmrigPath: found alongside wallet at %s\n", exeDirPath.c_str());
                return exeDirPath;
            }
        }
    }

    // Check development paths
#ifdef _WIN32
    // Not applicable for cross-compiled Windows builds
#else
    // Linux development build — resolve relative to executable directory
    // (build/bin/), not CWD which may differ at runtime
    std::string exeDir = util::Platform::getExecutableDirectory();
    std::vector<std::string> devPaths = {
        exeDir + "/../../external/xmrig-HAC/xmrig/build/xmrig",   // from build/linux/bin/
        exeDir + "/../external/xmrig-HAC/xmrig/build/xmrig",      // from build/linux/
        "../external/xmrig-HAC/xmrig/build/xmrig",                 // CWD = build/linux/
        "../../external/xmrig-HAC/xmrig/build/xmrig",              // CWD = build/linux/bin/
        "external/xmrig-HAC/xmrig/build/xmrig",                    // CWD = project root
    };
    for (const auto& dp : devPaths) {
        if (std::filesystem::exists(dp)) {
            std::string resolved = std::filesystem::canonical(dp).string();
            DEBUG_LOGF("[INFO] getXmrigPath: found dev binary at %s\n", resolved.c_str());
            return resolved;
        }
    }
#endif
    
    DEBUG_LOGF("[ERROR] getXmrigPath: xmrig binary not found anywhere\n");
    return "";
}

} // namespace resources
} // namespace dragonx