source: ai2020/group5/src/main/java/Group5AcceptanceStrategy.java@ 3

import geniusweb.actions.ActionWithBid;
import geniusweb.actions.Offer;
import geniusweb.boa.BoaState;
import geniusweb.boa.acceptancestrategy.AcceptanceStrategy;
import geniusweb.issuevalue.Bid;
import geniusweb.profile.Profile;
import geniusweb.profile.utilityspace.LinearAdditive;
import geniusweb.actions.Action;

import java.math.BigDecimal;
import java.util.Date;

public class Group5AcceptanceStrategy implements AcceptanceStrategy {
    private LinearAdditive utilspace;

    /**
     * Implements our own acceptance strategy that combines ACnext and ACtime as failsafe.
     *
     * @param bid       The bid that we want to know if it is acceptable or not.
     * @param negoState Current state of the negotiations so far.
     * @return Returns a boolean to indicate whether the current bid is acceptable.
     */
    @Override
    public Boolean isAcceptable(Bid bid, BoaState negoState) {
        // Do not accept if there is no offer
        if (bid == null) {
            return false;
        }

        // The ACtime part of the strategy
        double currenttimeFraction = negoState.getProgress().get(System.currentTimeMillis());

        // Calculate the utility of their bid and our reservation bid.
        BigDecimal bidUtil = getUtilityOfBid(bid, negoState);
        BigDecimal reservationValue;
        if (currenttimeFraction > 0.90) {
            if (utilspace.getReservationBid() == null) {
                return true;
            }
            reservationValue = utilspace.getUtility(utilspace.getReservationBid());
            if (bidUtil.compareTo(reservationValue) > 0) {
                return true;
            }
        }

        //Now implement the ACnext part, so compare the utility of the bid to utility of our next bid.
        Group5BiddingStrategy biddingStrategy = new Group5BiddingStrategy();
        Action nextAction = biddingStrategy.getAction(negoState);
        if (nextAction instanceof ActionWithBid) {
            Bid futureBid = ((ActionWithBid) nextAction).getBid();
            BigDecimal utilOfNextBid = getUtilityOfBid(futureBid, negoState);
            return bidUtil.compareTo(utilOfNextBid) > 0;
        }

        // If it is not better than the bid we are going to do and still have time, then dont accept.
        return false;
    }

    /**
     * Function that calculates the utility of a bid for our profile.
     * @param bid The bid of which we want to know the utility.
     * @param negoState The state in which we want to know the utility.
     * @return a BigDecimal with the utility.
     */
    public BigDecimal getUtilityOfBid(Bid bid, BoaState negoState) {
        Profile newUtilspace = negoState.getProfile();
        if (!newUtilspace.equals(this.utilspace)) {
            this.utilspace = (LinearAdditive) newUtilspace;
        }
        // Calculate the utility of their bid.
        return this.utilspace.getUtility(bid);
    }
}