/*
 * Copyright (c)2013-2021 ZeroTier, Inc.
 *
 * Use of this software is governed by the Business Source License included
 * in the LICENSE.TXT file in the project's root directory.
 *
 * Change Date: 2026-01-01
 *
 * On the date above, in accordance with the Business Source License, use
 * of this software will be governed by version 2.0 of the Apache License.
 */
/****/

#ifndef ZT_CONTAINERS_HPP
#define ZT_CONTAINERS_HPP

/* This defines a Map, SortedMap, Vector, etc. based on STL templates. */

#include "Constants.hpp"
#include "Utils.hpp"

#include <algorithm>
#include <list>
#include <map>
#include <set>
#include <string>
#include <vector>

#ifdef __CPP11__

#include <atomic>
#include <forward_list>
#include <unordered_map>

#endif

namespace ZeroTier {

template <typename V> class Vector : public std::vector<V> {
  public:
    ZT_INLINE Vector() : std::vector<V>() {}

    template <typename I> ZT_INLINE Vector(I begin, I end) : std::vector<V>(begin, end) {}
};

template <typename V> class List : public std::list<V> {
};

#ifdef __CPP11__

struct intl_MapHasher {
    template <typename O> std::size_t operator()(const O &obj) const noexcept { return (std::size_t)obj.hashCode(); }

    std::size_t operator()(const Vector<uint8_t> &bytes) const noexcept { return (std::size_t)Utils::fnv1a32(bytes.data(), (unsigned int)bytes.size()); }

    std::size_t operator()(const uint64_t i) const noexcept { return (std::size_t)Utils::hash64(i ^ Utils::s_mapNonce); }

    std::size_t operator()(const int64_t i) const noexcept { return (std::size_t)Utils::hash64((uint64_t)i ^ Utils::s_mapNonce); }

    std::size_t operator()(const uint32_t i) const noexcept { return (std::size_t)Utils::hash32(i ^ (uint32_t)Utils::s_mapNonce); }

    std::size_t operator()(const int32_t i) const noexcept { return (std::size_t)Utils::hash32((uint32_t)i ^ (uint32_t)Utils::s_mapNonce); }
};

template <typename K, typename V> class Map : public std::unordered_map<K, V, intl_MapHasher> {
};

template <typename K, typename V> class MultiMap : public std::unordered_multimap<K, V, intl_MapHasher, std::equal_to<K>> {
};

#else

template <typename K, typename V> class Map : public std::map<K, V> {
};

template <typename K, typename V> class MultiMap : public std::multimap<K, V> {
};

#endif

template <typename K, typename V> class SortedMap : public std::map<K, V> {
};

#ifdef __CPP11__

template <typename V> class ForwardList : public std::forward_list<V> {
};

#else

template <typename V> class ForwardList : public std::list<V> {
};

#endif

template <typename V> class Set : public std::set<V, std::less<V>> {
};

typedef std::string String;

/**
 * A 384-bit hash
 */
struct H384 {
    uint64_t data[6];

    ZT_INLINE H384() noexcept { Utils::zero<sizeof(data)>(data); }

    ZT_INLINE H384(const H384 &b) noexcept { Utils::copy<48>(data, b.data); }

    explicit ZT_INLINE H384(const void *const d) noexcept { Utils::copy<48>(data, d); }

    ZT_INLINE H384 &operator=(const H384 &b) noexcept
    {
        Utils::copy<48>(data, b.data);
        return *this;
    }

    ZT_INLINE unsigned long hashCode() const noexcept { return (unsigned long)data[0]; }

    ZT_INLINE operator bool() const noexcept { return ((data[0] != 0) && (data[1] != 0) && (data[2] != 0) && (data[3] != 0) && (data[4] != 0) && (data[5] != 0)); }

    ZT_INLINE bool operator==(const H384 &b) const noexcept { return ((data[0] == b.data[0]) && (data[1] == b.data[1]) && (data[2] == b.data[2]) && (data[3] == b.data[3]) && (data[4] == b.data[4]) && (data[5] == b.data[5])); }

    ZT_INLINE bool operator!=(const H384 &b) const noexcept { return !(*this == b); }

    ZT_INLINE bool operator<(const H384 &b) const noexcept { return std::lexicographical_compare(data, data + 6, b.data, b.data + 6); }

    ZT_INLINE bool operator<=(const H384 &b) const noexcept { return !(b < *this); }

    ZT_INLINE bool operator>(const H384 &b) const noexcept { return (b < *this); }

    ZT_INLINE bool operator>=(const H384 &b) const noexcept { return !(*this < b); }
};

static_assert(sizeof(H384) == 48, "H384 contains unnecessary padding");

/**
 * A fixed size byte array
 *
 * @tparam S Size in bytes
 */
template <unsigned long S> struct Blob {
    uint8_t data[S];

    ZT_INLINE Blob() noexcept { Utils::zero<S>(data); }

    ZT_INLINE Blob(const Blob &b) noexcept { Utils::copy<S>(data, b.data); }

    explicit ZT_INLINE Blob(const void *const d) noexcept { Utils::copy<S>(data, d); }

    explicit ZT_INLINE Blob(const void *const d, const unsigned int l) noexcept
    {
        Utils::copy(data, d, (l > (unsigned int)S) ? (unsigned int)S : l);
        if (l < S) {
            Utils::zero(data + l, S - l);
        }
    }

    ZT_INLINE Blob &operator=(const Blob &b) noexcept
    {
        Utils::copy<S>(data, b.data);
        return *this;
    }

    ZT_INLINE unsigned long hashCode() const noexcept { return Utils::fnv1a32(data, (unsigned int)S); }

    ZT_INLINE operator bool() const noexcept { return Utils::allZero(data, (unsigned int)S); }

    ZT_INLINE bool operator==(const Blob &b) const noexcept { return (memcmp(data, b.data, S) == 0); }

    ZT_INLINE bool operator!=(const Blob &b) const noexcept { return (memcmp(data, b.data, S) != 0); }

    ZT_INLINE bool operator<(const Blob &b) const noexcept { return (memcmp(data, b.data, S) < 0); }

    ZT_INLINE bool operator<=(const Blob &b) const noexcept { return (memcmp(data, b.data, S) <= 0); }

    ZT_INLINE bool operator>(const Blob &b) const noexcept { return (memcmp(data, b.data, S) > 0); }

    ZT_INLINE bool operator>=(const Blob &b) const noexcept { return (memcmp(data, b.data, S) >= 0); }
};

}   // namespace ZeroTier

#endif