#include <boost/type_traits/is_arithmetic.hpp>
#include <boost/mpl/integral_c.hpp>
#include <boost/static_assert.hpp>

#include <boost/operators.hpp>

#include <limits>
#include <cmath>
#include <stdexcept> // std::domain_error

#include <boost/numeric/conversion/converter_policies.hpp>
#include <boost/numeric/conversion/conversion_traits.hpp>
#include <boost/numeric/conversion/numeric_cast_traits.hpp>
#include <boost/numeric/conversion/bounds.hpp>

#include <boost/math/special_functions/fpclassify.hpp>

#include <iosfwd>

#include <boost/numeric/conversion/cast.hpp>

#include <boost/exception/diagnostic_information.hpp>

#include <boost/test/unit_test.hpp>

#include <iostream>

namespace core {

    namespace mpl = boost::mpl;

    namespace detail {

        template<typename T>
        struct value_holder
        {
            BOOST_STATIC_ASSERT_MSG(boost::is_arithmetic<T>::value, "T must be a fundamental type");

            typedef T                           fundamental_type;
            typedef std::numeric_limits<T>      limits;

            /*constexpr*/ value_holder()
            { }

            template<typename T2>
            /*constexpr*/ value_holder(T2 d) : m_data(d)
            { }

            fundamental_type                    m_data;
        };
    }

    template <class T>
    struct operators
        : boost::less_than_comparable
          <
            T
          , boost::equality_comparable
          <
            T
          , boost::addable
          <
            T
          , boost::subtractable
          <
            T
          , boost::multipliable
          <
            T
          , boost::dividable
          <
            T
          > > > > > >
    { };

    ////////////////////////////////////////////////////////////////////////////
    template<typename T>
    struct intrinsic_type
        : detail::value_holder<T>,
        operators< intrinsic_type<T> >
    {
        typedef detail::value_holder<T>         base;
        typedef typename detail::value_holder<T>::fundamental_type builtin_type;

        typedef intrinsic_type<T>                type;

        // default constructor
        /*constexpr*/ intrinsic_type()
        { }

        // copy constructor
        /*constexpr*/ intrinsic_type(intrinsic_type<T> const& other)
            : base(other.m_data)
        { }

        // copy constructor
        /*constexpr*/ intrinsic_type(detail::value_holder<T> const& other)
            : base(other.m_data)
        { }

        template<typename T2>
        /*constexpr*/ intrinsic_type(T2 d)
            : base(d)
        { }

        builtin_type to_builtin() const {
            return base::m_data;
        }

        builtin_type& to_builtin() {
            return base::m_data;
        }

        bool operator<(intrinsic_type const& rhs) const {
            return to_builtin() < rhs.to_builtin();
        }

        intrinsic_type operator -() const
        {
            return intrinsic_type(-to_builtin());
        }

        bool operator==(intrinsic_type const& rhs) const {
            return to_builtin() == rhs.to_builtin();
        }

        intrinsic_type operator+=(intrinsic_type const& rhs) {
            to_builtin() += rhs.to_builtin();
            return *this;
        }

        intrinsic_type operator-=(intrinsic_type const& rhs) {
            to_builtin() -= rhs.to_builtin();
            return *this;
        }

        intrinsic_type operator*=(intrinsic_type const& rhs) {
            to_builtin() *= rhs.to_builtin();
            return *this;
        }

        intrinsic_type operator/=(intrinsic_type const& rhs) {
            to_builtin() /= rhs.to_builtin();
            return *this;
        }

        template<typename CharT>
        std::basic_ostream<CharT>& print_on(std::basic_ostream<CharT>& os) const {
            os << to_builtin();
            return os;
        }
    };

    ////////////////////////////////////////////////////////////////////////////
    template<typename T>
    struct ceil
    {
        typedef intrinsic_type<T> value_type;

        static inline
            value_type apply(value_type const& value) {
                return std::ceil(value.to_builtin());
        }
    };

    template<typename T>
    struct floor
    {
        typedef intrinsic_type<T> value_type;

        static inline
            value_type apply(value_type const& value) {
                return std::floor(value.to_builtin());
        }
    };

    template<typename T>
    struct trunc
    {
        typedef intrinsic_type<T> value_type;

        static inline
            value_type apply(value_type const& value) {

                return value.to_builtin() < static_cast<typename value_type::fundamental_type>(0)
                    ? std::ceil(value.to_builtin())
                    : std::floor(value.to_builtin());
        }
    };

    template<typename T>
    struct math_round
    {
        typedef intrinsic_type<T> value_type;

        static inline
            value_type apply(value_type const& value) {

                return value.to_builtin() < static_cast<typename value_type::fundamental_type>(0)
                    ? std::ceil( value.to_builtin() - epsilon())
                    : std::floor(value.to_builtin() + epsilon());
        }

        static inline
            typename value_type::fundamental_type epsilon() {
                return static_cast<typename value_type::fundamental_type>(0.5);
        }
    };

