// Copyright (c) 2015-2016 The Bitcoin Core developers
// Copyright (c) 2017-2025 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <prevector.h>

#include <reverse_iterator.h>
#include <serialize.h>
#include <streams.h>

#include <test/setup_common.h>

#include <boost/test/unit_test.hpp>

#include <span>
#include <vector>

BOOST_FIXTURE_TEST_SUITE(prevector_tests, TestingSetup)

template <unsigned int N, typename T> class prevector_tester {
    typedef std::vector<T> realtype;
    realtype real_vector;
    realtype real_vector_alt;

    typedef prevector<N, T> pretype;
    pretype pre_vector;
    pretype pre_vector_alt;

    typedef typename pretype::size_type Size;
    bool passed = true;
    FastRandomContext rand_cache;
    uint256 rand_seed;

    template <typename A, typename B> void local_check_equal(A a, B b) {
        local_check(a == b);
    }
    void local_check(bool b) { passed &= b; }
    void test() {
        const pretype &const_pre_vector = pre_vector;
        local_check_equal(real_vector.size(), pre_vector.size());
        local_check_equal(real_vector.empty(), pre_vector.empty());
        for (Size s = 0; s < real_vector.size(); s++) {
            local_check(real_vector[s] == pre_vector[s]);
            local_check(&(pre_vector[s]) == &(pre_vector.begin()[s]));
            local_check(&(pre_vector[s]) == &*(pre_vector.begin() + s));
            local_check(&(pre_vector[s]) ==
                        &*((pre_vector.end() + s) - real_vector.size()));
        }
        // local_check(realtype(pre_vector) == real_vector);
        local_check(pretype(real_vector.begin(), real_vector.end()) ==
                    pre_vector);
        local_check(pretype(pre_vector.begin(), pre_vector.end()) ==
                    pre_vector);
        size_t pos = 0;
        for (const T &v : pre_vector) {
            local_check(v == real_vector[pos++]);
        }
        for (const T &v : reverse_iterate(pre_vector)) {
            local_check(v == real_vector[--pos]);
        }
        for (const T &v : const_pre_vector) {
            local_check(v == real_vector[pos++]);
        }
        for (const T &v : reverse_iterate(const_pre_vector)) {
            local_check(v == real_vector[--pos]);
        }
        CDataStream ss1(SER_DISK, 0);
        CDataStream ss2(SER_DISK, 0);
        ss1 << real_vector;
        ss2 << pre_vector;
        local_check_equal(ss1.size(), ss2.size());
        for (Size s = 0; s < ss1.size(); s++) {
            local_check_equal(ss1[s], ss2[s]);
        }
    }

public:
    void resize(Size s) {
        real_vector.resize(s);
        local_check_equal(real_vector.size(), s);
        pre_vector.resize(s);
        local_check_equal(pre_vector.size(), s);
        test();
    }

    void reserve(Size s) {
        real_vector.reserve(s);
        local_check(real_vector.capacity() >= s);
        pre_vector.reserve(s);
        local_check(pre_vector.capacity() >= s);
        test();
    }

    void insert(Size position, const T &value) {
        real_vector.insert(real_vector.begin() + position, value);
        pre_vector.insert(pre_vector.begin() + position, value);
        test();
    }

    void insert(Size position, Size count, const T &value) {
        real_vector.insert(real_vector.begin() + position, count, value);
        pre_vector.insert(pre_vector.begin() + position, count, value);
        test();
    }

    template <typename I> void insert_range(Size position, I first, I last) {
        real_vector.insert(real_vector.begin() + position, first, last);
        pre_vector.insert(pre_vector.begin() + position, first, last);
        test();
    }

    void erase(Size position) {
        real_vector.erase(real_vector.begin() + position);
        pre_vector.erase(pre_vector.begin() + position);
        test();
    }

    void erase(Size first, Size last) {
        real_vector.erase(real_vector.begin() + first,
                          real_vector.begin() + last);
        pre_vector.erase(pre_vector.begin() + first, pre_vector.begin() + last);
        test();
    }

    void update(Size pos, const T &value) {
        real_vector[pos] = value;
        pre_vector[pos] = value;
        test();
    }

    void push_back(const T &value) {
        real_vector.push_back(value);
        pre_vector.push_back(value);
        test();
    }

    void pop_back() {
        real_vector.pop_back();
        pre_vector.pop_back();
        test();
    }

    void clear() {
        real_vector.clear();
        pre_vector.clear();
    }

    void assign(Size n, const T &value) {
        real_vector.assign(n, value);
        pre_vector.assign(n, value);
    }

    Size size() const { return real_vector.size(); }

    Size capacity() const { return pre_vector.capacity(); }

    void shrink_to_fit() {
        pre_vector.shrink_to_fit();
        test();
    }

    void swap() {
        real_vector.swap(real_vector_alt);
        pre_vector.swap(pre_vector_alt);
        test();
    }

    void move() {
        real_vector = std::move(real_vector_alt);
        real_vector_alt.clear();
        pre_vector = std::move(pre_vector_alt);
        pre_vector_alt.clear();
    }

    void copy() {
        real_vector = real_vector_alt;
        pre_vector = pre_vector_alt;
    }

    void resize_uninitialized(realtype values) {
        size_t r = values.size();
        size_t s = real_vector.size() / 2;
        if (real_vector.capacity() < s + r) {
            real_vector.reserve(s + r);
        }
        real_vector.resize(s);
        pre_vector.resize_uninitialized(s);
        for (auto v : values) {
            real_vector.push_back(v);
        }
        auto p = pre_vector.size();
        pre_vector.resize_uninitialized(p + r);
        for (auto v : values) {
            pre_vector[p] = v;
            ++p;
        }
        test();
    }

    ~prevector_tester() {
        BOOST_CHECK_MESSAGE(passed, "insecure_rand: " + rand_seed.ToString());
    }

    prevector_tester() {
        SeedInsecureRand();
        rand_seed = InsecureRand256();
        rand_cache = FastRandomContext(rand_seed);
    }
};

