/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Copyright 2016-2017 Danny Robson <danny@nerdcruft.net>
 */

#ifndef CRUFT_UTIL_RANDOM_HPP
#define CRUFT_UTIL_RANDOM_HPP

#include "coord/traits.hpp"

#include <algorithm>
#include <array>
#include <random>
#include <limits>
#include <type_traits>


namespace util::random {
    template <typename T>
    struct state_size;

    template <
        class UIntType,
        size_t w, size_t n, size_t m, size_t r,
        UIntType a, size_t u, UIntType d, size_t s,
        UIntType b, size_t t,
        UIntType c, size_t l, UIntType f
    > struct state_size<std::mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>> {
        static constexpr auto value = n * sizeof (UIntType);
    };

    template <typename UIntType, UIntType a, UIntType c, UIntType m>
    struct state_size<std::linear_congruential_engine<UIntType,a,c,m>> {
        static constexpr auto value = sizeof (UIntType);
    };

    template <typename T>
    constexpr auto state_size_v = state_size<T>::value;

    ///////////////////////////////////////////////////////////////////////////
    /// return correctly initialised thread-local generator of an unspecified,
    /// but not entirely useless, type. ie, not LCG.
    inline auto&
    generator (void)
    {
        using generator_t = std::default_random_engine;

        static thread_local generator_t gen = [] () {
            std::array<int,state_size_v<generator_t> / 4> seed;
            std::generate (seed.begin (), seed.end (), std::random_device ());

            std::seed_seq seq (seed.begin (), seed.end ());
            return generator_t (seq);
        } ();

        return gen;
    }


    ///////////////////////////////////////////////////////////////////////////
    /// select a value uniformly from the range [lo, hi)
    template <typename T>
    std::enable_if_t<std::is_floating_point_v<T>,T>
    uniform (T lo, T hi)
    {
        return std::uniform_real_distribution<T> { lo, hi } (generator ());
    }


    template <typename T>
    std::enable_if_t<std::is_floating_point_v<T>,T>
    uniform (void)
    {
        return uniform<T> (0, 1);
    }


    ///------------------------------------------------------------------------
    /// select a value uniformly from the range [lo, hi) using a supplied
    /// generator
    template <
        typename T,
        typename GeneratorT,
        typename = std::enable_if_t<std::is_integral_v<T>>
    >
    T
    uniform (T lo, T hi, GeneratorT &&gen)
    {
        return std::uniform_int_distribution<T> { lo, hi } (gen);
    }


    ///------------------------------------------------------------------------
    /// select a value uniformly from the range [lo, hi)
    template <typename T>
    std::enable_if_t<std::is_integral_v<T>,T>
    uniform (T lo, T hi)
    {
        return uniform (lo, hi, generator ());
    }


    //-------------------------------------------------------------------------
    template <typename T>
    std::enable_if_t<std::is_integral_v<T>,T>
    uniform (void)
    {
        return uniform (
            std::numeric_limits<T>::min (),
            std::numeric_limits<T>::max ()
        );
    }


    //-------------------------------------------------------------------------
    template <
        typename T,
        typename = std::enable_if_t<
            is_coord_v<T> && std::is_floating_point_v<typename T::value_type>
        >
    >
    T
    uniform (void)
    {
        T res {};
        std::fill (res.begin (), res.end (), uniform<typename T::value_type> ());
        return res;
    }


    ///////////////////////////////////////////////////////////////////////////
    /// choose a value at random from an array
    template <typename T, size_t N>
    T&
    choose (T (&t)[N])
    {
        std::uniform_int_distribution<size_t> dist (0, N - 1);
        return t[dist (generator ())];
    }
};

#endif