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

package genius.gui.session;

import java.util.List;

import java.util.ArrayList;
import java.util.Date;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;

import java.awt.BorderLayout;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;

import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.xml.stream.XMLStreamException;

import genius.core.AgentID;
import genius.core.exceptions.InstantiateException;
import genius.core.exceptions.NegotiatorException;
import genius.core.listener.Listener;
import genius.core.logging.ConsoleLogger;
import genius.core.logging.FileLogger;
import genius.core.logging.XmlLogger;
import genius.core.misc.RLBOAUtils;
import genius.core.parties.NegotiationParty;
import genius.core.parties.NegotiationPartyInternal;
import genius.core.parties.SessionsInfo;
import genius.core.protocol.MultilateralProtocol;
import genius.core.repository.ParticipantRepItem;
import genius.core.repository.ProfileRepItem;
import genius.core.session.ExecutorWithTimeout;
import genius.core.session.MultilateralSessionConfiguration;
import genius.core.session.Participant;
import genius.core.session.RepositoryException;
import genius.core.session.Session;
import genius.core.session.SessionConfiguration;
import genius.core.session.SessionManager;
import genius.core.session.TournamentManager;
import genius.core.tournament.TournamentConfiguration;
import genius.gui.progress.session.ActionDocumentModel;
import genius.gui.progress.session.OutcomesListModel;
import genius.gui.progress.session.SessionProgressUI;

/**
 * Session Panel. Asks user to configure a session. When user presses run, the
 * panel changes into a progress panel and a session runner is started.
 */
@SuppressWarnings("serial")
public class SessionPanel extends JPanel {
        public SessionPanel() {
                final SessionModel model = new SessionModel();

                setLayout(new BorderLayout());
                add(new SessionConfigPanel(model), BorderLayout.CENTER);
                model.addListener(new Listener<MultilateralSessionConfiguration>() {
                        @Override
                        public void notifyChange(final MultilateralSessionConfiguration config) {
                                new Thread(new Runnable() {
                                        @Override
                                        public void run() {
                                                boolean showChart = model.getShowChart().getValue();
                                                boolean biChart = model.getParticipantsModel().getSize() == 2
                                                                && model.getBilateralUtilUtilPlot().getValue();
                                                runSession(config, showChart, biChart, model.getBilateralShowAllBids().getValue(),
                                                                model.getPrintEnabled().getValue());
                                        }
                                }).start();
                        }

                });

        }

        /**
         * Runs a session and waits for completion.
         * 
         * @param config
         * @param showChart
         *            true iff a progress chart should be shown.
         * @param useBiChart
         *            true iff the bilateral progress chart is to be used.
         * @param showAllBids
         */
        private void runSession(MultilateralSessionConfiguration config, boolean showChart, boolean useBiChart,
                        boolean showAllBids, boolean isPrintEnabled) {
                System.out.println("run session, with " + config);
                try {
                        start(config, showChart, useBiChart, showAllBids, isPrintEnabled);
                } catch (InstantiateException | RepositoryException | NegotiatorException | XMLStreamException | IOException
                                | TimeoutException | ExecutionException e) {
                        e.printStackTrace();
                        JOptionPane.showMessageDialog(null, "Session failed to run: " + e.getMessage(), "Warning",
                                        JOptionPane.WARNING_MESSAGE);
                }

        }

