Reader.hpp

#pragma once
#include <eris/Optimize.hpp>
#include <eris/WrappedPositional.hpp>
#include <eris/Agent.hpp>
#include <eris/Market.hpp>
#include "creativity/Book.hpp"
#include "creativity/BookCopy.hpp" // IWYU pragma: keep
#include "creativity/belief/ProfitStream.hpp"
#include "creativity/belief/Demand.hpp"
#include <vector>
#include <unordered_set>
#include <forward_list>
#include <functional>
#include <map>
#include <unordered_map>
#include <set>
#include <type_traits>

namespace creativity {

class Creativity;

namespace belief { class Profit; }

class Reader : public eris::WrappedPositional<eris::Agent>,
    public virtual eris::interopt::Begin,
    public virtual eris::interopt::OptApply,
    public virtual eris::intraopt::Initialize,
    public virtual eris::intraopt::OptApplyReset
{
    public:
        Reader() = delete; 

        Reader(
                Creativity &creativity,
                const eris::Position &pos
              );

        template <typename Container>
        typename std::enable_if<std::is_base_of<Book, typename Container::value_type::member_type>::value, double>::type
        u(double money, const Container &books) const {
            double u = money - numBooksPenalty(books.size());
            for (auto &book : books) {
                u += uBook(book);
            }
            return u;
        }

        template <typename Container>
        typename std::enable_if<std::is_same<eris::eris_id_t, typename Container::value_type>::value, double>::type
        u(double money, const Container &books) const {
            double u = money - numBooksPenalty(books.size());
            for (auto &book_id : books) {
                u += uBook(simGood<Book>(book_id));
            }
            return u;
        }

        double u(double money, const std::unordered_map<eris::SharedMember<Book>, std::reference_wrapper<BookCopy>> &books) const;

        const double& u() const;

        const double& uLifetime() const;

        const std::unordered_map<eris::SharedMember<Book>, BookCopy>& library() const;

        const std::unordered_map<eris::SharedMember<Book>, std::reference_wrapper<BookCopy>>& newBooks() const;

        const std::set<eris::SharedMember<Book>>& wrote() const;

        virtual double uBook(const eris::SharedMember<Book> &b) const;

        virtual double uBook(const eris::SharedMember<Book> &b, double quality) const;

        virtual double quality(const eris::SharedMember<Book> &b) const;

        void distancePenaltyPolynomial(std::vector<double> coef);

        const std::vector<double>& distancePenaltyPolynomial() const;

        static constexpr std::initializer_list<double> default_distance_penalty_polynomial{0, 0, 3};

        double distancePenalty(double distance) const;

        void numBooksPenaltyPolynomial(std::vector<double> coef);

        const std::vector<double>& numBooksPenaltyPolynomial() const;

        static constexpr std::initializer_list<double> default_num_books_penalty_polynomial{0, 0, 1};

        virtual double numBooksPenalty(unsigned long books) const;

        double creation_shape = 0.0;

        double creation_scale = 10.0;

        double creationQuality(double effort) const;

        double creationEffort(double quality) const;

        static double creationQuality(double shape, double scale, double effort);

        static double creationEffort(double shape, double scale, double effort);

        const belief::Profit& profitBelief() const;
        const belief::Profit& profitExtrapBelief() const;
        bool profitExtrapBeliefDiffers() const;
        const belief::ProfitStream& profitStreamBelief(unsigned int age, bool usable = false) const;

        bool usableBelief(const eris::learning::BayesianLinear &model) const;

        const std::map<unsigned int, belief::ProfitStream>& profitStreamBeliefs() const;

        static const std::vector<unsigned int> profit_stream_ages;

        const belief::Demand& demandBelief() const;

        double piracyCost() const;

        const std::unordered_set<eris::SharedMember<Reader>>& friends() const;

        bool addFriend(eris::SharedMember<Reader> new_pal, bool recurse = true);

        bool removeFriend(const eris::SharedMember<Reader> &old_pal, bool recurse = true);

        void alterUtility(double amount);

        void interBegin() override;

        void interOptimize() override;

        void interApply() override;

        void intraInitialize() override;

        void intraOptimize() override;
        void intraApply() override;
        void intraReset() override;

    protected:
        Creativity &creativity_;

        std::shared_ptr<belief::Profit> profit_belief_, 
            profit_belief_extrap_; 
        belief::Demand demand_belief_; 

        std::map<unsigned int, belief::ProfitStream> profit_stream_beliefs_;

        std::unordered_set<eris::SharedMember<Reader>> friends_;

        void updateBeliefs();

        void updateDemandBelief();

        void updateProfitBelief();

        void updateProfitStreamBelief();

        void registerAuthoredBook(eris::SharedMember<Book> book);
        void registerMarketUpdate(eris::SharedMember<Book> book);
#ifndef DOXYGEN_SHOULD_SEE_THIS
        // The protected register* methods are called from Book:
        friend void Book::added();
        friend void Book::setMarket(eris::SharedMember<BookMarket>);
        friend void Book::weakDepRemoved(eris::SharedMember<eris::Member>, eris::eris_id_t);
#endif

    private:
        std::vector<double> dist_penalty_poly_;
        std::vector<double> nbooks_penalty_poly_;
        std::unordered_map<eris::SharedMember<Book>, BookCopy> library_;
        std::unordered_map<eris::SharedMember<Book>, std::reference_wrapper<BookCopy>> library_new_;

        std::unordered_set<eris::SharedMember<Book>>
            wrote_market_,
            book_cache_,
            book_cache_market_;
        std::unordered_map<eris::SharedMember<Book>, BookCopy::Status> reserved_books_;

        std::set<eris::SharedMember<Book>> wrote_;

        std::forward_list<eris::Market::Reservation> reservations_;
        double reserved_piracy_cost_ = 0.0;

        // Track current and cumulative utility:
        double u_curr_ = 0, u_lifetime_ = 0;

        // Book prices for the upcoming period.  If a book currently on the market isn't in here,
        // or has a negative price, it'll be removed from the market
        std::unordered_map<eris::SharedMember<Book>, double> new_prices_;

        // True in the period in which creation started, false otherwise.
        bool create_starting_ = false;
        int create_countdown_ = -1; // the number of periods remaining until the book is finished; new books can only be initiated when this is -1.
        double create_effort_ = 0, create_quality_ = 0, create_price_ = 0;
        // The author's position at the time of creation; the final position will be this plus noise
        eris::Position create_position_;

};

}