/* Utilities for OctaSTD.
 *
 * This file is part of OctaSTD. See COPYING.md for futher information.
 */

#ifndef OSTD_UTILITY_HH
#define OSTD_UTILITY_HH

#include <stddef.h>

#include <utility>

#include "ostd/type_traits.hh"
#include "ostd/internal/tuple.hh"

namespace ostd {

/* declval */

template<typename T>
AddRvalueReference<T> declval() noexcept;

/* swap */

namespace detail {
    template<typename T>
    auto test_swap(int) ->
        BoolConstant<IsVoid<decltype(declval<T>().swap(declval<T &>()))>>;
    template<typename>
    False test_swap(...);

    template<typename T>
    inline void swap_fb(
        T &a, T &b, EnableIf<decltype(test_swap<T>(0))::value, bool> = true
    ) noexcept(noexcept(a.swap(b))) {
        a.swap(b);
    }

    template<typename T>
    inline void swap_fb(
        T &a, T &b, EnableIf<!decltype(test_swap<T>(0))::value, bool> = true
    ) noexcept(IsNothrowMoveConstructible<T> && IsNothrowMoveAssignable<T>) {
        T c(std::move(a));
        a = std::move(b);
        b = std::move(c);
    }
}

template<typename T>
inline void swap(T &a, T &b) noexcept(noexcept(detail::swap_fb(a, b))) {
   detail::swap_fb(a, b);
}

template<typename T, Size N>
inline void swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b))) {
    for (Size i = 0; i < N; ++i) {
        swap(a[i], b[i]);
    }
}

namespace detail {
    namespace adl_swap {
        using ostd::swap;
        template<typename T>
        inline void swap_adl(T &a, T &b) noexcept(noexcept(swap(a, b))) {
            swap(a, b);
        }
    }
    template<typename T>
    inline void swap_adl(T &a, T &b) noexcept(noexcept(adl_swap::swap_adl(a, b))) {
        adl_swap::swap_adl(a, b);
    }
}

/* pair */

struct PiecewiseConstruct {};
constexpr PiecewiseConstruct piecewise_construct = {};

template<typename T, typename U>
struct Pair {
    T first;
    U second;

    Pair() = default;
    ~Pair() = default;

    Pair(Pair const &) = default;
    Pair(Pair &&) = default;

    Pair(T const &x, U const &y): first(x), second(y) {}

    template<typename TT, typename UU>
    Pair(TT &&x, UU &&y):
        first(std::forward<TT>(x)), second(std::forward<UU>(y))
    {}

    template<typename TT, typename UU>
    Pair(Pair<TT, UU> const &v): first(v.first), second(v.second) {}

    template<typename TT, typename UU>
    Pair(Pair<TT, UU> &&v):
        first(std::move(v.first)), second(std::move(v.second))
    {}

    template<typename ...A1, typename ...A2>
    Pair(PiecewiseConstruct pc, Tuple<A1...> fa, Tuple<A2...> sa):
        Pair(
            pc, fa, sa,
            detail::MakeTupleIndices<sizeof...(A1)>(),
            detail::MakeTupleIndices<sizeof...(A2)>()
        )
    {}

    Pair &operator=(Pair const &v) {
        first = v.first;
        second = v.second;
        return *this;
    }

    template<typename TT, typename UU>
    Pair &operator=(Pair<TT, UU> const &v) {
        first = v.first;
        second = v.second;
        return *this;
    }

    Pair &operator=(Pair &&v) noexcept(
        IsNothrowMoveAssignable<T> && IsNothrowMoveAssignable<U>
    ) {
        first = std::move(v.first);
        second = std::move(v.second);
        return *this;
    }

    template<typename TT, typename UU>
    Pair &operator=(Pair<TT, UU> &&v) {
        first = std::forward<TT>(v.first);
        second = std::forward<UU>(v.second);
        return *this;
    }

    void swap(Pair &v) noexcept(
        noexcept(detail::swap_adl(first, v.first)) &&
        noexcept(detail::swap_adl(second, v.second))
    ) {
        detail::swap_adl(first, v.first);
        detail::swap_adl(second, v.second);
    }

private:
    template<typename ...A1, typename ...A2, Size ...I1, Size ...I2>
    Pair(
        PiecewiseConstruct, Tuple<A1...> &fa, Tuple<A2...> &sa,
        detail::TupleIndices<I1...>, detail::TupleIndices<I2...>
    );
};

template<typename T>
struct ReferenceWrapper;

namespace detail {
    template<typename T>
    struct MakePairRetBase {
        using Type = T;
    };

