source: boa/src/main/java/geniusweb/boa/BoaParty.java@ 16

package geniusweb.boa;

import java.io.IOException;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.Timer;
import java.util.TimerTask;
import java.util.logging.Level;

import javax.websocket.DeploymentException;

import geniusweb.actions.Action;
import geniusweb.boa.acceptancestrategy.AcceptanceStrategy;
import geniusweb.boa.biddingstrategy.BiddingStrategy;
import geniusweb.party.Capabilities;
import geniusweb.party.DefaultParty;
import geniusweb.party.inform.ActionDone;
import geniusweb.party.inform.Finished;
import geniusweb.party.inform.Inform;
import geniusweb.party.inform.Settings;
import geniusweb.party.inform.YourTurn;
import geniusweb.profileconnection.ProfileConnectionFactory;
import geniusweb.profileconnection.ProfileInterface;

/**
 * Determines the next {@link Action} given our profile, the opponent model and
 * the acceptance strategy Could also be called OfferingStrategy, but we use
 * BiddingStrategy because of the name "BOA".
 * <p>
 * The BiddingStrategy must handle the connection, so it has to connect with the
 * profile when the {@link Settings} come in , and create the subcomponents.
 * 
 * The settings are assumed to contain also parameters "as" containing the
 * full.class.path to the {@link AcceptanceStrategy} clas, and "os" containing
 * the full.class.path to the   {@link OpponentModel} class and "bs" containing
 * the full.class.path to the   {@link BiddingStrategy} class.
 * 
 */
public class BoaParty extends DefaultParty {
        /**
         * This only supports SAOP protocol because it is not clear how the
         * BiddingStrategy could be made more general without basically becoming a
         * full Party.
         * 
         */
        private ProfileInterface profileint;
        private NegoState negoState = new NegoState();
        private BiddingStrategy biddingStrategy;

        @Override
        public Capabilities getCapabilities() {
                return new Capabilities(new HashSet<>(Arrays.asList("SAOP")));
        }

        @Override
        public String getDescription() {
                return "Takes parameters om=OpponentModel full.class.path,  as=AcceptanceStrategy full.class.path "
                                + "and bs=BiddingStrategy full.class.path. "
                                + "Builds a BOA party running on SAOP.";
        }

        @SuppressWarnings("unchecked")
        @Override
        public void notifyChange(Inform info) {
                try {
                        if (info instanceof Settings) {
                                Settings settings = (Settings) info;
                                this.profileint = ProfileConnectionFactory
                                                .create(settings.getProfile().getURI(), getReporter());
                                Class<BiddingStrategy> bsClass = (Class<BiddingStrategy>) Class
                                                .forName((String) settings.getParemeters().get("bs"));
                                Class<AcceptanceStrategy> asClass = (Class<AcceptanceStrategy>) Class
                                                .forName((String) settings.getParemeters().get("as"));
                                Class<OpponentModel> omClass = (Class<OpponentModel>) Class
                                                .forName((String) settings.getParemeters().get("om"));
                                ;
                                biddingStrategy = bsClass.newInstance();
                                negoState = negoState.with(settings.getProgress(),
                                                settings.getID(), asClass, omClass, reporter);
                                return;
                        }

                        // Beyond this point the biddingStrategy should contain profile
                        if (negoState.getProfile() == null) {
                                negoState = negoState.with(profileint.getProfile());
                        }

                        if (info instanceof ActionDone) {
                                negoState = negoState.with(((ActionDone) info).getAction());
                        } else if (info instanceof YourTurn) {
                                waitAndAct();
                        } else if (info instanceof Finished) {
                                getReporter().log(Level.INFO, "Final ourcome:" + info);
                        }
                } catch (DeploymentException | IOException | ClassNotFoundException
                                | InstantiationFailedException | InstantiationException
                                | IllegalAccessException e) {
                        throw new RuntimeException("Failed to handle info", e);
                }

        }

        /**
         * If current time > {@link BiddingStrategy#getActionTime()} then execute
         * the action of the biddingStrategy. Otherwise, wait the specified time and
         * retry.
         */
        private void waitAndAct() {
                Long actionTime = biddingStrategy.getActionTime(negoState);
                if (System.currentTimeMillis() > actionTime) {
                        try {
                                getConnection().send(biddingStrategy.getAction(negoState));
                        } catch (IOException e) {
                                getReporter().log(Level.SEVERE,
                                                "Failed to execute action, connection may be broken?");
                                e.printStackTrace();
                        }
                } else {
                        // wait specified time and retry
                        new Timer().schedule(new TimerTask() {
                                @Override
                                public void run() {
                                        waitAndAct();
                                }
                        }, new Date(actionTime));
                }
        }

}