/** @file scaled_unit.hpp
 *
 *  Author: Roland Conybeare
 **/

#pragma once

#include "width2x.hpp"

namespace xo {
    namespace qty {
        /** @class scaled_unit
         *  @brief Represents the product sqrt(outer_scale_sq) * outer_scale_exact * nat_unit
         **/
        template < typename Int,
                   typename OuterScale = ratio::ratio<Int> >
        struct scaled_unit {
            using ratio_int_type = typename natural_unit<Int>::ratio_int_type;

            constexpr scaled_unit(const natural_unit<Int> & nat_unit,
                                  OuterScale outer_scale_factor,
                                  double outer_scale_sq)
                : natural_unit_{nat_unit},
                  outer_scale_factor_{outer_scale_factor},
                  outer_scale_sq_{outer_scale_sq}
                {}

            constexpr bool is_scaled_unit_type() const { return true; }

            constexpr scaled_unit reciprocal() const {
                return scaled_unit(natural_unit_.reciprocal(),
                                   1 / outer_scale_factor_,
                                   1.0 / outer_scale_sq_);
            }

            /** @brief true iff scaled unit can be faithfully represented by a @ref natural_unit
             *
             * @see natural_unit::is_natural
             **/
            constexpr bool is_natural() const {
                return (outer_scale_factor_ == OuterScale(1) && (outer_scale_sq_ == 1.0));
            }

            constexpr bool is_dimensionless() const { return natural_unit_.is_dimensionless(); }
            constexpr std::size_t n_bpu() const { return natural_unit_.n_bpu(); }

            constexpr bpu<Int> & operator[](std::size_t i) { return natural_unit_[i]; }
            constexpr const bpu<Int> & operator[](std::size_t i) const { return natural_unit_[i]; }

        public: /* need public members so that a scaled_unit instance can be a non-type template parameter (a structural type) */

            natural_unit<Int> natural_unit_;
            OuterScale outer_scale_factor_;
            double outer_scale_sq_;
        };

        namespace detail {
            template <typename Int>
            constexpr auto make_unit_rescale_result(const natural_unit<Int> & bpuv) {
                return scaled_unit<Int>(bpuv,
                                        ratio::ratio<Int>(1, 1),
                                        1.0);
            }
        }

        namespace su {
            constexpr auto picogram = detail::make_unit_rescale_result<std::int64_t>(nu::picogram);
            constexpr auto nanogram = detail::make_unit_rescale_result<std::int64_t>(nu::nanogram);
            constexpr auto microgram = detail::make_unit_rescale_result<std::int64_t>(nu::microgram);
            constexpr auto milligram = detail::make_unit_rescale_result<std::int64_t>(nu::milligram);
            constexpr auto gram = detail::make_unit_rescale_result<std::int64_t>(nu::gram);
            constexpr auto kilogram = detail::make_unit_rescale_result<std::int64_t>(nu::kilogram);
            constexpr auto tonne = detail::make_unit_rescale_result<std::int64_t>(nu::tonne);
            constexpr auto kilotonne = detail::make_unit_rescale_result<std::int64_t>(nu::kilotonne);
            constexpr auto megatonne = detail::make_unit_rescale_result<std::int64_t>(nu::megatonne);
            constexpr auto gigatonne = detail::make_unit_rescale_result<std::int64_t>(nu::gigatonne);

            constexpr auto picometer = detail::make_unit_rescale_result<std::int64_t>(nu::picometer);
            constexpr auto nanometer = detail::make_unit_rescale_result<std::int64_t>(nu::nanometer);
            constexpr auto micrometer = detail::make_unit_rescale_result<std::int64_t>(nu::micrometer);
            constexpr auto millimeter = detail::make_unit_rescale_result<std::int64_t>(nu::millimeter);
            constexpr auto meter = detail::make_unit_rescale_result<std::int64_t>(nu::meter);
            constexpr auto kilometer = detail::make_unit_rescale_result<std::int64_t>(nu::kilometer);
            constexpr auto megameter = detail::make_unit_rescale_result<std::int64_t>(nu::megameter);
            constexpr auto gigameter = detail::make_unit_rescale_result<std::int64_t>(nu::gigameter);

            constexpr auto lightsecond = detail::make_unit_rescale_result<std::int64_t>(nu::lightsecond);
            constexpr auto astronomicalunit = detail::make_unit_rescale_result<std::int64_t>(nu::astronomicalunit);