    template<typename T>
    struct MakePairRetBase<ReferenceWrapper<T>> {
        using Type = T &;
    };

    template<typename T>
    struct MakePairRet {
        using Type = typename detail::MakePairRetBase<Decay<T>>::Type;
    };
} /* namespace detail */

template<typename T, typename U>
inline Pair<
    typename detail::MakePairRet<T>::Type, typename detail::MakePairRet<U>::Type
> make_pair(T &&a, U &&b) {
    return Pair<
        typename detail::MakePairRet<T>::Type,
        typename detail::MakePairRet<U>::Type
    >(std::forward<T>(a), std::forward<U>(b));
}

template<typename T, typename U>
inline constexpr bool operator==(Pair<T, U> const &x, Pair<T, U> const &y) {
    return (x.first == y.first) && (x.second == y.second);
}

template<typename T, typename U>
inline constexpr bool operator!=(Pair<T, U> const &x, Pair<T, U> const &y) {
    return (x.first != y.first) || (x.second != y.second);
}

template<typename T, typename U>
inline constexpr bool operator<(Pair<T, U> const &x, Pair<T, U> const &y) {
    return (x.first < y.first)
        ? true
        : ((y.first < x.first)
            ? false
            : ((x.second < y.second)
                ? true
                : false));
}

template<typename T, typename U>
inline constexpr bool operator>(Pair<T, U> const &x, Pair<T, U> const &y) {
    return (y < x);
}

template<typename T, typename U>
inline constexpr bool operator<=(Pair<T, U> const &x, Pair<T, U> const &y) {
    return !(y < x);
}

template<typename T, typename U>
inline constexpr bool operator>=(Pair<T, U> const &x, Pair<T, U> const &y) {
    return !(x < y);
}

template<typename T, typename U>
constexpr Size TupleSize<Pair<T, U>> = 2;

template<typename T, typename U>
struct TupleElementBase<0, Pair<T, U>> {
    using Type = T;
};

template<typename T, typename U>
struct TupleElementBase<1, Pair<T, U>> {
    using Type = U;
};

namespace detail {
    template<Size>
    struct GetPair;

    template<>
    struct GetPair<0> {
        template<typename T, typename U>
        static T &get(Pair<T, U> &p) { return p.first; }
        template<typename T, typename U>
        static T const &get(Pair<T, U> const &p) { return p.first; }
        template<typename T, typename U>
        static T &&get(Pair<T, U> &&p) { return std::forward<T>(p.first); }
        template<typename T, typename U>
        static T const &&get(Pair<T, U> const &&p) {
            return std::forward<T const>(p.first);
        }
    };

    template<>
    struct GetPair<1> {
        template<typename T, typename U>
        static U &get(Pair<T, U> &p) { return p.second; }
        template<typename T, typename U>
        static U const &get(Pair<T, U> const &p) { return p.second; }
        template<typename T, typename U>
        static U &&get(Pair<T, U> &&p) { return std::forward<U>(p.second); }
        template<typename T, typename U>
        static T const &&get(Pair<T, U> const &&p) {
            return std::forward<T const>(p.second);
        }
    };
}

template<Size I, typename T, typename U>
inline TupleElement<I, Pair<T, U>> &get(Pair<T, U> &p) noexcept {
    return detail::GetPair<I>::get(p);
}

template<Size I, typename T, typename U>
inline TupleElement<I, Pair<T, U>> const &get(Pair<T, U> const &p) noexcept {
    return detail::GetPair<I>::get(p);
}

template<Size I, typename T, typename U>
inline TupleElement<I, Pair<T, U>> &&get(Pair<T, U> &&p) noexcept {
    return detail::GetPair<I>::get(std::move(p));
}

template<Size I, typename T, typename U>
inline TupleElement<I, Pair<T, U>> const &&get(Pair<T, U> const &&p) noexcept {
    return detail::GetPair<I>::get(std::move(p));
}

namespace detail {
    template<typename T, typename U,
        bool = IsSame<RemoveCv<T>, RemoveCv<U>>,
        bool = IsEmpty<T>, bool = IsEmpty<U>
    >
    constexpr Size CompressedPairSwitch = detail::Undefined<T>();

    /* neither empty */
    template<typename T, typename U, bool Same>
    constexpr Size CompressedPairSwitch<T, U, Same, false, false> = 0;

    /* first empty */
    template<typename T, typename U, bool Same>
    constexpr Size CompressedPairSwitch<T, U, Same, true, false> = 1;

    /* second empty */
    template<typename T, typename U, bool Same>
    constexpr Size CompressedPairSwitch<T, U, Same, false, true> = 2;

