source: boa/src/main/java/geniusweb/boa/NegoState.java@ 14

package geniusweb.boa;

import java.lang.reflect.Parameter;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;

import geniusweb.actions.Action;
import geniusweb.actions.ActionWithBid;
import geniusweb.actions.PartyId;
import geniusweb.boa.acceptancestrategy.AcceptanceStrategy;
import geniusweb.boa.biddingstrategy.BiddingStrategy;
import geniusweb.issuevalue.Bid;
import geniusweb.party.inform.Settings;
import geniusweb.profile.Profile;
import geniusweb.progress.Progress;
import tudelft.utilities.logging.Reporter;

/**
 * Stores the current state of the negotiation for a {@link BoaParty}, including
 * the state of the opponent models
 *
 */
public class NegoState {
        private final Settings settings;
        private final Profile profile;
        private final Progress progress;
        private final Class<OpponentModel> opponentModelClass;
        private final AcceptanceStrategy acceptanceStrat;
        private final Bid lastReceivedBid;
        private final Map<PartyId, OpponentModel> opponentModels;
        private final Reporter reporter;

        public NegoState() {
                this(null, null, null, null, null, null, new HashMap<>(), null);
        }

        public NegoState(Settings settings, Profile profile, Progress progr,
                        Class<OpponentModel> omClass, AcceptanceStrategy as, Bid lastRcBid,
                        Map<PartyId, OpponentModel> oppMods, Reporter reporter) {
                this.settings = settings;
                this.profile = profile;
                this.progress = progr;
                this.opponentModelClass = omClass;
                this.acceptanceStrat = as;
                this.lastReceivedBid = lastRcBid;
                this.opponentModels = oppMods;
                this.reporter = reporter;
        }

        /**
         * Initialize the component. Must be called first.
         * 
         * @param progress the progress to use
         * @param myId     the Id of this party
         * @param as       the acceptance strategy class
         * @param om       the Class of the OpponentModels
         * @param reporter a {@link Reporter} to log messages and errors to
         * @return initialized {@link BiddingStrategy}
         * @throws InstantiationFailedException if one of provided classes can not
         *                                      be instantiated.
         */

        public NegoState with(Progress progr, PartyId myId,
                        Class<AcceptanceStrategy> asClass, Class<OpponentModel> omClass,
                        Reporter reporter) throws InstantiationFailedException {
                AcceptanceStrategy as;
                try {
                        as = asClass.newInstance();
                } catch (InstantiationException | IllegalAccessException e) {
                        throw new InstantiationFailedException(
                                        "Failed to create " + asClass, e);
                }
                return new NegoState(settings, profile, progr, omClass, as,
                                lastReceivedBid, opponentModels, reporter);
        }

        /**
         * 
         * @param profile the profile that we use. Must be called second (after the
         *                init call above). Can be called multiple times, if a
         *                profile changes
         * @throws InstantiationFailedException if one of provided classes can not
         *                                      be instantiated.
         */
        public NegoState with(Profile prof) {
                if (profile != null)
                        reporter.log(Level.WARNING,
                                        "DefaultBiddingStrategy does not support profile changes. Ignored the change.");
                return new NegoState(settings, prof, progress, opponentModelClass,
                                acceptanceStrat, lastReceivedBid, 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.
         * @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 NegoState with(Action action) throws InstantiationFailedException {
                try {
                        Map<PartyId, OpponentModel> newmodels = updateModels(action);
                } catch (InstantiationException | IllegalAccessException e) {
                        throw new InstantiationFailedException("Updating the models failed:"
                                        + e.getMessage() + ". Ignoring the action", e);
                }
                Bid lastbid = action instanceof ActionWithBid
                                ? ((ActionWithBid) action).getBid()
                                : lastReceivedBid;
                return new NegoState(settings, profile, progress, opponentModelClass,
                                acceptanceStrat, lastbid, opponentModels, reporter);
        }

        /**
         * Must be called every time a 'round' as been made and the progress needs
         * to be incremented.
         * 
         * @param progress the new value of the progress
         * @return new state
         * @throws InstantiationFailedException if one of provided classes can not
         *                                      be instantiated.
         */
        public NegoState with(Progress prog) {
                return new NegoState(settings, profile, prog, opponentModelClass,
                                acceptanceStrat, lastReceivedBid, opponentModels, reporter);
        }

        /**
         * @param action
         * @return the map with the opponentmodels, with the party that did the
         *         action updated.
         * @throws InstantiationException
         * @throws IllegalAccessException
         */
        private Map<PartyId, OpponentModel> updateModels(Action action)
                        throws InstantiationException, IllegalAccessException {
                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
         */
        private Map<PartyId, OpponentModel> extendedOpponentModels(PartyId newparty)
                        throws InstantiationException, IllegalAccessException {
                // check if this is new party
                if (opponentModels.containsKey(newparty))
                        return opponentModels;

                Map<PartyId, OpponentModel> newmodels = new HashMap<>(opponentModels);
                OpponentModel newmodel = opponentModelClass.newInstance();
                newmodel = newmodel.with(profile.getDomain());
                newmodels.put(newparty, newmodel);
                return newmodels;
        }
}