// Copyright (c) 2026-present The Bitcoin Core developers

// Distributed under the MIT software license, see the accompanying

// file COPYING or https://www.opensource.org/licenses/mit-license.php.

#include <wallet/export.h>

#include <key_io.h>

#include <util/fs.h>

#include <util/expected.h>

#include <wallet/scriptpubkeyman.h>

#include <wallet/context.h>

#include <wallet/sqlite.h>

#include <wallet/wallet.h>

#include <fstream>

namespace wallet {

util::Expected<std::vector<WalletDescInfo>, std::string> ExportDescriptors(const CWallet& wallet, bool export_private)

{

    AssertLockHeld(wallet.cs_wallet);

    std::vector<WalletDescInfo> wallet_descriptors;

    for (const auto& spk_man : wallet.GetAllScriptPubKeyMans()) {

  Branch (22:30): [True: 0, False: 0]

        const auto desc_spk_man = dynamic_cast<DescriptorScriptPubKeyMan*>(spk_man);

        if (!desc_spk_man) {

  Branch (24:13): [True: 0, False: 0]

            return util::Unexpected{"Unexpected ScriptPubKey manager type."};

        }

        LOCK(desc_spk_man->cs_desc_man);

        const auto& wallet_descriptor = desc_spk_man->GetWalletDescriptor();

        std::string descriptor;

        if (!Assume(desc_spk_man->GetDescriptorString(descriptor, export_private))) {

  Branch (30:13): [True: 0, False: 0]

            return util::Unexpected{"Can't get descriptor string."};

        }

        const bool is_range = wallet_descriptor.descriptor->IsRange();

        wallet_descriptors.emplace_back(

            descriptor,

            wallet_descriptor.creation_time,

            wallet.IsActiveScriptPubKeyMan(*desc_spk_man),

            wallet.IsInternalScriptPubKeyMan(desc_spk_man),

            is_range ? std::optional(std::make_pair(wallet_descriptor.GetStart(), wallet_descriptor.GetEnd())) : std::nullopt,

  Branch (39:13): [True: 0, False: 0]

            wallet_descriptor.GetNext(),

            wallet_descriptor.cache

        );

    }

    return wallet_descriptors;

}

util::Result<std::string> ExportWatchOnlyWallet(const CWallet& wallet, const fs::path& destination, WalletContext& context)

{

    AssertLockHeld(wallet.cs_wallet);

    if (destination.empty()) {

  Branch (51:9): [True: 0, False: 0]

        return util::Error{_("Error: Export destination cannot be empty")};

    }

    if (fs::exists(destination)) {

  Branch (54:9): [True: 0, False: 0]

        return util::Error{strprintf(_("Error: Export destination '%s' already exists"), fs::PathToString(destination))};

    }

    if (!std::ofstream{fs::PathToString(destination)}) {

  Branch (57:9): [True: 0, False: 0]

        return util::Error{strprintf(_("Error: Could not create file '%s'"), fs::PathToString(destination))};

    }

    bool success = false;

    auto cleanup_destination = interfaces::MakeCleanupHandler([&success, &destination] {

        if (!success) fs::remove(destination);

  Branch (62:13): [True: 0, False: 0]

    });

    // Get the descriptors from this wallet

    util::Expected<std::vector<WalletDescInfo>, std::string> exported = ExportDescriptors(wallet, /*export_private=*/false);

    if (!exported) {

  Branch (67:9): [True: 0, False: 0]

        return util::Error{Untranslated(exported.error())};

    }

    if (exported->empty()) {

  Branch (70:9): [True: 0, False: 0]

        return util::Error{_("Error: Wallet has no descriptors to export")};

    }

    // Make the wallet with the same flags as this wallet, but without private keys

    const uint64_t create_flags = wallet.GetWalletFlags() | WALLET_FLAG_DISABLE_PRIVATE_KEYS;

    // Create the temporary watchonly wallet in memory to avoid leaving files on disk

    std::vector<bilingual_str> warnings;

    bilingual_str error;

    WalletContext empty_context;

    empty_context.args = context.args;

    std::shared_ptr<CWallet> watchonly_wallet = CWallet::CreateNew(empty_context, /*name=*/wallet.GetName() + "_watchonly_temp", MakeInMemoryWalletDatabase(), create_flags, /*born_encrypted=*/false, error, warnings);

    if (!watchonly_wallet) {

  Branch (83:9): [True: 0, False: 0]

        return util::Error{strprintf(_("Error: Failed to create new watchonly wallet. %s"), error)};

    }

    {

        LOCK(watchonly_wallet->cs_wallet);

        // Parse the descriptors and add them to the new wallet

        for (const WalletDescInfo& desc_info : *Assert(exported)) {

  Branch (91:46): [True: 0, False: 0]

            // Parse the descriptor

            FlatSigningProvider dummy_keys;

            std::string dummy_err;

            std::vector<std::unique_ptr<Descriptor>> descs = Parse(desc_info.descriptor, dummy_keys, dummy_err, /*require_checksum=*/true);

            CHECK_NONFATAL(descs.size() == 1); // All of our descriptors should be valid, and not multipath

            CHECK_NONFATAL(dummy_keys.keys.size() == 0); // No private keys should be present in our exported descriptors

            // Get the range if there is one

            int32_t range_start = 0;

            int32_t range_end = 0;

            if (desc_info.range) {

  Branch (102:17): [True: 0, False: 0]

                range_start = desc_info.range->first;

                range_end = desc_info.range->second;

            }

            WalletDescriptor w_desc(std::move(descs.at(0)), desc_info.creation_time, range_start, range_end, desc_info.next_index);

            // For descriptors that cannot self expand (i.e. needs private keys or cache), set the cache

            if (!w_desc.descriptor->CanSelfExpand()) {

  Branch (110:17): [True: 0, False: 0]

                w_desc.cache = desc_info.cache;

            }

            // Add to the watchonly wallet

            auto spkm_res = watchonly_wallet->AddWalletDescriptor(w_desc, dummy_keys, /*label=*/"", /*internal=*/false);

            if (!spkm_res) {

  Branch (116:17): [True: 0, False: 0]

                return util::Error{util::ErrorString(spkm_res)};

            }

            // Set active spkms as active

            if (desc_info.active) {

  Branch (121:17): [True: 0, False: 0]

                // Determine whether this descriptor is internal

                // This is only set for active spkms

                bool internal = false;

                if (desc_info.internal) {

  Branch (125:21): [True: 0, False: 0]

                    internal = *desc_info.internal;

                }

                watchonly_wallet->AddActiveScriptPubKeyMan(spkm_res->get().GetID(), *Assert(w_desc.descriptor->GetOutputType()), internal);

            }

        }

        // Copy locked coins that are persisted

        for (const auto& [coin, persisted] : wallet.m_locked_coins) {

  Branch (133:44): [True: 0, False: 0]

            if (!persisted) continue;

  Branch (134:17): [True: 0, False: 0]

            watchonly_wallet->LockCoin(coin, persisted);

        }

        {

            // Make a WalletBatch for the watchonly wallet so that everything else can be written atomically

            WalletBatch watchonly_batch(watchonly_wallet->GetDatabase());

            if (!watchonly_batch.TxnBegin()) {

  Branch (141:17): [True: 0, False: 0]

                return util::Error{strprintf(_("Error: database transaction cannot be executed for new watchonly wallet %s"), watchonly_wallet->GetName())};

            }

            // Copy orderPosNext

            watchonly_batch.WriteOrderPosNext(wallet.nOrderPosNext);

            // Write the best block locator to avoid rescanning on reload

            CBlockLocator best_block_locator;

            {

                WalletBatch local_wallet_batch(wallet.GetDatabase());

                if (!local_wallet_batch.ReadBestBlock(best_block_locator)) {

  Branch (152:21): [True: 0, False: 0]

                    return util::Error{_("Error: Unable to read wallet's best block locator record")};

                }

            }

            if (!watchonly_batch.WriteBestBlock(best_block_locator)) {

  Branch (156:17): [True: 0, False: 0]

                return util::Error{_("Error: Unable to write watchonly wallet best block locator record")};

            }

            // Copy the transactions

            for (const auto& [txid, wtx] : wallet.mapWallet) {

  Branch (161:42): [True: 0, False: 0]

                DataStream wtx_ser;

                wtx_ser << wtx;

                CWalletTx copy_wtx(deserialize, wtx_ser, wtx.GetTxs());

                if (!watchonly_wallet->LoadToWallet(std::move(copy_wtx))) {

  Branch (165:21): [True: 0, False: 0]

                    return util::Error{strprintf(_("Error: Could not add tx %s to watchonly wallet"), txid.GetHex())};

                }

                watchonly_batch.WriteFullTx(watchonly_wallet->mapWallet.at(txid));

            }

            // Copy address book

            for (const auto& [dest, entry] : wallet.m_address_book) {

  Branch (172:44): [True: 0, False: 0]

                auto address{EncodeDestination(dest)};

                if (entry.purpose) watchonly_batch.WritePurpose(address, PurposeToString(*entry.purpose));

  Branch (174:21): [True: 0, False: 0]

                if (entry.label) watchonly_batch.WriteName(address, *entry.label);

  Branch (175:21): [True: 0, False: 0]

                for (const auto& [id, request] : entry.receive_requests) {

  Branch (176:48): [True: 0, False: 0]

                    watchonly_batch.WriteAddressReceiveRequest(dest, id, request);

                }

                if (entry.previously_spent) watchonly_batch.WriteAddressPreviouslySpent(dest, true);

  Branch (179:21): [True: 0, False: 0]

            }

            if (!watchonly_batch.TxnCommit()) {

  Branch (182:17): [True: 0, False: 0]

                return util::Error{_("Error: cannot commit db transaction for watchonly wallet export")};

            }

        }

        // Make a backup of this wallet at the specified destination directory

        if (!watchonly_wallet->BackupWallet(fs::PathToString(destination))) {

  Branch (188:13): [True: 0, False: 0]

            return util::Error{_("Error: Unable to write the exported wallet")};

        }

        success = true;

    }

    return fs::PathToString(destination);

}

} // namespace wallet