source: protocol/src/main/java/geniusweb/protocol/session/saop/SAOPState.java@ 26

package geniusweb.protocol.session.saop;

import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import geniusweb.actions.Accept;
import geniusweb.actions.Action;
import geniusweb.actions.EndNegotiation;
import geniusweb.actions.Offer;
import geniusweb.actions.PartyId;
import geniusweb.inform.Agreements;
import geniusweb.issuevalue.Bid;
import geniusweb.progress.Progress;
import geniusweb.progress.ProgressRounds;
import geniusweb.protocol.ProtocolException;
import geniusweb.protocol.partyconnection.ProtocolToPartyConn;
import geniusweb.protocol.partyconnection.ProtocolToPartyConnections;
import geniusweb.protocol.session.DefaultSessionState;
import geniusweb.protocol.session.SessionResult;
import geniusweb.protocol.session.SessionSettings;
import geniusweb.references.PartyWithProfile;

/**
 * Immutable.
 */
public class SAOPState extends DefaultSessionState {

        /**
         * 
         * @param actions       the actions done by the parties
         * @param conns         the existing party connections. we assume ownership
         *                      of this so it should not be modified although
         *                      connections may of course break. If null, default
         *                      empty list is used. Can be less than 2 parties in
         *                      the first phases of the setup.
         * @param progress      the {@link Progress} line. can be null
         * @param settings      the {@link SAOPSettings}
         * @param partyprofiles map with the {@link PartyWithProfile} for connected
         *                      parties. null is equivalent to an empty map.
         * @param e             the {@link ProtocolException}, or null if none
         *                      occurred.
         */
        public SAOPState(List<Action> actions, ProtocolToPartyConnections conns,
                        Progress progress, SessionSettings settings,
                        Map<PartyId, PartyWithProfile> partyprofiles, ProtocolException e) {
                super(actions, conns, progress, settings, partyprofiles, e);
        }

        /**
         * Creates the initial state from the given settings and progress=null
         * 
         * @param settings the {@link SAOPSettings}
         */
        public SAOPState(SAOPSettings settings) {
                this(Collections.emptyList(),
                                new ProtocolToPartyConnections(Collections.emptyList()), null,
                                settings, null, null);

        }

        /**
         * 
         * @param connection   the new {@link ProtocolToPartyConn}
         * @param partyprofile the {@link PartyWithProfile} that is associated with
         *                     this state
         * @return new SessionState with the new connection added. This call ignores
         *         the progress (does not check isFinal) because SAOP uses this
         *         during the setup where the deadline is not yet relevant. The
         *         connection should be informed about the partyprofile but the
         *         state currently indicate if that already happened or not.
         */
        public SAOPState with(ProtocolToPartyConn connection,
                        PartyWithProfile partyprofile) {
                // Only called from the SAOP initialization phase.
                ProtocolToPartyConnections newconns = getConnections().with(connection);
                Map<PartyId, PartyWithProfile> newprofiles = new HashMap<>(
                                getPartyProfiles());
                newprofiles.put(connection.getParty(), partyprofile);
                return new SAOPState(getActions(), newconns, getProgress(),
                                getSettings(), newprofiles, null);
        }

        /**
         * 
         * @param e the error that occured
         * @return a new state with the error set.
         */
        public SAOPState with(ProtocolException e) {
                return new SAOPState(getActions(), getConnections(), getProgress(),
                                getSettings(), getPartyProfiles(), e);
        }

        /**
         * Sets the progress for this session. Can be set only if progress=null.
         * 
         * @param newprogress the new progress
         * @return new SAOPState with the progress set
         */
        public SAOPState with(Progress newprogress) {
                if (newprogress == null) {
                        throw new IllegalArgumentException("newprogress must be not null");
                }
                if (getProgress() != null) {
                        return this;
                }
                return new SAOPState(getActions(), getConnections(), newprogress,
                                getSettings(), getPartyProfiles(), getError());
        }

