common/auction.h

/* auction.h                                                       -*- C++ -*-
   Jeremy Barnes, 6 April 2011
   Copyright (c) 2011 Datacratic.  All rights reserved.

   Base class for agents to deal with an auction.
*/

#pragma once

#include "rtbkit/common/bid_request.h"
#include "rtbkit/common/currency.h"
#include "rtbkit/common/account_key.h"
#include "rtbkit/common/augmentation.h"
#include <boost/function.hpp>
#include <boost/enable_shared_from_this.hpp>
#include "soa/jsoncpp/json.h"
#include "soa/types/date.h"
#include "jml/arch/atomic_ops.h"
#include "jml/arch/exception.h"
#include "jml/utils/compact_vector.h"
#include "jml/db/persistent_fwd.h"
#include "rtbkit/common/json_holder.h"


namespace RTBKIT {

struct AgentConfig;
struct ExchangeConnector;


/*****************************************************************************/
/* AUCTION                                                                   */
/*****************************************************************************/

struct Auction : public std::enable_shared_from_this<Auction> {
    
    typedef boost::function<void (std::shared_ptr<Auction> auction)>
        HandleAuction;

    Auction();
    
    Auction(ExchangeConnector * exchangeConnector,
            HandleAuction handleAuction,
            std::shared_ptr<BidRequest> request,
            const std::string & requestStr,
            const std::string & requestStrFormat,
            Date start,
            Date expiry);
    
    ~Auction();

    bool isZombie;  

    Date start;
    Date expiry;
    Date lossAssumed;

    // Debug
    Date doneParsing;
    Date inPrepro, outOfPrepro;
    Date doneAugmenting;
    Date inStartBidding;

    Id id;
    std::shared_ptr<BidRequest>  request;
    std::string requestStr;  
    std::string requestStrFormat;  
    std::string requestSerialized; 

    AugmentationList augmentations; 
    AgentAugmentations agentAugmentations; 

    double timeAvailable(Date now = Date::now()) const;

    double timeUsed(Date now = Date::now()) const;

    bool tooLate();

    struct Price {
        Price(Amount maxPrice = Amount(), float priority = 0.0)
            : maxPrice(maxPrice), priority(priority)
        {
        }

        Amount maxPrice;      
        float  priority;       

        Json::Value toJson() const;
        std::string toJsonStr() const;
        static Price fromJson(const Json::Value&);
    };

    static const Price NONE;

    enum WinLoss {
        PENDING,    
        WIN,        
        LOSS,       
        TOOLATE,    
        INVALID,    
    };

    struct Response {
        Response(Price price = NONE,
                 int tagId = -1,
                 const AccountKey & account = AccountKey(),
                 bool test = true,
                 std::string agent = "",
                 std::string bidData = "",
                 std::string meta = "null",
                 std::shared_ptr<const AgentConfig> agentConfig
                     = std::shared_ptr<const AgentConfig>(),
                 const SegmentList& visitChannels = SegmentList(),
                 int agentCreativeIndex = -1)
            : price(price), tagId(tagId),
              account(account),
              test(test), agent(agent),
              bidData(bidData), meta(meta), creativeId(-1),
              localStatus(INVALID),
              agentConfig(agentConfig),
              visitChannels(visitChannels),
              agentCreativeIndex(agentCreativeIndex)
        {
        }

        // Information about the actual bid
        Price price;           
        int tagId;             
        AccountKey account;    
        bool test;             

        // Information about the agent who did the bidding
        std::string agent;    
        std::string bidData;   
        std::string meta;      


        int creativeId;          
        std::string creativeName; 

        // Information about the status of the bid (what happened to it)
        WinLoss localStatus;   

        std::shared_ptr<const AgentConfig> agentConfig;

        // List of channels for which we subscribe to post impression visit
        // events.
        SegmentList visitChannels;

        int agentCreativeIndex;

        static std::string print(WinLoss wl);
        Json::Value toJson() const;
        std::string toJsonStr() const;

        void serialize(ML::DB::Store_Writer & store) const;
        void reconstitute(ML::DB::Store_Reader & store);

        bool valid() const;
    };

    WinLoss setResponse(int spotNum, Response newResponse);

    void addDataSources(const std::set<std::string> & sources);
    const std::set<std::string> & getDataSources() const;

    std::string status() const;

    bool setError(const std::string & error, const std::string & details = "");

    bool finish();

    size_t numSpots() const
    {
        return request->imp.size();
    }

    Json::Value getResponseJson(int spotNum) const;
    
    Json::Value getResponsesJson() const;

    const std::vector<std::vector<Response> > & getResponses() const;

    ExchangeConnector * exchangeConnector; 
    HandleAuction handleAuction;   

    struct Data {
        Data()
            : tooLate(false), oldData(0)
        {
            responses.reserve(8);
        }

        Data(int numSpots)
            : tooLate(false), responses(numSpots), oldData(0)
        {
        }

        bool hasValidResponse(int spotNum) const
        {
            if (spotNum >= responses.size())
                throw ML::Exception("invalid spot number");
            return !responses[spotNum].empty();
        }
        
        bool hasError() const
        {
            return !error.empty();
        }

        const Response & winningResponse(int spotNum) const
        {
            if (spotNum >= responses.size())
                throw ML::Exception("invalid spot number");
            if (responses[spotNum].empty())
                throw ML::Exception("empty responses");
            return responses[spotNum][0];
        }

        bool tooLate;
        std::vector<std::vector<Response> > responses;  
        std::set<std::string> dataSources; // data sources used to make the bid decissions.
        Data * oldData;  
        std::string error, details;
    };

    const Data * getCurrentData() const
    {
        return data;
    }

private:
    Data * data;

public:
    static long long created;
    static long long destroyed;
};

} // namespace RTBKIT