source: src/main/java/geniusweb/profilesserver/websocket/GetProfileSocket.java@ 16

package geniusweb.profilesserver.websocket;

import java.io.IOException;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.stream.Collectors;

import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;

import geniusweb.bidspace.AllBidsList;
import geniusweb.bidspace.BidsWithUtility;
import geniusweb.issuevalue.Bid;
import geniusweb.profile.DefaultPartialOrdering;
import geniusweb.profile.PartialOrdering;
import geniusweb.profile.Profile;
import geniusweb.profile.utilityspace.LinearAdditive;
import geniusweb.profilesserver.Jackson;
import geniusweb.profilesserver.ProfilesRepository;
import geniusweb.profilesserver.events.ChangeEvent;
import tudelft.utilities.immutablelist.FixedList;
import tudelft.utilities.immutablelist.ImmutableList;
import tudelft.utilities.listener.Listener;

/**
 * Returns a websocket that communicates the list of currently available domains
 * and profiles. Every time something changes, a new list of domains and
 * profiles is sent. For each new websocket the server will create one of this
 * but they all share one {@link ProfilesRepository}.
 * 
 * <p>
 * Query string: the websocket allows query strings.
 * <ul>
 * <li>partial</li> a query key that is assigned a natural number N (0 or
 * larger). If set, the profile is converted into a Partial Profile with the
 * given number of points. If N>0, the maximum utility bid is included .If N>1,
 * the minimum utility bid is included. The other bids are picked at random.
 * This filtering mechanism only works if the profile is {@link LinearAdditive}
 * space. The reservation bid is passed through unmodified.
 */
@ServerEndpoint("/websocket/get/{domain}/{profile}")
public class GetProfileSocket {
        private Profile prof = null; // the latest that we sent to client.

        // should all be final, except that we can only set them when start is
        // called...
        private String profilename;
        private Listener<ChangeEvent> changeListener;
        private Session session;
        private Map<String, String> params = Collections.emptyMap();

        @OnOpen
        public void start(Session session, @PathParam("domain") final String domain,
                        @PathParam("profile") final String profile) throws IOException {
                this.session = session;
                this.profilename = domain + "/" + profile;

                if (session.getQueryString() != null) {
                        List<String> paramstrings = Arrays
                                        .asList(session.getQueryString().split("&"));
                        params = paramstrings.stream().map(str -> str.split("=")).collect(
                                        Collectors.toMap(vals -> vals[0], vals -> vals[1]));
                }
                changeListener = new Listener<ChangeEvent>() {
                        @Override
                        public void notifyChange(ChangeEvent data) {
                                sendupdatedProfile();
                        }
                };
                sendupdatedProfile();
                Profiles.repository.addListener(changeListener);
        }

        private void sendupdatedProfile() {
                Profile newprof = Profiles.repository.getProfile(profilename);
                // notice, may be null if profile does not exist/was removed.
                if (newprof == null ? prof != null : !newprof.equals(prof)) {
                        prof = newprof;
                        try {
                                session.getBasicRemote().sendText(
                                                Jackson.instance().writeValueAsString(filter(prof)));
                        } catch (Exception e) {
                                e.printStackTrace();
                        }
                }
        }

        /**
         * 
         * @param prof1
         * @return a filtered profile. If "partial" is not set, this returns the
         *         given profile unmodified. If partial is set, a
         *         DefaultPartialOrdering with the requested number of bids are
         *         selected
         */
        private Profile filter(Profile prof1) {
                String partial = params.get("partial");
                if (partial == null) {
                        return prof1;
                }
                if (!(prof1 instanceof PartialOrdering))
                        throw new IllegalArgumentException(
                                        "profile must be partialordering but got " + prof);
                PartialOrdering profile = (PartialOrdering) prof1;
                final int numbids = Integer.parseInt(partial);
                if (numbids < 0)
                        throw new IllegalArgumentException("parameter partial must be >=0");

                ImmutableList<Bid> allbids;
                if (profile instanceof DefaultPartialOrdering)
                        allbids = new FixedList<Bid>(
                                        ((DefaultPartialOrdering) profile).getBids());
                else
                        allbids = new AllBidsList(prof.getDomain());

                if (BigInteger.valueOf(numbids).compareTo(allbids.size()) > 0)
                        throw new IllegalArgumentException("Request for " + numbids
                                        + " exceeds number of bids in the space " + allbids.size());

                BidsWithUtility info = new BidsWithUtility((LinearAdditive) prof);
                Set<Bid> selected = new HashSet<>();
                if (numbids > 0) {
                        selected.add(info.getExtremeBid(true));
                }
                if (numbids > 1) {
                        selected.add(info.getExtremeBid(false));
                }
                Random random = new Random();
                for (int nr = 2; nr < numbids; nr++) {
                        int attempt = 0;
                        Bid bid;
                        do {
                                long i = random.nextInt(allbids.size().intValue());
                                bid = allbids.get(BigInteger.valueOf(i));
                        } while (attempt++ < 10 && selected.contains(bid));
                        selected.add(bid);
                }

                // put comparison info for these bids in the map
                Map<Bid, Set<Bid>> isBetterMap = new HashMap<>();
                for (Bid bid : selected) {
                        Set<Bid> worse = selected.stream().filter(
                                        otherbid -> profile.isPreferredOrEqual(bid, otherbid)
                                                        && !profile.isPreferredOrEqual(otherbid, bid))
                                        .collect(Collectors.toSet());
                        isBetterMap.put(bid, worse);
                }
                return new DefaultPartialOrdering(
                                prof.getName() + "-partial-" + numbids, prof.getDomain(),
                                prof.getReservationBid(), isBetterMap);
        }

        @OnClose
        public void end() throws IOException {
                Profiles.repository.removeListener(changeListener);
        }

        @OnError
        public void onError(Throwable t) throws Throwable {
                t.printStackTrace();
        }

}