source: src/main/java/genius/gui/session/SessionModel.java@ 209

package genius.gui.session;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.swing.DefaultListModel;
import javax.swing.event.ListDataEvent;
import javax.swing.event.ListDataListener;

import genius.core.AgentID;
import genius.core.listener.DefaultListenable;
import genius.core.persistent.PersistentDataType;
import genius.core.repository.DomainRepItem;
import genius.core.repository.MultiPartyProtocolRepItem;
import genius.core.repository.PartyRepItem;
import genius.core.session.MultilateralSessionConfiguration;
import genius.core.session.Participant;
import genius.core.session.SessionConfiguration;
import genius.gui.deadline.DeadlineModel;
import genius.gui.negosession.ContentProxy;
import genius.gui.panels.BooleanModel;
import genius.gui.panels.SingleSelectionModel;
import genius.gui.panels.TextModel;

/**
 * Model that stores single session info for MVC.
 */
public class SessionModel extends DefaultListenable<MultilateralSessionConfiguration> {

        // models are all final, as they will be used to hook up the GUI.
        private final SingleSelectionModel<MultiPartyProtocolRepItem> protocolModel;
        private final SingleSelectionModel<DomainRepItem> domainModel;
        private final DeadlineModel deadlineModel = new DeadlineModel();

        // currently selected participant
        private final ParticipantModel participantModel;
        // the list of participants in the nego session
        private final DefaultListModel<Participant> participantsModel = new DefaultListModel<>();

        // selected mediator. Not used if protocol does not need mediator.
        private final SingleSelectionModel<PartyRepItem> mediatorModel;
        private final TextModel mediatorIdModel = new TextModel("Mediator");

        // bilateral-only options
        private final BooleanModel showProgressChart = new BooleanModel(true);
        private final BooleanModel bilateralShowUtilUtilPlot = new BooleanModel(true);
        private final BooleanModel bilateralShowAllBids = new BooleanModel(true);
        private final BooleanModel printEnabled = new BooleanModel(true);
        private final SingleSelectionModel<PersistentDataType> persistentDatatypeModel = new SingleSelectionModel<PersistentDataType>(
                        Arrays.asList(PersistentDataType.values()));

        public SessionModel() {
                protocolModel = new SingleSelectionModel<>(ContentProxy.fetchProtocols());
                domainModel = new SingleSelectionModel<>(ContentProxy.fetchDomains());
                participantModel = new ParticipantModel(protocolModel, domainModel);
                mediatorModel = new SingleSelectionModel<PartyRepItem>(new ArrayList<PartyRepItem>());

                updateSubmodels();
                addConstraints();
        }

        /**
         * @return the current single session run configuration
         */
        public MultilateralSessionConfiguration getConfiguration() {
                List<Participant> participants = new ArrayList<>();

                MultiPartyProtocolRepItem protocol = (MultiPartyProtocolRepItem) protocolModel.getSelectedItem();

                Participant mediator = null;
                if (protocol.getHasMediator()) {
                        // HACK #1463 use profile of participant 1 to avoid null profile.
                        mediator = new Participant(new AgentID(mediatorIdModel.getText()),
                                        (PartyRepItem) mediatorModel.getSelectedItem(), participantsModel.get(0).getProfile());
                }
                for (int n = 0; n < participantsModel.size(); n++) {
                        participants.add(participantsModel.getElementAt(n));
                }
                return new SessionConfiguration(protocol, mediator, participants, deadlineModel.getDeadline(),
                                persistentDatatypeModel.getSelection());
        }

        /**
         * @return the protocol data model.
         */
        public SingleSelectionModel<MultiPartyProtocolRepItem> getProtocolModel() {
                return protocolModel;
        }
        
        public SingleSelectionModel<DomainRepItem> getDomainModel() {
                return domainModel;
        }

        /**
         * @return the {@link TextModel} for teh Mediator ID
         */
        public TextModel getMediatorIdModel() {
                return mediatorIdModel;
        }

        /**
         * @return the mediator model
         */
        public SingleSelectionModel<PartyRepItem> getMediatorModel() {
                return mediatorModel;
        }

        public DeadlineModel getDeadlineModel() {
                return deadlineModel;
        }

        public SingleSelectionModel<PersistentDataType> getPersistentDatatypeModel() {
                return persistentDatatypeModel;
        }

        /**
         * @return the settings for the 'participant information'. This setting is
         *         used when the user clicks the 'add' button.
         */
        public ParticipantModel getParticipantModel() {
                return participantModel;
        }

        /**
         * Call this when model is completed (user clicked 'start'). TODO check that
         * the model is indeed complete.
         */
        public void modelIsComplete() {
                notifyChange(getConfiguration());
        }

        /**
         * @return model holding the list of participants.
         */
        public DefaultListModel<Participant> getParticipantsModel() {
                return participantsModel;
        }

        /**
         * 
         * @return boolean whether to show all bid points in the util-util graph.
         *         Only has meaning if {@link #getBilateralUtilUtilPlot()} is true
         */
        public BooleanModel getBilateralShowAllBids() {
                return bilateralShowAllBids;
        }

        /**
         * @return A booleanModel containing a boolean. If true, a util-util graph
         *         instead of a default graph will be plotted. util-util graph is a
         *         graph with side A utilities on the X-axis and side B utilities on
         *         the Y axis. This visualization method allows us to also plot
         *         other points like the Pareto Frontier and Nash point.
         * 
         */
        public BooleanModel getBilateralUtilUtilPlot() {
                return bilateralShowUtilUtilPlot;
        }

        /**
         * a booleanModel holding true iff user asked to enable print to stdout.
         * 
         * @return
         */
        public BooleanModel getPrintEnabled() {
                return printEnabled;
        }

        /**
         * 
         * @return true iff a session progress chart should be shown.
         */
        public BooleanModel getShowChart() {
                return showProgressChart;
        }

        /****************************** support funcs ******************/
        /**
         * connecting listeners that check the constraints between the fields in the
         * model
         */
        private void addConstraints() {
                // protocol has major impact on the submodels
                protocolModel.addListDataListener(new ListDataListener() {

                        @Override
                        public void intervalRemoved(ListDataEvent e) {
                        }

                        @Override
                        public void intervalAdded(ListDataEvent e) {
                        }

                        @Override
                        public void contentsChanged(ListDataEvent e) {
                                updateSubmodels();
                        }
                });

        }

        /**
         * Update the models after a protocol change.
         * 
         * @param protocol
         *            the new protocol.
         */
        private void updateSubmodels() {
                mediatorModel.setAllItems(ContentProxy.fetchMediatorsForProtocol(protocolModel.getSelection()));
        }

}