        @Override
        public Agreements getAgreements() {
                Agreements agree = new Agreements();
                List<Action> acts = getActions();
                int nparticipants = getConnections().size();
                if (nparticipants < 2 || acts.size() < nparticipants) {
                        return agree;
                }
                Action offer = acts.get(acts.size() - nparticipants);
                if (!(offer instanceof Offer))
                        return agree;
                Bid bid = ((Offer) offer).getBid();

                // check that the last n-1 are accepts.
                boolean allaccept = acts.stream().skip(acts.size() - nparticipants + 1)
                                .allMatch(act -> act instanceof Accept
                                                && bid.equals(((Accept) act).getBid()));
                if (allaccept)
                        agree = agree.with(new Agreements(bid, getParties()));
                return agree;
        }

        /**
         * 
         * @return all currently connected parties.
         */
        private Set<PartyId> getParties() {
                return getConnections().stream().map(conn -> conn.getParty())
                                .collect(Collectors.toSet());
        }

        @Override
        public boolean isFinal(long currentTimeMs) {
                List<Action> acts = getActions();
                return super.isFinal(currentTimeMs)
                                || !getAgreements().getMap().isEmpty() || (!acts.isEmpty()
                                                && acts.get(acts.size() - 1) instanceof EndNegotiation);
        }

        @Override
        public SAOPSettings getSettings() {
                return (SAOPSettings) super.getSettings();
        }

        /**
         * @param actor  the actor that did this action. Can be used to check if
         *               action is valid. NOTICE caller has to make sure the current
         *               state is not final.
         * @param action the action that was proposed by actor.
         * @return new SAOPState with the action added as last action.
         */

        public SAOPState with(PartyId actor, Action action) {

                if (actor == null) { // this is a bug
                        throw new IllegalArgumentException("actor must not be null");
                }
                if (!actor.equals(getNextActor())) {
                        throw new IllegalArgumentException("Party does not have the turn ");

                }
                if (action == null) {
                        throw new IllegalArgumentException("action is null");
                }
                if (!actor.equals(action.getActor())) {
                        throw new IllegalArgumentException(
                                        "act contains wrong credentials: " + action);
                }

                // check protocol is followed for specific actions
                if (action instanceof Accept) {
                        Bid bid = getLastBid();
                        if (bid == null) {
                                throw new IllegalArgumentException(
                                                "Accept without a recent offer");
                        }
                        if (!bid.equals(((Accept) action).getBid())) {
                                throw new IllegalArgumentException(
                                                "Party accepts a bid differing from the last offer ="
                                                                + bid + ", action=" + action + ")");
                        }
                } else if (action instanceof Offer) {
                        // offer is always fine. We don't check if bid is actually in domain
                        // or complete etc. We would need domain for that
                } else if (action instanceof EndNegotiation) {
                        // just act, we will get into the final state then.
                } else {
                        throw new IllegalArgumentException(
                                        "Action " + action + " is not allowed in SAOP");
                }

                List<Action> newactions = new LinkedList<>(getActions());
                newactions.add(action);
                return new SAOPState(newactions, getConnections(), advanceProgress(),
                                getSettings(), getPartyProfiles(), null);
        }

        /**
         * Check up to nparticipants-1 steps back if there was an offer.
         * 
         * @return Bid from the most recent offer, or null if no such offer
         */
        private Bid getLastBid() {
                int nparticipants = getConnections().size();
                List<Action> acts = getActions();
                for (int n = acts.size() - 1; n > acts.size() - nparticipants
                                && n >= 0; n--) {
                        Action action = acts.get(n);
                        if (action instanceof Offer) {
                                return ((Offer) action).getBid();
                        }
                }
                return null;

        }

        /**
         * 
         * @return the next actor in the current state. Assumes 1 action per actor
         *         every time.
         */
        protected PartyId getNextActor() {
                return getConnections()
                                .get(getActions().size() % getConnections().size()).getParty();
        }

        /**
         * 
         * @param progress
         * @return new progress state
         */
        private Progress advanceProgress() {
                Progress newprogress = getProgress();
                if (newprogress instanceof ProgressRounds && isLastActor()) {
                        newprogress = ((ProgressRounds) newprogress).advance();
                }
                return newprogress;
        }

        /**
         * @return true if the current actor is the last actor in the list
         */
        private boolean isLastActor() {
                int nparticipants = getConnections().size();
                return getActions().size() % nparticipants == nparticipants - 1;
        }

        @Override
        public SessionResult getResult() {
                return new SessionResult(getPartyProfiles(), getAgreements(),
                                Collections.emptyMap(), getError());
        }

}