/*
  Copyright (c) 2020 Equinor ASA

  This file is part of the Open Porous Media project (OPM).

  OPM is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  OPM is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef OPM_OUTPUT_DATA_GUIDERATEVALUE_HPP
#define OPM_OUTPUT_DATA_GUIDERATEVALUE_HPP

#include <array>
#include <bitset>
#include <cstddef>
#include <stdexcept>
#include <string>
#include <opm/json/JsonObject.hpp>

namespace Opm { namespace data {

    class GuideRateValue {
    public:
        enum class Item : std::size_t {
            Oil, Gas, Water, ResV,

            // -- Must be last enumerator --
            NumItems,
        };

        void clear()
        {
            this->mask_.reset();
            this->value_.fill(0.0);
        }

        constexpr bool has(const Item p) const
        {
            const auto i = this->index(p);

            return (i < Size) && this->mask_[i];
        }

        bool operator==(const GuideRateValue& vec) const
        {
            return (this->mask_  == vec.mask_)
                && (this->value_ == vec.value_);
        }

        double get(const Item p) const
        {
            if (! this->has(p)) {
                throw std::invalid_argument {
                    "Request for Unset Item Value for " + this->itemName(p)
                };
            }

            return this->value_[ this->index(p) ];
        }

        GuideRateValue& set(const Item p, const double value)
        {
            const auto i = this->index(p);

            if (i >= Size) {
                throw std::invalid_argument {
                    "Cannot Assign Item Value for Unsupported Item '"
                    + this->itemName(p) + '\''
                };
            }

            this->mask_.set(i);
            this->value_[i] = value;

            return *this;
        }

        GuideRateValue& operator+=(const GuideRateValue& rhs)
        {
            for (auto i = 0*Size; i < Size; ++i) {
                if (rhs.mask_[i]) {
                    this->mask_.set(i);
                    this->value_[i] += rhs.value_[i];
                }
            }

            return *this;
        }

        template <class MessageBufferType>
        void write(MessageBufferType& buffer) const
        {
            auto maskrep = this->mask_.to_ullong();
            buffer.write(maskrep);

            for (const auto& x : this->value_) {
                buffer.write(x);
            }
        }

        template <class MessageBufferType>
        void read(MessageBufferType& buffer)
        {
            this->clear();

            {
                auto mask = 0ull;
                buffer.read(mask);

                this->mask_ = std::bitset<Size>(mask);
            }

            for (auto& x : this->value_) {
                buffer.read(x);
            }
        }

        void init_json(Json::JsonObject& json_data) const {
            for (const auto& item : {Item::Oil, Item::Gas, Item::Water, Item::ResV}) {
                if (this->has(item))
                    json_data.add_item(this->itemName(item), this->get(item));
            }
        }

        template<class Serializer>
        void serializeOp(Serializer& serializer)
        {
           serializer(mask_);
           serializer(value_);
        }

        static GuideRateValue serializationTestObject()
        {
            GuideRateValue val;
            val.mask_ = std::bitset<Size>(1234);
            val.value_ = {1,2,3,4};

            return val;
        }

    private:
        enum { Size = static_cast<std::size_t>(Item::NumItems) };

        std::bitset<Size>        mask_{};
        std::array<double, Size> value_{};

        constexpr std::size_t index(const Item p) const noexcept
        {
            return static_cast<std::size_t>(p);
        }

        std::string itemName(const Item p) const
        {
            switch (p) {
            case Item::Oil:   return "Oil";
            case Item::Gas:   return "Gas";
            case Item::Water: return "Water";
            case Item::ResV:  return "ResV";

            case Item::NumItems:
                return "Out of bounds (NumItems)";
            }

            return "Unknown (" + std::to_string(this->index(p)) + ')';
        }
    };

}} // namespace Opm::data

#endif // OPM_OUTPUT_DATA_GUIDERATEVALUE_HPP