source: protocol/src/main/java/geniusweb/protocol/session/shaop/BareSHAOPState.java@ 11

package geniusweb.protocol.session.shaop;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import com.fasterxml.jackson.annotation.JsonCreator;

import geniusweb.actions.Action;
import geniusweb.actions.PartyId;
import geniusweb.progress.Progress;
import geniusweb.protocol.ProtocolException;
import geniusweb.protocol.partyconnection.ProtocolToPartyConnections;
import geniusweb.protocol.session.SessionSettings;
import geniusweb.protocol.session.SessionState;
import geniusweb.references.PartyWithProfile;

/**
 * The state without all the "with" functioality to make this more readable.
 * immutable. json-serializable.
 */
public abstract class BareSHAOPState implements SessionState {
        protected final List<Action> actions;

        protected final transient ProtocolToPartyConnections connections;

        protected final Progress progress;

        protected final SHAOPSettings settings;

        protected final ProtocolException error;

        protected final int teamNr;

        protected final Map<PartyId, Integer> partyNumbers;

        protected final Map<PartyId, Double> totalSpent;

        /**
         * 
         * @param actions    value for actions done so far. null equals to empty
         *                   list
         * @param conns      the currently existing connections. Can be empty/null.
         *                   Each connection represents another party. Normally the
         *                   connections are in the order SHAOP1,COB1,SHAOP2,COB2,..
         *                   so 2 parties for each team. The protocol should check
         *                   this.
         * @param progr      the {@link Progress} that governs this session. Can be
         *                   null if session did not yet start.
         * @param settings   the settings used for the session
         * @param e          the exception that occured, usually null. All errors
         *                   occuring due to faulty {@link Action}s translate to
         *                   {@link ProtocolException}s. All errors in our own code
         *                   are bugs (not ProtocolExceptions) and should result in
         *                   a throw.
         * @param teamNr     the teamnr (0,1,2..) that has the turn. 2* gives index
         *                   {@link #connections} and settings
         * @param partyNrs   a map for each known PartyId to a number. The number is
         *                   the index in both {@link SHAOPSettings#getTeams()} and
         *                   in {@link #connections}. null is empyt map.
         * @param totalSpent total accumulated elicitation costs so far. only SHAOP
         *                   parties accumulate costs. null = empty map
         */
        @JsonCreator
        public BareSHAOPState(List<Action> actions,
                        ProtocolToPartyConnections conns, Progress progr,
                        SHAOPSettings settings, ProtocolException e, int teamNr,
                        Map<PartyId, Integer> partyNrs, Map<PartyId, Double> spent) {
                if (conns == null) {
                        this.connections = new ProtocolToPartyConnections(
                                        Collections.emptyList());
                } else {
                        this.connections = conns;
                }
                if (actions == null) {
                        this.actions = new LinkedList<>();
                } else {
                        this.actions = actions;
                }
                if (partyNrs == null) {
                        this.partyNumbers = Collections.emptyMap();
                } else {
                        this.partyNumbers = partyNrs;
                }
                if (spent == null) {
                        this.totalSpent = Collections.emptyMap();
                } else {
                        this.totalSpent = spent;
                }

                if (!connections.allunique()) {
                        throw new IllegalArgumentException(
                                        "There can not be multiple connections for a party:"
                                                        + conns);
                }

                this.progress = progr;
                this.settings = settings;
                this.error = e;
                this.teamNr = teamNr;
        }

        public ProtocolToPartyConnections getConnections() {
                return connections;
        }

        /**
         * 
         * @return party ID of current team leader (SHAOP party)
         */
        public PartyId getCurrentTeam() {
                return connections.get(2 * teamNr).getParty();
        }

        /**
         * @param id the {@link PartyId}
         * @return the PartyWithProfile associated with that id.
         */
        public PartyWithProfile getPartyProfile(PartyId id) {
                return settings.getAllParties().get(partyNumbers.get(id));
        }

        /**
         * 
         * @return the index of each party
         */
        public Map<PartyId, Integer> getPartyNumbers() {
                return Collections.unmodifiableMap(partyNumbers);
        }

        /**
         * 
         * @return unmodifyable list of actions done so far.
         */
        @Override
        public List<Action> getActions() {
                return Collections.unmodifiableList(actions);
        }

        @Override
        public Progress getProgress() {
                return progress;
        }

        @Override
        public SessionSettings getSettings() {
                return settings;
        }

        @Override
        public boolean isFinal(long currentTimeMs) {
                return error != null
                                || (progress != null && progress.isPastDeadline(currentTimeMs));
        }

        @Override
        public ProtocolException getError() {
                return error;
        }

        @Override
        public String toString() {
                return this.getClass().getSimpleName() + "[" + actions + ","
                                + connections + "," + progress + "," + settings + "," + error
                                + "]";
        }

}