source: protocol/src/main/java/geniusweb/protocol/session/mopac/PartyStates.java@ 52

package geniusweb.protocol.session.mopac;

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

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;

import geniusweb.actions.Action;
import geniusweb.actions.EndNegotiation;
import geniusweb.actions.PartyId;
import geniusweb.inform.Agreements;
import geniusweb.protocol.ProtocolException;

/**
 * Invariant: contains the current state of all participating parties. A party
 * either notYetActed, did action, reached an agreement, walked away or made a
 * {@link ProtocolException}.
 * <p>
 * After a phase completes, the actions are filtered/handled to collect
 * agreements and move remaining parties back to notYetActed.
 * 
 */
@JsonAutoDetect(fieldVisibility = Visibility.ANY, getterVisibility = Visibility.NONE, setterVisibility = Visibility.NONE, isGetterVisibility = Visibility.NONE)
public class PartyStates {
        // all parties must be in exactly one state at all times.
        private final Set<PartyId> notYetActed;
        private final List<Action> actions; // chrono order
        private final Agreements agreements;
        private final List<PartyId> walkedAway;
        private final Map<PartyId, ProtocolException> exceptions;
        private final Map<PartyId, Integer> powers;

        @JsonCreator
        protected PartyStates(@JsonProperty("powers") Map<PartyId, Integer> powers,
                        @JsonProperty("notYetActed") Set<PartyId> notYetActed,
                        @JsonProperty("actions") List<Action> actions,
                        @JsonProperty("agreements") Agreements agreements,
                        @JsonProperty("walkedAway") List<PartyId> walkedAway,
                        @JsonProperty("exceptions") Map<PartyId, ProtocolException> exceptions) {
                this.notYetActed = new HashSet<>(notYetActed);
                this.actions = new ArrayList<>(actions);
                this.agreements = agreements;
                this.walkedAway = new ArrayList<>(walkedAway);
                this.exceptions = exceptions;
                this.powers = new HashMap<>(powers);
        }

        /**
         * Initial constructor.
         * 
         * @param powers the powers of all parties.
         */
        public PartyStates(Map<PartyId, Integer> powers) {
                this(powers, new HashSet<>(powers.keySet()), Collections.emptyList(),
                                new Agreements(), Collections.emptyList(),
                                Collections.emptyMap());
        }

        /**
         * 
         * @param action the action done by some party. The correctness of action,
         *               particularly of {@link Action#getActor()}, must be correct.
         * @return new state with party done given action. This just accepts any
         *         given action and is not considering number of rounds, time or
         *         whether an action is allowed.
         * 
         * @throws IllegalArgumentException if party doing action already acted.
         *                                  This is just a safety check as legality
         *                                  of actions should be checked before
         *                                  calling this.
         */
        public PartyStates with(Action action) {
                if (!(notYetActed.contains(action.getActor())))
                        throw new IllegalArgumentException(
                                        "actor already acted: " + action);
                if (action instanceof EndNegotiation)
                        return withWalkAway(action.getActor());
                List<Action> newActions = new LinkedList<Action>(actions);
                newActions.add(action);
                return new PartyStates(powers, removeParty(action.getActor()),
                                newActions, agreements, walkedAway, exceptions);
        }

        /**
         * 
         * @param newAgree a new agreements to be merged with existing agreements.
         *                 The parties in the agreement must have acted and thus in
         *                 actions.
         * @return new PartyStates with agreeing parties removed from actions and
         *         added to Agreements.
         */
        public PartyStates with(Agreements newAgree) {
                Set<PartyId> parties = newAgree.getMap().keySet();
                List<Action> newActions = actions.stream()
                                .filter(act -> !(parties.contains(act.getActor())))
                                .collect(Collectors.toList());
                return new PartyStates(powers, notYetActed, newActions,
                                agreements.with(newAgree), walkedAway, exceptions);
        }

        public PartyStates withWalkAway(PartyId actor) {
                if (!(notYetActed.contains(actor)))
                        throw new IllegalArgumentException("actor already acted: " + actor);
                LinkedList<PartyId> newWalkAway = new LinkedList<>(walkedAway);
                newWalkAway.add(actor);
                return new PartyStates(powers, removeParty(actor), actions, agreements,
                                newWalkAway, exceptions);
        }

        /**
         * Move party from active to exceptions.
         * 
         * @param e the exception that the party caused
         * @return new PartyStates with party that caused the exception in the
         *         exceptions list and removed from the active list. Nothing happens
         *         if party is not active.
         */
        public PartyStates with(ProtocolException e) {
                if (!notYetActed.contains(e.getParty())) {
                        // complex case. Party did valid action but now is messing around.
                        // Easiest seems to completely ignore it. CHECK.
                        return this;
                }
                Map<PartyId, ProtocolException> newExc = new HashMap<>(exceptions);
                newExc.put(e.getParty(), e);
                return new PartyStates(powers, removeParty(e.getParty()), actions,
                                agreements, walkedAway, newExc);
        }

