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

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

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

#include <util/bip32.h>

#include <tinyformat.h>

#include <util/strencodings.h>

#include <algorithm>

#include <cstdint>

#include <optional>

#include <span>

#include <sstream>

#include <string_view>

util::Expected<KeyPathElement, std::string> ParseKeyPathElement(std::span<const char> elem)

{

    const std::string_view raw{elem.begin(), elem.end()};

    if (elem.empty()) {

        return util::Unexpected{strprintf("Key path value '%s' is not valid", raw)};

    }

    bool is_hardened = false;

    const char last = elem.back();

    if (last == '\'' || last == 'h') {

        elem = elem.first(elem.size() - 1);

        is_hardened = true;

    }

    const auto number{ToIntegral<uint32_t>(std::string_view{elem.begin(), elem.end()})};

    if (!number) {

        return util::Unexpected{strprintf("Key path value '%s' is not a valid uint32", raw)};

    }

    if (*number >= BIP32_HARDENED_FLAG) {

        return util::Unexpected{strprintf("Key path value %u is out of range", *number)};

    }

    return KeyPathElement{*number, is_hardened};

}

bool ParseHDKeypath(const std::string& keypath_str, std::vector<uint32_t>& keypath)

{

    std::stringstream ss(keypath_str);

    std::string item;

    bool first = true;

    while (std::getline(ss, item, '/') || std::getline(ss, item, 'h')) {

        if (item.compare("m") == 0) {

            if (first) {

                first = false;

                continue;

            }

            return false;

        }

        const auto parsed{ParseKeyPathElement(std::span<const char>{item.data(), item.size()})};

        if (!parsed) return false;

        keypath.push_back(parsed->ChildNumber());

        first = false;

    }

    return true;

}

std::string FormatHDKeypath(const std::vector<uint32_t>& path, bool apostrophe)

{

    std::string ret;

    for (auto i : path) {

        ret += strprintf("/%i", (i << 1) >> 1);

        if (i >> 31) ret += apostrophe ? '\'' : 'h';

    }

    return ret;

}

std::string WriteHDKeypath(const std::vector<uint32_t>& keypath, bool apostrophe)

{

    return "m" + FormatHDKeypath(keypath, apostrophe);

}

bool HasHardenedDerivation(std::span<const uint32_t> keypath)

{

    return std::any_of(keypath.begin(), keypath.end(), [](uint32_t index) {

        return index >> 31;

    });

}