    ////////////////////////////////////////////////////////////////////////////
    template<typename CharT, typename T>
    static inline
        std::basic_ostream<CharT>& operator<<(std::basic_ostream<CharT>& os, intrinsic_type<T> const& v) {
            return v.print_on(os);
    }
}


////////////////////////////////////////////////////////////////////////////////
//
// The Numeric Conversion Library *requires* User Defined Numeric Types
// to properly specialize std::numeric_limits<>
namespace std {

    template<typename T>
    struct numeric_limits<core::intrinsic_type<T> >
        : public numeric_limits<typename core::intrinsic_type<T>::fundamental_type>
    {
        typedef core::intrinsic_type<T> this_type;

        static const/*constexpr*/ bool is_specialized = true;

        static /*constexpr*/ this_type (min)() throw() { return (this_type::base::limits::min)(); }
        static /*constexpr*/ this_type (max)() throw() { return (this_type::base::limits::max)(); }
    };
}

////////////////////////////////////////////////////////////////////////////////
//! boost.NumericConversation range checking and overflow policies
namespace core {

    enum range_check_result
    {
        cNonFinite   = 0,
        cInRange     = 1,
        cNegOverflow = 2,
        cPosOverflow = 3
    } ;

    //! Define a custom range checker
    template<typename Traits, typename OverFlowHandler>
    struct range_checker;

    template<typename BuiltInT, typename SourceT, typename OverFlowHandler>
    struct range_checker
        <
            boost::numeric::conversion_traits< core::intrinsic_type<BuiltInT>, SourceT >
          , OverFlowHandler
        >
    {
        typedef boost::numeric::conversion_traits< core::intrinsic_type<BuiltInT>, SourceT > conv_traits;
        typedef typename conv_traits::argument_type argument_type;
        typedef typename conv_traits::source_type S;
        typedef typename conv_traits::target_type T;

        //! Check range of integral types.
        static range_check_result out_of_range(argument_type value)
        {
            if(!boost::math::isfinite(value)) // Neither infinity nor NaN.
                return cNonFinite;
            else if(T(value) > boost::numeric::bounds<T>::highest())
                return cPosOverflow;
            else if(T(value) < boost::numeric::bounds<T>::lowest())
                return cNegOverflow;
            else
                return cInRange;
        }

        static void validate_range(argument_type value)
        {
            BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_bounded);
            OverFlowHandler()(out_of_range(value));
        }
    };

    template<typename BuiltInT, typename TargetT, typename OverFlowHandler>
    struct range_checker
        <
            boost::numeric::conversion_traits< TargetT, core::intrinsic_type<BuiltInT> >
          , OverFlowHandler
        >
    {
        typedef boost::numeric::conversion_traits< TargetT, core::intrinsic_type<BuiltInT> > conv_traits;
        typedef typename conv_traits::argument_type argument_type;
        typedef typename conv_traits::source_type S;
        typedef typename conv_traits::target_type T;

        //! Check range of integral types.
        static range_check_result out_of_range(argument_type value)
        {
            if(!boost::math::isfinite(value.to_builtin())) // Neither infinity nor NaN.
                return cNonFinite;
            else if(value.to_builtin() > boost::numeric::bounds<T>::highest())
                return cPosOverflow;
            else if(value.to_builtin() < boost::numeric::bounds<T>::lowest())
                return cNegOverflow;
            else
                return cInRange;
        }

        static void validate_range(argument_type value)
        {
            BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_bounded);
            OverFlowHandler()(out_of_range(value));
        }
    };

    //! Overflow handler
    struct bad_numeric_cast : virtual boost::exception, virtual std::bad_cast
    {
        virtual const char * what() const throw() {
            return "bad numeric conversion: overflow";
        }
    };

    struct rounding_error : virtual boost::exception, std::domain_error
    {
        rounding_error() : std::domain_error("NaN or Infinity") {}

        virtual const char * what() const throw() {
            return "bad numeric conversion: can not be represented in the target integer type";
        }
    };

    struct negative_overflow : virtual bad_numeric_cast
    {
        virtual const char * what() const throw() {
            return "bad numeric conversion: negative overflow";
        }
    };

    struct positive_overflow : virtual bad_numeric_cast
    {
        virtual const char * what() const throw() {
            return "bad numeric conversion: positive overflow";
        }
    };

    struct overflow_handler
    {
        void operator()(range_check_result result)
        {
            if(result == cNonFinite)
                BOOST_THROW_EXCEPTION(rounding_error());
            else if(result == cNegOverflow)
                BOOST_THROW_EXCEPTION(negative_overflow());
            else if(result == cPosOverflow)
                BOOST_THROW_EXCEPTION(positive_overflow());
        }
    };

    //! Define a rounding policy and specialize on the custom type.
    template<typename SourceT>
    struct Ceil : boost::numeric::Ceil<SourceT> {};

    template<typename T>
    struct Ceil<intrinsic_type<T> >
    {
        typedef mpl::integral_c<
            std::float_round_style, std::round_toward_infinity
        > round_style;

        typedef intrinsic_type<T> value_type;

        static value_type nearbyint(value_type const& value)
        {
            return ceil<T>::apply(value);
        }
    };

    //! Define a rounding policy and specialize on the custom type.
    template<typename SourceT>
    struct Floor: boost::numeric::Trunc<SourceT> {};

    template<typename T>
    struct Floor<intrinsic_type<T> >
    {
        typedef boost::mpl::integral_c<
            std::float_round_style, std::round_toward_neg_infinity
        > round_style;

        typedef intrinsic_type<T> value_type;

        static value_type nearbyint(value_type const& value)
        {
            return floor<T>::apply(value);
        }
    };

    //! Define a rounding policy and specialize on the custom type.
    template<typename SourceT>
    struct Trunc: boost::numeric::Trunc<SourceT> {};

    template<typename T>
    struct Trunc<intrinsic_type<T> >
    {
        typedef boost::mpl::integral_c<
            std::float_round_style, std::round_toward_zero
        > round_style;

        typedef intrinsic_type<T> value_type;

        static value_type nearbyint(value_type const& value)
        {
            return trunc<T>::apply(value);
        }
    };

    //! Define a rounding policy and specialize on the custom type.
    template<typename SourceT>
    struct MathRound: boost::numeric::Trunc<SourceT> {};

    template<typename T>
    struct MathRound<intrinsic_type<T> >
    {
        typedef boost::mpl::integral_c<
            std::float_round_style, std::round_to_nearest
        > round_style;

        typedef intrinsic_type<T> value_type;

        static value_type nearbyint(value_type const& value)
        {
            return math_round<T>::apply(value);
        }
    };


}