BOOST_AUTO_TEST_CASE(PrevectorTestInt) {
    for (int j = 0; j < 64; j++) {
        prevector_tester<8, int> test;
        for (int i = 0; i < 2048; i++) {
            if (InsecureRandBits(2) == 0) {
                test.insert(InsecureRandRange(test.size() + 1),
                            InsecureRand32());
            }
            if (test.size() > 0 && InsecureRandBits(2) == 1) {
                test.erase(InsecureRandRange(test.size()));
            }
            if (InsecureRandBits(3) == 2) {
                int new_size = std::max(
                    0, std::min(30, int(test.size()) +
                                        int(InsecureRandRange(5)) - 2));
                test.resize(new_size);
            }
            if (InsecureRandBits(3) == 3) {
                test.insert(InsecureRandRange(test.size() + 1),
                            1 + InsecureRandBool(), InsecureRand32());
            }
            if (InsecureRandBits(3) == 4) {
                int del = std::min<int>(test.size(), 1 + (InsecureRandBool()));
                int beg = InsecureRandRange(test.size() + 1 - del);
                test.erase(beg, beg + del);
            }
            if (InsecureRandBits(4) == 5) {
                test.push_back(InsecureRand32());
            }
            if (test.size() > 0 && InsecureRandBits(4) == 6) {
                test.pop_back();
            }
            if (InsecureRandBits(5) == 7) {
                int values[4];
                int num = 1 + (InsecureRandBits(2));
                for (int k = 0; k < num; k++) {
                    values[k] = InsecureRand32();
                }
                test.insert_range(InsecureRandRange(test.size() + 1), values,
                                  values + num);
            }
            if (InsecureRandBits(5) == 8) {
                int del = std::min<int>(test.size(), 1 + (InsecureRandBits(2)));
                int beg = InsecureRandRange(test.size() + 1 - del);
                test.erase(beg, beg + del);
            }
            if (InsecureRandBits(5) == 9) {
                test.reserve(InsecureRandBits(5));
            }
            if (InsecureRandBits(6) == 10) {
                test.shrink_to_fit();
            }
            if (test.size() > 0) {
                test.update(InsecureRandRange(test.size()), InsecureRand32());
            }
            if (InsecureRandBits(10) == 11) {
                test.clear();
            }
            if (InsecureRandBits(9) == 12) {
                test.assign(InsecureRandBits(5), InsecureRand32());
            }
            if (InsecureRandBits(3) == 3) {
                test.swap();
            }
            if (InsecureRandBits(4) == 8) {
                test.copy();
            }
            if (InsecureRandBits(5) == 18) {
                test.move();
            }
            if (InsecureRandBits(5) == 19) {
                unsigned int num = 1 + (InsecureRandBits(4));
                std::vector<int> values(num);
                for (auto &v : values) {
                    v = InsecureRand32();
                }
                test.resize_uninitialized(values);
            }
        }
    }
}

BOOST_AUTO_TEST_CASE(PrevectorTestSpan) {
    // Just ensure prevector can be implicitly and explicitly converted to std::span and that the result is sane.
    auto GetSizeViaImplicitSpan = [](const std::span<const uint8_t> &sp){ return sp.size(); };
    prevector<28, uint8_t> pvec;
    for (size_t i = 0; i < 64; ++i) {
        pvec.push_back(InsecureRandBits(8));
        std::span<uint8_t> span{pvec}; // ensure c'tor works
        std::span<const uint8_t> cspan{pvec};
        auto test = [&] {
            BOOST_CHECK_EQUAL(span.size(), pvec.size());
            BOOST_CHECK_EQUAL(cspan.size(), pvec.size());
            BOOST_CHECK_EQUAL(GetSizeViaImplicitSpan(pvec), pvec.size());
            BOOST_CHECK(span.data() == pvec.data());
            BOOST_CHECK(cspan.data() == pvec.data());
            auto it = cspan.rbegin();
            auto it2 = pvec.rbegin();
            for (size_t pos = pvec.size(); it != cspan.rend() && it2 != pvec.rend() && pos != 0; ++it, ++it2) {
                BOOST_CHECK_EQUAL(*it, *it2);
                BOOST_CHECK_EQUAL(*it, pvec[--pos]);
            }
            BOOST_CHECK(it == cspan.rend() && it2 == pvec.rend());
        };
        test();
        span = pvec; // ensure copy-assign works
        cspan = pvec;
        test();
    }
}

BOOST_AUTO_TEST_SUITE_END()