            constexpr auto inch = detail::make_unit_rescale_result<std::int64_t>(nu::inch);
            constexpr auto foot = detail::make_unit_rescale_result<std::int64_t>(nu::foot);
            constexpr auto yard = detail::make_unit_rescale_result<std::int64_t>(nu::yard);
            constexpr auto mile = detail::make_unit_rescale_result<std::int64_t>(nu::mile);

            constexpr auto picosecond = detail::make_unit_rescale_result<std::int64_t>(nu::picosecond);
            constexpr auto nanosecond = detail::make_unit_rescale_result<std::int64_t>(nu::nanosecond);
            constexpr auto microsecond = detail::make_unit_rescale_result<std::int64_t>(nu::microsecond);
            constexpr auto millisecond = detail::make_unit_rescale_result<std::int64_t>(nu::millisecond);
            constexpr auto second = detail::make_unit_rescale_result<std::int64_t>(nu::second);
            constexpr auto minute = detail::make_unit_rescale_result<std::int64_t>(nu::minute);
            constexpr auto hour = detail::make_unit_rescale_result<std::int64_t>(nu::hour);
            constexpr auto day = detail::make_unit_rescale_result<std::int64_t>(nu::day);
            constexpr auto week = detail::make_unit_rescale_result<std::int64_t>(nu::week);
            constexpr auto month = detail::make_unit_rescale_result<std::int64_t>(nu::month);
            constexpr auto year = detail::make_unit_rescale_result<std::int64_t>(nu::year);
            constexpr auto year250 = detail::make_unit_rescale_result<std::int64_t>(nu::year250);
            constexpr auto year360 = detail::make_unit_rescale_result<std::int64_t>(nu::year360);
            constexpr auto year365 = detail::make_unit_rescale_result<std::int64_t>(nu::year365);

            constexpr auto volatility_30d = detail::make_unit_rescale_result<std::int64_t>(nu::volatility_30d);
            constexpr auto volatility_250d = detail::make_unit_rescale_result<std::int64_t>(nu::volatility_250d);
            constexpr auto volatility_360d = detail::make_unit_rescale_result<std::int64_t>(nu::volatility_360d);
            constexpr auto volatility_365d = detail::make_unit_rescale_result<std::int64_t>(nu::volatility_365d);
        }

        namespace detail {
            template <typename Int,
                      typename Int2x = width2x<Int>,
                      typename OuterScale = ratio::ratio<Int2x>>
            constexpr
            scaled_unit<Int, OuterScale>
            su_product(const natural_unit<Int> & lhs_bpu_array,
                       const natural_unit<Int> & rhs_bpu_array)
            {
                natural_unit<Int2x> prod = lhs_bpu_array.template to_repr<Int2x>();

                /* accumulate product of scalefactors spun off by rescaling
                 * any basis-units in rhs_bpu_array that conflict with the same dimension
                 * in lh_bpu_array
                 */
                auto sfr = (detail::outer_scalefactor_result<Int2x>
                            (OuterScale(1) /*outer_scale_factor*/,
                             1.0 /*outer_scale_sq*/));

                for (std::size_t i = 0; i < rhs_bpu_array.n_bpu(); ++i) {
                    auto sfr2 = nu_product_inplace<Int2x, OuterScale>(&prod,
                                                                      rhs_bpu_array[i].template to_repr<Int2x>());

                    sfr.outer_scale_factor_ = sfr.outer_scale_factor_ * sfr2.outer_scale_factor_;
                    sfr.outer_scale_sq_ *= sfr2.outer_scale_sq_;
                }

                return scaled_unit<Int, OuterScale>(prod.template to_repr<Int>(),
                                                    sfr.outer_scale_factor_,
                                                    sfr.outer_scale_sq_);
            }

