source: boa/src/main/java/geniusweb/boa/BoaState.java@ 52

package geniusweb.boa;

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.Offer;
import geniusweb.actions.PartyId;
import geniusweb.boa.acceptancestrategy.AcceptanceStrategy;
import geniusweb.boa.biddingstrategy.BiddingStrategy;
import geniusweb.inform.Settings;
import geniusweb.opponentmodel.OpponentModel;
import geniusweb.profile.Profile;
import geniusweb.profile.utilityspace.LinearAdditive;
import geniusweb.progress.Progress;
import geniusweb.progress.ProgressRounds;
import tudelft.utilities.logging.Reporter;

/**
 * Stores the current state of the negotiation for a {@link BoaParty}, including
 * the state of the opponent models. immutable.
 *
 */
public class 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 Reporter reporter;

        /**
         * Initial state. Update using with(settings).
         * 
         * @param reporter the {@link Reporter} to use for logging
         */
        public BoaState(Reporter reporter) {
                this(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. BOA only supports
         *                      {@link LinearAdditive} so this can be assumed to be
         *                      {@link LinearAdditive}.
         * @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 BoaParty}'s reporter
         */
        private BoaState(Settings settings, Profile profile, Progress progr,
                        Class<? extends OpponentModel> omClass, List<Action> actionHistory,
                        Map<PartyId, OpponentModel> oppMods, Reporter reporter) {
                this.settings = settings;
                this.profile = profile;
                this.progress = progr;
                this.opponentModelClass = omClass;
                this.actionHistory = actionHistory;
                this.opponentModels = oppMods;
                this.reporter = reporter;
        }

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

        /**
         * @param newprofile a new profile to be used, replaces old profile.
         *                   {@link LinearAdditive} profile (BOA does not support
         *                   other types)
         * @return new {@link BoaState}
         */
        public BoaState with(Profile newprofile) {
                return new BoaState(settings, newprofile, progress, 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. BOA only supports
         *         {@link LinearAdditive} so this can be assumed to be
         *         {@link LinearAdditive}.
         */
        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 BoaState 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 BoaState(settings, profile, newprogress, 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);
        }

        /**
         * 
         * @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(settings.getParameters())
                                        .with(profile.getDomain(), profile.getReservationBid());
                } catch (Exception e) {
                        throw new InstantiationFailedException(
                                        "Failed to instantiate " + opponentModelClass, e);
                }
                newmodels.put(newparty, newmodel);
                return newmodels;
        }

        /**
         * 
         * @return last received Offer, or null if no offer was done.
         */
        public Offer getLastReceivedOffer() {
                for (int i = actionHistory.size() - 1; i >= 0; i--) {
                        Action act = actionHistory.get(i);
                        if (act instanceof Offer)
                                return (Offer) act;
                }
                return null;
        }

}