source: src/main/java/agents/anac/y2019/ibasic/boacomponents/IBasicAS.java@ 201

package agents.anac.y2019.ibasic.boacomponents;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import genius.core.Bid;
import genius.core.boaframework.AcceptanceStrategy;
import genius.core.boaframework.Actions;
import genius.core.boaframework.NegotiationSession;
import genius.core.boaframework.OfferingStrategy;
import genius.core.boaframework.OpponentModel;
import genius.core.boaframework.SortedOutcomeSpace;
import genius.core.uncertainty.UserModel;
import genius.core.utility.AbstractUtilitySpace;


public class IBasicAS extends AcceptanceStrategy {
        
        //Our own model of the opponent
        IBasicOM opponentModel;
        
        //The Utility Space used to evaluate the utility of a received bid. 
        AbstractUtilitySpace utilSpace;
        Boolean first = false; 
        UserModel usermodel; 
        SortedOutcomeSpace outcomespace;
        
        //The reservation value and the minimum threshold we eventually use in the optimal stopping algrithm. 
        double reservationValue; 
        double minThreshold;
        
        //We keep track of the best bid of the opponent, worse bid of the opponent (according to our own utility) and the current round. 
        double lowestBidYet = 1;

        //We keep track of the history of the opponents bids. 
        List<Bid> opponentHistory = new ArrayList<>();
        
        //We override the init method in order to initialize the usermodel and bidOrder at the start of the session. 
        @Override
        public void init(NegotiationSession negotiationSession, OfferingStrategy offeringStrategy,
                        OpponentModel opponentModel, Map<String, Double> parameters) throws Exception {
                super.init(negotiationSession, parameters);
                
                //Sets the utility space and determines the reservation value. 
                this.utilSpace = negotiationSession.getUtilitySpace();
                reservationValue = utilSpace.getReservationValueUndiscounted();
                usermodel = negotiationSession.getUserModel();
                
                this.opponentModel = (IBasicOM)  opponentModel;
                //If we operate under preference uncertainty, we switch to a corresponding utility space. 
                if (negotiationSession.getUserModel() != null) {
                        this.utilSpace = IBasicPU.createUtilitySpace(negotiationSession.getDomain(), negotiationSession.getUserModel());}
                
                this.outcomespace = new SortedOutcomeSpace(utilSpace);
                negotiationSession.setOutcomeSpace(this.outcomespace);
        }
        
        //This method determines the acceptability of the received bid. 
        @Override
        public Actions determineAcceptability() 
        {
                //First it saves the last received bid of the opponent and the last bid we placed. 
                Bid receivedBid = negotiationSession.getOpponentBidHistory().getLastBid();
                
                //We save the last utility of the opponent
                double lastOpponentBidUtil = this.utilSpace.getUtility(receivedBid);
                
                //We get the time that the session is playing in. 
                double totalTime = negotiationSession.getTimeline().getTotalTime();
                double currentRound = negotiationSession.getTimeline().getCurrentTime();
                
                //The first thing we check, is that if this utility is 1 or if we are in the final round, we accept straight away. 
                if(lastOpponentBidUtil == 1) {
                        return Actions.Accept;
                }
                
                //In case that there are no placed bids, we know that we have to give the first bid, which we do by rejecting. 
                if (receivedBid == null) {
                        first = true;
                        return Actions.Reject;
                        }

                //If we have less than 30 bids in our bid ranking, we use a simple heuristic instead of the cplex method. 
                if(usermodel != null) {
                        if (usermodel.getBidRanking().getSize() < 30)
                        {
                                if (currentRound <= totalTime-2)
                                {
                                        if (receivedBid == negotiationSession.getUserModel().getBidRanking().getBidOrder().get(negotiationSession.getUserModel().getBidRanking().getBidOrder().size()-1)) {
                                                return Actions.Accept;
                                        }
                                }
                                else if (currentRound >= negotiationSession.getTimeline().getTotalTime()-1) {
                                        return Actions.Accept;
                                }
                                return Actions.Reject;
                        }
                }
                
                //We keep track of the worse bid until now. This is used later in this method to determine the optimal stopping interval. 
                if (lastOpponentBidUtil < lowestBidYet) {
                        lowestBidYet = lastOpponentBidUtil;
                }
                
                //If we are in the final round, we accept all bids above our reservation value or else we break.
                if (currentRound >= totalTime-1 && lastOpponentBidUtil > reservationValue) {

                        return Actions.Accept;
                }
                else if (currentRound >= totalTime-1 && lastOpponentBidUtil <= reservationValue) {
                        return Actions.Break;
                }
                
                //If we are in the final 3 rounds, we use our optimal stopping criteria to determine our minimal acceptance threshold.
                else if (currentRound >= totalTime-3 && currentRound < totalTime-1)
                {
                        //Either the reservation value or the lowest received bid, which one is the highest, becomes the minimal threshold over which the optimal stopping criteria is calculated. 
                        if (reservationValue > lowestBidYet) {
                                minThreshold = reservationValue;
                        }
                        else {
                                minThreshold = lowestBidYet;
                        }
                        
                        //Optimal Stopping Criteria: For this we perform the optimal stopping criteria between the interval of the bestbid of the opponent and the worse bid of the opponent. 
                        if(lastOpponentBidUtil >= (lowestBidYet + (OptimalStoppingFunction((totalTime - currentRound))*(1 - minThreshold)))) {
                                return Actions.Accept;
                        }
                }
                
                //For the rest of the negotiation session, we use two stages: one where simply have a hard threshold: 93 and one where we follow a curve which is dependent on the concession rate of the opponent
                else if(currentRound < totalTime -3)
                {       
                        //At 60% of the session, we determine the concession rate of the opponent.
                        double concessionrate = 0;
                        if (currentRound == (int) (negotiationSession.getTimeline().getTotalTime() * 0.6)) {
                                concessionrate = -0.04 + (this.opponentModel.EvaluateConsessionOpp()/ 4);
                        }
                        //For the first stage of the session, between 0.0 and 0.6, we accept a hard threshold of nothing less than 0.93 utility
                        if (currentRound <= 0.6*totalTime && lastOpponentBidUtil > 0.93 && lastOpponentBidUtil > reservationValue) {
                                return Actions.Accept;
                        }
                        //For the second stage (before the optimal stopping criteria) we follow the function below.
                        else if (currentRound >= 0.6 *totalTime) {
                                if (lastOpponentBidUtil > reservationValue && lastOpponentBidUtil > (0.93) - ((0.1 + concessionrate) * Math.pow(negotiationSession.getTimeline().getTime(), 7))) {
                                                return Actions.Accept;
                                }
                        }
                }
                return Actions.Reject;
        }
                
        //The optimal stopping method is a recursive method where we receive the amount of rounds that are left and we calculate the optimal stopping threshold for that round. 
        public double OptimalStoppingFunction(double time)
        {
                if (time <= 1) {
                        return 0;
                }
                else {
                        return  0.5 + (0.5 * Math.pow(OptimalStoppingFunction(time-1), 2));
                }
        }
        
        @Override
        public String getName()
        {
                return "IBasicAS";
        }

}