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

import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import geniusweb.actions.Action;
import geniusweb.actions.PartyId;
import geniusweb.boa.BoaState;
import geniusweb.boa.InstantiationFailedException;
import geniusweb.boa.acceptancestrategy.AcceptanceStrategy;
import geniusweb.boa.biddingstrategy.BiddingStrategy;
import geniusweb.inform.Settings;
import geniusweb.issuevalue.Bid;
import geniusweb.opponentmodel.OpponentModel;
import geniusweb.profile.Profile;
import geniusweb.progress.Progress;
import geniusweb.progress.ProgressRounds;
import tudelft.utilities.logging.Reporter;

/**
 * Stores the current state of the negotiation for a {@link Group5Party}, including
 * the state of the opponent models. immutable.
 *
 */
public class Group5BoaState extends BoaState {
    private final Settings settings;
    private final Profile profile;
    private final Progress progress;
    private final Class<? extends OpponentModel> opponentModelClass;
    private final Map<PartyId, OpponentModel> opponentModels;
    private final List<Action> actionHistory;
    private final BiddingStrategy biddingStrategy;
    private final AcceptanceStrategy acceptanceStrategy;
    private final Reporter reporter;

    /**
     * Initial state. Update using with(settings).
     *
     * @param reporter the {@link Reporter} to use for logging
     */
    public Group5BoaState(Reporter reporter) {
        this(null, null, null, null, null, null, Collections.emptyList(),
                Collections.emptyMap(), reporter);
        if (reporter == null) {
            throw new NullPointerException("reporter must be not null");
        }
    }

    /**
     * Internal constructor. Use
     * {@link #with(Settings, BiddingStrategy, AcceptanceStrategy, Class, Reporter)}
     *
     * @param settings      the negoi {@link Settings}
     * @param profile       the {@link Profile} to be used
     * @param progr         the {@link Progress}
     * @param bidstrat      the {@link BiddingStrategy}
     * @param acceptstrat   the {@link AcceptanceStrategy}
     * @param omClass       the class of the {@link OpponentModel}
     * @param actionHistory list of {@link Action}s that have been done in the
     *                      negotiatino (by us and others), first action is the
     *                      oldest.
     * @param oppMods       a map of {@link OpponentModel}s, one for each
     *                      {@link PartyId} encountered in the negotiation
     * @param reporter      the {@link Reporter} that can be used to log
     *                      messages. Should equal {@link Group5Party}'s reporter
     */
    private Group5BoaState(Settings settings, Profile profile, Progress progr,
                     BiddingStrategy bidstrat, AcceptanceStrategy acceptstrat,
                     Class<? extends OpponentModel> omClass, List<Action> actionHistory,
                     Map<PartyId, OpponentModel> oppMods, Reporter reporter) {
        super(reporter);
        this.settings = settings;
        this.profile = profile;
        this.progress = progr;
        this.biddingStrategy = bidstrat;
        this.acceptanceStrategy = acceptstrat;
        this.opponentModelClass = omClass;
        this.actionHistory = actionHistory;
        this.opponentModels = oppMods;
        this.reporter = reporter;
    }

    public Map<PartyId, OpponentModel> getOpponentModels() {
        return opponentModels;
    }

    /**
     * This should be the first update call used.
     *
     * @param newsettings the negoi {@link Settings}
     * @param bidstrat    the {@link BiddingStrategy}
     * @param acceptstrat the {@link AcceptanceStrategy}
     * @param omClass     the class of the {@link OpponentModel}
     * @return initialized BoaState
     */
    public Group5BoaState with(Settings newsettings, BiddingStrategy bidstrat,
                         AcceptanceStrategy acceptstrat,
                         Class<? extends OpponentModel> omClass) {
        if (settings != null)
            throw new IllegalStateException("settings already set");
        if (newsettings == null || omClass == null || bidstrat == null
                || acceptstrat == null || reporter == null)
            throw new NullPointerException(
                    "settings, reporter, bidstrat, acceptstrat, omClass and oModels must be not null");
        return new Group5BoaState(newsettings, null, newsettings.getProgress(),
                bidstrat, acceptstrat, omClass, actionHistory,
                new HashMap<PartyId, OpponentModel>(), reporter);
    }