    /* both empty, not the same */
    template<typename T, typename U>
    constexpr Size CompressedPairSwitch<T, U, false, true, true> = 3;

    /* both empty and same */
    template<typename T, typename U>
    constexpr Size CompressedPairSwitch<T, U, true, true, true> = 1;

    template<typename T, typename U, Size = CompressedPairSwitch<T, U>>
    struct CompressedPairBase;

    template<typename T, typename U>
    struct CompressedPairBase<T, U, 0> {
        T p_first;
        U p_second;

        template<typename TT, typename UU>
        CompressedPairBase(TT &&a, UU &&b):
            p_first(std::forward<TT>(a)), p_second(std::forward<UU>(b))
        {}

        template<typename ...A1, typename ...A2, Size ...I1, Size ...I2>
        CompressedPairBase(
            PiecewiseConstruct, Tuple<A1...> &fa, Tuple<A2...> &sa,
            detail::TupleIndices<I1...>, detail::TupleIndices<I2...>
        );

        T &first() { return p_first; }
        T const &first() const { return p_first; }

        U &second() { return p_second; }
        U const &second() const { return p_second; }

        void swap(CompressedPairBase &v) {
            swap_adl(p_first, v.p_first);
            swap_adl(p_second, v.p_second);
        }
    };

    template<typename T, typename U>
    struct CompressedPairBase<T, U, 1>: T {
        U p_second;

        template<typename TT, typename UU>
        CompressedPairBase(TT &&a, UU &&b):
            T(std::forward<TT>(a)), p_second(std::forward<UU>(b))
        {}

        template<typename ...A1, typename ...A2, Size ...I1, Size ...I2>
        CompressedPairBase(
            PiecewiseConstruct, Tuple<A1...> &fa, Tuple<A2...> &sa,
            detail::TupleIndices<I1...>, detail::TupleIndices<I2...>
        );

        T &first() { return *this; }
        T const &first() const { return *this; }

        U &second() { return p_second; }
        U const &second() const { return p_second; }

        void swap(CompressedPairBase &v) {
            swap_adl(p_second, v.p_second);
        }
    };

    template<typename T, typename U>
    struct CompressedPairBase<T, U, 2>: U {
        T p_first;

        template<typename TT, typename UU>
        CompressedPairBase(TT &&a, UU &&b):
            U(std::forward<UU>(b)), p_first(std::forward<TT>(a))
        {}

        template<typename ...A1, typename ...A2, Size ...I1, Size ...I2>
        CompressedPairBase(
            PiecewiseConstruct, Tuple<A1...> &fa, Tuple<A2...> &sa,
            detail::TupleIndices<I1...>, detail::TupleIndices<I2...>
        );

        T &first() { return p_first; }
        T const &first() const { return p_first; }

        U &second() { return *this; }
        U const &second() const { return *this; }

        void swap(CompressedPairBase &v) {
            swap_adl(p_first, v.p_first);
        }
    };

    template<typename T, typename U>
    struct CompressedPairBase<T, U, 3>: T, U {
        template<typename TT, typename UU>
        CompressedPairBase(TT &&a, UU &&b):
            T(std::forward<TT>(a)), U(std::forward<UU>(b))
        {}

        template<typename ...A1, typename ...A2, Size ...I1, Size ...I2>
        CompressedPairBase(
            PiecewiseConstruct, Tuple<A1...> &fa, Tuple<A2...> &sa,
            detail::TupleIndices<I1...>, detail::TupleIndices<I2...>
        );

        T &first() { return *this; }
        T const &first() const { return *this; }

        U &second() { return *this; }
        U const &second() const { return *this; }

        void swap(CompressedPairBase &) {}
    };

    template<typename T, typename U>
    struct CompressedPair: CompressedPairBase<T, U> {
        using Base = CompressedPairBase<T, U>;

        template<typename TT, typename UU>
        CompressedPair(TT &&a, UU &&b):
            Base(std::forward<TT>(a), std::forward<UU>(b))
        {}

        template<typename ...A1, typename ...A2>
        CompressedPair(PiecewiseConstruct pc, Tuple<A1...> fa, Tuple<A2...> sa):
            Base(
                pc, fa, sa,
                detail::MakeTupleIndices<sizeof...(A1)>(),
                detail::MakeTupleIndices<sizeof...(A2)>()
            )
        {}

        T &first() { return Base::first(); }
        T const &first() const { return Base::first(); }

        U &second() { return Base::second(); }
        U const &second() const { return Base::second(); }

        void swap(CompressedPair &v) {
            Base::swap(v);
        }
    };
} /* namespace detail */

} /* namespace ostd */

#endif