            /* use Int2x to accumulate scalefactor
             */
            template < typename Int,
                       typename Int2x = width2x<Int>,
                       typename OuterScale = ratio::ratio<Int2x> >
            constexpr
            scaled_unit<Int, OuterScale>
            su_ratio(const natural_unit<Int> & nu_lhs,
                     const natural_unit<Int> & nu_rhs)
            {
                natural_unit<Int2x> ratio = nu_lhs.template to_repr<Int2x>();

                /* accumulate product of scalefactors spun off by rescaling
                 * any basis-units in rhs_bpu_array that conflict with the same dimension
                 * in lh_bpu_array
                 */
                auto sfr = (detail::outer_scalefactor_result<Int2x, OuterScale>
                            (OuterScale(1) /*outer_scale_factor*/,
                             1.0 /*outer_scale_sq*/));

                for (std::size_t i = 0; i < nu_rhs.n_bpu(); ++i) {
                    auto sfr2 = nu_ratio_inplace<Int2x, OuterScale>(&ratio,
                                                                    nu_rhs[i].template to_repr<Int2x>());

                    /* note: nu_ratio_inplace() reports multiplicative outer scaling factors,
                     *       so multiply is correct here
                     */
                    sfr.outer_scale_factor_ = (sfr.outer_scale_factor_
                                               * sfr2.outer_scale_factor_);
                    sfr.outer_scale_sq_ *= sfr2.outer_scale_sq_;
                }

                return scaled_unit<Int, OuterScale>(ratio.template to_repr<Int>(),
                                                    sfr.outer_scale_factor_,
                                                    sfr.outer_scale_sq_);
            }
        }

        template <typename Int,
                  typename Int2x = detail::width2x_t<Int>>
        inline constexpr scaled_unit<Int>
        operator* (const scaled_unit<Int> & x_unit,
                   const scaled_unit<Int> & y_unit)
        {
            auto rr = detail::su_product<Int, Int2x>(x_unit.natural_unit_,
                                                     y_unit.natural_unit_);

            return (scaled_unit<Int>
                    (rr.natural_unit_,
                     (ratio::ratio<Int2x>(rr.outer_scale_factor_)
                      * ratio::ratio<Int2x>(x_unit.outer_scale_factor_)
                      * ratio::ratio<Int2x>(y_unit.outer_scale_factor_)),
                     rr.outer_scale_sq_ * x_unit.outer_scale_sq_ * y_unit.outer_scale_sq_));
        }

        template <typename Int,
                  typename Int2x = detail::width2x_t<Int>>
        inline constexpr scaled_unit<Int>
        operator* (const scaled_unit<Int> & x_unit,
                   const natural_unit<Int> & y_unit)
        {
            auto y_unit2 = detail::make_unit_rescale_result<Int>(y_unit);

            return x_unit * y_unit2;
        }

        template <typename Int,
                  typename Int2x = detail::width2x_t<Int>>
        inline constexpr scaled_unit<Int>
        operator* (const natural_unit<Int> & x_unit,
                   const scaled_unit<Int> & y_unit)
        {
            auto x_unit2 = detail::make_unit_rescale_result<Int>(x_unit);

            return x_unit2 * y_unit;
        }

        template <typename Int,
                  typename Int2x = detail::width2x_t<Int>>
        inline constexpr scaled_unit<Int>
        operator/ (const scaled_unit<Int> & x_unit,
                   const scaled_unit<Int> & y_unit)
        {
            auto rr = detail::su_ratio<Int, Int2x>(x_unit.natural_unit_,
                                                   y_unit.natural_unit_);

            return (scaled_unit<Int>
                    (rr.natural_unit_,
                     (ratio::ratio<Int2x>(rr.outer_scale_factor_)
                      * ratio::ratio<Int2x>(x_unit.outer_scale_factor_)
                      * ratio::ratio<Int2x>(y_unit.outer_scale_factor_)),
                     rr.outer_scale_sq_ * x_unit.outer_scale_sq_ * y_unit.outer_scale_sq_));
        }

        template <typename Int,
                  typename Int2x = detail::width2x_t<Int>>
        inline constexpr scaled_unit<Int>
        operator/ (const scaled_unit<Int> & x_unit,
                   const natural_unit<Int> & y_unit)
        {
            auto y_unit2 = detail::make_unit_rescale_result<Int>(y_unit);

            return x_unit / y_unit2;
        }

        template <typename Int,
                  typename Int2x = detail::width2x_t<Int>>
        inline constexpr scaled_unit<Int>
        operator/ (const natural_unit<Int> & x_unit,
                   const scaled_unit<Int> & y_unit)
        {
            auto x_unit2 = detail::make_unit_rescale_result<Int>(x_unit);

            return x_unit2 / y_unit;
        }
    } /*namespace qty*/
} /*namespace xo*/

/** end scaled_unit.hpp **/