namespace boost { namespace numeric {

    //! Define the numeric_cast_traits specializations on the custom type.
    template<typename T, typename SourceT>
    struct numeric_cast_traits<core::intrinsic_type<T>, SourceT>
    {
        typedef SourceT                             source_type;
        typedef core::intrinsic_type<T>             target_type;

        typedef conversion_traits<
            target_type, source_type
        >                                   conv_traits;

        typedef core::overflow_handler              overflow_policy;

        typedef core::range_checker<
            conv_traits,
            overflow_policy
        >                                   range_checking_policy;

        typedef boost::numeric::Trunc<source_type>  rounding_policy;
    };

    template <typename TargetT, typename T>
    struct numeric_cast_traits<TargetT, core::intrinsic_type<T> >
    {
        typedef core::intrinsic_type<T>             source_type;
        typedef TargetT                             target_type;

        typedef conversion_traits<
            target_type,
            source_type
        >                                   conv_traits;

        typedef core::overflow_handler              overflow_policy;

        typedef core::range_checker<
            conv_traits,
            overflow_policy
        >                                   range_checking_policy;

        typedef core::MathRound<source_type>        rounding_policy;
    };

    //! Define the conversion from the custom type to built-in types and vice-versa.
    template<typename TargetT, typename T>
    struct raw_converter<conversion_traits<TargetT, core::intrinsic_type<T> > >
    {
        typedef core::intrinsic_type<T>             source_type;
        typedef TargetT                             target_type;

        static target_type low_level_convert(source_type const& value)
        {
            return static_cast<target_type>(value.to_builtin());
        }
    };

    template<typename T, typename SourceT>
    struct raw_converter<conversion_traits<core::intrinsic_type<T>, SourceT> >
    {
        typedef SourceT                             source_type;
        typedef core::intrinsic_type<T>             target_type;

        static target_type low_level_convert(source_type const& value)
        {
            return value;
        }
    };
}}

////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE(TestUDTNumericCast)
{
    typedef core::intrinsic_type<int> my_type;

    try {
        {
            double z = (std::numeric_limits<double>::max)();
            z *= std::numeric_limits<double>::epsilon();
            std::cout << z << std::endl;
            std::cout << boost::numeric_cast<double>(z) << '\n';
        }
        {
            typedef core::intrinsic_type<double> my_type;

            my_type x(1.499);
            my_type y(1.500);

            std::cout << x << "->" << boost::numeric_cast<int>(x) << '\n';
            std::cout << y << "->" << boost::numeric_cast<int>(y) << '\n';
        }
        {
            typedef core::intrinsic_type<double> my_type;

            const int x = 42;

            my_type y = boost::numeric_cast<my_type>(x);
            BOOST_CHECK_CLOSE(y.to_builtin(), 42., 1e-5);
        }

    }
    catch(core::positive_overflow& e) {
        std::cerr << "CORE: " << boost::diagnostic_information(e) << std::endl;
    }
    catch(boost::numeric::positive_overflow& e) {
        std::cerr << "Boost.Numeric: " << e.what() << std::endl;
    }
    catch(boost::exception& e) {
        std::cerr << "Boost: " << boost::diagnostic_information(e) << std::endl;
    }
    catch(std::exception& e) {
        std::cerr << "STD: " << e.what() << std::endl;
    }
}