        /**
         * 
         * @return parties that have not yet acted
         */
        public Set<PartyId> getNotYetActed() {
                return notYetActed;
        }

        /**
         * 
         * @return parties that are still in the negotiation. These are the parties
         *         that not yet acted plus the ones that did an action.
         */
        public Set<PartyId> getNegotiatingParties() {
                Set<PartyId> parties = actions.stream().map(act -> act.getActor())
                                .collect(Collectors.toSet());
                parties.addAll(notYetActed);
                return parties;
        }

        /**
         * @param actor
         * @return {@link #notYetActed} with actor removed
         * @throws IllegalArgumentException if party already acted (not in
         *                                  {@link #notYetActed}).
         */
        private Set<PartyId> removeParty(PartyId party) {
                Set<PartyId> newActiveParties = new HashSet<>(notYetActed);
                if (!newActiveParties.remove(party))
                        throw new IllegalArgumentException(
                                        "Party " + party + " is not active, can't be removed");
                return newActiveParties;

        }

        public Agreements getAgreements() {
                return agreements;
        }

        public Map<PartyId, Integer> getPowers() {
                return Collections.unmodifiableMap(powers);
        }

        public Map<PartyId, ProtocolException> getExceptions() {
                return Collections.unmodifiableMap(exceptions);
        }

        /**
         * @return new state where all {@link #notYetActed} are moved to the
         *         exceptions list.
         */
        public PartyStates finish() {
                PartyStates newstate = this;
                for (PartyId party : notYetActed) {
                        newstate = newstate
                                        .with(new ProtocolException("Party did not act", party));
                }
                return newstate;
        }

        public List<Action> getActions() {
                return Collections.unmodifiableList(actions);
        }

        /**
         * 
         * @return all parties that walked away
         */
        public List<PartyId> getWalkedAway() {
                return Collections.unmodifiableList(walkedAway);
        }

        /**
         * @param <T>  the type of objects requested
         * @param type the type of actions to extract. Must be of type T, needed
         *             because of java's type erasure.
         * 
         * @return all actions of requested type in this phase
         */
        public <T extends Action> List<T> getActions(Class<T> type) {
                return actions.stream().filter(act -> type.isInstance(act))
                                .map(act -> (T) act).collect(Collectors.toList());
        }

        @Override
        public String toString() {
                return "PartyStates[" + notYetActed + "," + actions + "," + agreements
                                + "," + walkedAway + "," + exceptions + "]";
        }

        /**
         * 
         * @return states with all parties that are in {@link #actions} moved back
         *         to {@link #notYetActed}. This state is then ready for a next
         *         phase.
         * @throws IllegalStateException if {@link #notYetActed} is not empty
         */
        public PartyStates flush() {
                if (!notYetActed.isEmpty())
                        throw new IllegalStateException(
                                        "Some parties did not yet act:" + notYetActed);
                return new PartyStates(powers, getNegotiatingParties(),
                                Collections.emptyList(), agreements, walkedAway, exceptions);
        }

        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + ((actions == null) ? 0 : actions.hashCode());
                result = prime * result
                                + ((agreements == null) ? 0 : agreements.hashCode());
                result = prime * result
                                + ((exceptions == null) ? 0 : exceptions.hashCode());
                result = prime * result
                                + ((notYetActed == null) ? 0 : notYetActed.hashCode());
                result = prime * result + ((powers == null) ? 0 : powers.hashCode());
                result = prime * result
                                + ((walkedAway == null) ? 0 : walkedAway.hashCode());
                return result;
        }

        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                PartyStates other = (PartyStates) obj;
                if (actions == null) {
                        if (other.actions != null)
                                return false;
                } else if (!actions.equals(other.actions))
                        return false;
                if (agreements == null) {
                        if (other.agreements != null)
                                return false;
                } else if (!agreements.equals(other.agreements))
                        return false;
                if (exceptions == null) {
                        if (other.exceptions != null)
                                return false;
                } else if (!exceptions.equals(other.exceptions))
                        return false;
                if (notYetActed == null) {
                        if (other.notYetActed != null)
                                return false;
                } else if (!notYetActed.equals(other.notYetActed))
                        return false;
                if (powers == null) {
                        if (other.powers != null)
                                return false;
                } else if (!powers.equals(other.powers))
                        return false;
                if (walkedAway == null) {
                        if (other.walkedAway != null)
                                return false;
                } else if (!walkedAway.equals(other.walkedAway))
                        return false;
                return true;
        }

}