    public Group5BoaState with(Profile newprofile) {
        return new Group5BoaState(settings, newprofile, progress, biddingStrategy,
                acceptanceStrategy, opponentModelClass, actionHistory,
                opponentModels, reporter);

    }

    /**
     *
     * @return the settings for this negotiation, includes my {@link PartyId},
     *         {@link Parameter}, {@link Profile} etc.
     */
    public Settings getSettings() {
        return settings;
    }

    /**
     *
     * @return the {@link Profile} as fetched from the profiles server, or null
     *         if no profile was received yet.
     */
    public Profile getProfile() {
        return profile;
    }

    /**
     *
     * @param action the action that was done by some participant (possibly us).
     * @return new BoaState that includes action.getBid as last bid (if action
     *         contains a bid), and with updated opponentmodel of that
     *         participant.
     * @throws InstantiationFailedException if one of provided classes can not
     *                                      be instantiated.
     */
    public Group5BoaState with(Action action) throws InstantiationFailedException {
        List<Action> newactions = new ArrayList<Action>(actionHistory);
        newactions.add(action);
        Progress newprogress = progress;
        Map<PartyId, OpponentModel> newmodels = opponentModels;

        if (action.getActor().equals(settings.getID())) {
            // ourside, just advance progress
            if (progress instanceof ProgressRounds) {
                // bit hacky, maybe we should wait
                newprogress = ((ProgressRounds) progress).advance();
            }
        } else {
            // not ourselves, update the OpponentModel
            newmodels = updateModels(action);
        }
        return new Group5BoaState(settings, profile, newprogress, biddingStrategy,
                acceptanceStrategy, opponentModelClass, newactions, newmodels,
                reporter);
    }

    /**
     * @return the current {@link Progress}
     */
    public Progress getProgress() {
        return progress;
    }

    /**
     * @return list of actions done so far, oldest action first
     */
    public List<Action> getActionHistory() {
        return Collections.unmodifiableList(actionHistory);
    }

    /**
     *
     * @param bid the {@link Bid} to check
     * @return true iff {@link #acceptanceStrategy} says the bid is acceptable
     */
    public boolean isAcceptable(Bid bid) {
        return acceptanceStrategy.isAcceptable(bid, this);
    }

    /**
     *
     * @return the next recommended action according to the
     *         {@link #biddingStrategy}
     */
    public Action getAction() {
        return biddingStrategy.getAction(this);
    }

    /**
     *
     * @return the Reporter (same as the BoaParty's reporter)
     */
    public Reporter getReporter() {
        return reporter;
    }

    /**
     * @param action
     * @return the map with the opponentmodels, with the model for the party
     *         that did the action updated.
     * @throws InstantiationFailedException
     */
    private Map<PartyId, OpponentModel> updateModels(Action action)
            throws InstantiationFailedException {
        PartyId actor = action.getActor();
        Map<PartyId, OpponentModel> updated = extendedOpponentModels(actor);
        updated.put(actor, updated.get(actor).with(action, progress));
        return updated;
    }

    /**
     * Get the current opponent model, extended with newparty if there is no
     * model yet for newparty.
     *
     * @param newparty a possibly new party
     * @return a (possibly new) opponentModels map
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws InstantiationFailedException
     */
    private Map<PartyId, OpponentModel> extendedOpponentModels(PartyId newparty)
            throws InstantiationFailedException {
        // check if this is new party
        if (opponentModels.containsKey(newparty))
            return opponentModels;

        Map<PartyId, OpponentModel> newmodels = new HashMap<>(opponentModels);
        OpponentModel newmodel;
        try {
            newmodel = opponentModelClass.newInstance()
                    .with(profile.getDomain(), profile.getReservationBid());
        } catch (Exception e) {
            throw new InstantiationFailedException(
                    "Failed to instantiate " + opponentModelClass, e);
        }
        newmodels.put(newparty, newmodel);
        return newmodels;
    }

}