        /**
         * 
         * @param config
         * @param showChart
         * @param showBiChart
         *            true if progress chart has to be shown
         * @param showAllBids
         *            if the bilateral progress chart should be used. Ignored if
         *            showBiChart is false.
         * @param isPrintEnabled
         *            true iff system out print is enabled.
         * @throws InstantiateException
         * @throws RepositoryException
         * @throws NegotiatorException
         * @throws XMLStreamException
         * @throws IOException
         * @throws TimeoutException
         * @throws ExecutionException
         */
        public void start(MultilateralSessionConfiguration config, boolean showChart, boolean showBiChart,
                        boolean showAllBids, boolean isPrintEnabled) throws InstantiateException, RepositoryException,
                        NegotiatorException, XMLStreamException, IOException, TimeoutException, ExecutionException {

                if (config.getParties().size() < 2) {
                        throw new IllegalArgumentException("There should be at least two negotiating agents !");
                }

                MultilateralProtocol protocol = TournamentManager.getProtocol(config.getProtocol());
                SessionsInfo info = new SessionsInfo(protocol, config.getPersistentDataType(), isPrintEnabled);
                Session session = new Session(config.getDeadline(), info);

                ExecutorWithTimeout executor = new ExecutorWithTimeout(1000 * config.getDeadline().getTimeOrDefaultTimeout());
                List<NegotiationPartyInternal> negoparties = getNegotiationParties(config, session, info, executor);
                SessionManager sessionManager = new SessionManager((SessionConfiguration) config, negoparties, session,
                                executor);

                // When training, the RLBOA agents can listen to the sessions
                if (TournamentConfiguration.getBooleanOption("accessPartnerPreferences", false))
                        RLBOAUtils.addReinforcementAgentListeners(negoparties, sessionManager);

                displayProgress(negoparties, sessionManager, showChart, showBiChart, showAllBids);

                // connect the loggers.
                DateFormat dateFormat = new SimpleDateFormat("yyyyMMdd-HHmmss");
                String fileName = String.format("log/Log-Session_%s", dateFormat.format(new Date()));
                FileLogger filelogger = new FileLogger(fileName);
                XmlLogger xmlLogger = new XmlLogger(new FileOutputStream(fileName + ".xml"), "Session");
                sessionManager.addListener(filelogger);
                sessionManager.addListener(xmlLogger);
                sessionManager.addListener(new ConsoleLogger());

                System.out.println("Negotiation session has started.");
                Thread t = new Thread(sessionManager);
                t.start();
                try {
                        t.join();
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }

                // close the loggers
                System.out.println("Negotiation session has stopped.");
                try {
                        filelogger.close();
                } catch (IOException e) {
                        e.printStackTrace();
                }
                try {
                        xmlLogger.close();
                } catch (IOException e) {
                        e.printStackTrace();
                }
                info.close();

        }

        /**
         * 
         * @param negoparties
         * @param sessionManager
         * @param showChart
         *            true iff any progress chart has to be shown
         * @param biChart
         *            if the bilateral progress chart has to be shown. Ignored if
         *            showChart is false.
         * @param showAllBids
         */
        private void displayProgress(List<NegotiationPartyInternal> negoparties, SessionManager sessionManager,
                        boolean showChart, boolean biChart, boolean showAllBids) {
                OutcomesListModel model = new OutcomesListModel(negoparties);
                ActionDocumentModel actiondocument = new ActionDocumentModel();
                sessionManager.addListener(model);
                sessionManager.addListener(actiondocument);
                removeAll();
                add(new SessionProgressUI(model, actiondocument, showChart, biChart, showAllBids), BorderLayout.CENTER);
                revalidate();
        }

        /**
         * 
         * @param config
         * @param session
         * @param info
         * @param executor
         *            the executor in which this session runs.
         * @return the parties for this negotiation. Converts the config into actual
         *         {@link NegotiationParty}s
         * @throws RepositoryException
         * @throws NegotiatorException
         * @throws ExecutionException
         * @throws TimeoutException
         */
        private List<NegotiationPartyInternal> getNegotiationParties(MultilateralSessionConfiguration config,
                        Session session, SessionsInfo info, ExecutorWithTimeout executor)
                        throws RepositoryException, NegotiatorException, TimeoutException, ExecutionException {
                List<ParticipantRepItem> parties = new ArrayList<>();
                List<ProfileRepItem> profiles = new ArrayList<>();
                List<AgentID> names = new ArrayList<AgentID>();

                for (Participant participant : config.getParties()) {
                        ParticipantRepItem strategy = participant.getStrategy();
                        parties.add(strategy);
                        if (!strategy.isMediator()) {
                                profiles.add(participant.getProfile());
                                names.add(participant.getId());
                        }
                }

                return TournamentManager.getPartyList(executor, config, info, session);
                // List<NegotiationPartyInternal> negoparties =
                // TournamentGenerator.generateSessionParties(parties, profiles,
                // names, session, info);
                // return negoparties;
        }

        private List<NegotiationPartyInternal> getNonMediators(List<NegotiationPartyInternal> negoparties) {
                List<NegotiationPartyInternal> list = new ArrayList<>();
                for (NegotiationPartyInternal party : negoparties) {
                        if (!party.isMediator()) {
                                list.add(party);
                        }
                }
                return list;
        }

        /**
         * simple stub to run this stand-alone (for testing).
         * 
         * @param args
         */
        public static void main(String[] args) {
                final JFrame gui = new JFrame();
                gui.setLayout(new BorderLayout());
                gui.getContentPane().add(new SessionPanel(), BorderLayout.CENTER);
                gui.pack();
                gui.setVisible(true);
        }

}