// package com.orbekk.same;
// 
// import java.util.List;
// import java.util.LinkedList;
// import java.util.Map;
// import java.util.HashMap;
// import org.slf4j.Logger;
// import org.slf4j.LoggerFactory;
// 
// /**
//  * The implementation of a 'Same' state.
//  *
//  * This class manages the current state of the Same protocol.
//  */
// public class SameState extends Thread implements UrlReceiver {
//     private Logger logger = LoggerFactory.getLogger(getClass());
//     private ConnectionManager connections;
//     
//     // TODO: Change the name of State.
//     private com.orbekk.same.State state =
//             new com.orbekk.same.State();
// 
//     /**
//      * The client id of this participant.
//      */
//     private String clientId;
// 
//     /**
//      * Stopping condition for this thread.
//      */
//     private boolean stopped = false;
// 
//     private String _setState = null;
//     private Map<String, String> _setParticipants = null;
// 
//     private Map<String, String> pendingParticipants =
//             new HashMap<String, String>();
// 
//     public SameState(String networkName, String clientId,
//             ConnectionManager connections) {
//         state.setNetworkName(networkName);
//         this.clientId = clientId;
//         this.connections = connections;
//         state.setMasterId(clientId);
//         state.getParticipants().put(clientId, null);
//     }
// 
//     public String getMasterId() {
//         return state.getMasterId();
//     }
// 
//     public synchronized Map<String, String> getParticipants() {
//         return state.getParticipants();
//     }
// 
//     /**
//      * Reset this SameService to an initial state.
//      *
//      * TODO: Implement fully.
//      */
//     private synchronized void resetState() {
//         state = new com.orbekk.same.State();
//         pendingParticipants.clear();
//     }
// 
//     public synchronized void joinNetwork(String networkName, String masterId) {
//         resetState();
//         state.setNetworkName(networkName);
//         state.setMasterId(masterId);
//         logger.info("Joined network {}.", networkName);
//     }
// 
//     public String getClientId() {
//         return clientId;
//     }
// 
//     public String getNetworkName() {
//         return state.getNetworkName();
//     }
// 
//     public String getCurrentState() {
//         return state.getData();
//     }
// 
//     /**
//      * TODO: Move to a separate library.
//      */
//     public void librarySetNewState(String newState) {
//         connections.getConnection(
//                 state.getParticipants().get(state.getMasterId()))
//                 .setState(newState);
//     }
// 
//     public String getUrl() {
//         return state.getParticipants().get(clientId);
//     }
// 
//     @Override
//     public void setUrl(String url) {
//         logger.info("My URL is {}", url);
//         state.getParticipants().put(clientId, url);
//     }
// 
//     public synchronized void addParticipant(String clientId, String url) {
//         logger.info("PendingParticipant.add: {} ({})", clientId, url);
//         pendingParticipants.put(clientId, url);
//         notifyAll();
//     }
// 
//     public synchronized void setParticipants(Map<String, String> participants) {
//         logger.info("Pending operation: _setParticipants");
//         _setParticipants = participants;
//         notifyAll();
//     }
// 
//     public synchronized void setState(String newState) {
//         logger.info("Pending operation: _setState");
//         _setState = newState;
//         notifyAll();
//     }
// 
//     private synchronized void handleSetParticipants() {
//         if (_setParticipants != null) {
//             if (isMaster()) {
//                 logger.error("{}: Master received setParticipants.", clientId);
//             } else {
//                 logger.info("{}: New participants committed.", clientId);
//                 state.getParticipants().clear();
//                 state.getParticipants().putAll(_setParticipants);
//             }
//         }
//         _setParticipants = null;
//     }
// 
//     public synchronized void handleSetState() {
//         if (_setState != null) {
//             if (isMaster()) {
//                 broadcast(new ServiceOperation() {
//                     @Override void run(SameService service) {
//                         service.setState(_setState);
//                     }
//                 });
//             }
//             state.setData(_setState);
//             _setState = null;
//         }
//     }
// 
//     private boolean isMaster() {
//         return state.getMasterId().equals(clientId);
//     }
// 
//     private synchronized void handleNewParticipants() {
//         if (!isMaster()) {
//             for (Map.Entry<String, String> e : pendingParticipants.entrySet()) {
//                 SameService master = connections.getConnection(
//                         state.getParticipants().get(state.getMasterId()));
//                 logger.info("Redirecting participant request to {}",
//                         state.getMasterId());
//                 String clientId = e.getKey();
//                 String url = e.getValue();
//                 master.participateNetwork(state.getNetworkName(), clientId,
//                         url);
//             }
//         } else {
//             state.getParticipants().putAll(pendingParticipants);
//             for (Map.Entry<String, String> e :
//                     pendingParticipants.entrySet()) {
//                 String clientId = e.getKey();
//                 String url = e.getValue();
//                 logger.info("New participant: {} URL({})", clientId, url);
//                 SameService remoteService = connections.getConnection(url);
//                 remoteService.notifyParticipation(state.getNetworkName(),
//                         state.getMasterId());
//                 broadcast(new ServiceOperation(){
//                     @Override void run(SameService service) {
//                         service.setParticipants(state.getParticipants());
//                     }
//                 });
//             }
//         }
//         pendingParticipants.clear();
//     }
// 
//     /**
//      * This method runs the pending commands to SameState.
//      *
//      * It should be called by the worker thread, but can be called directly
//      * for testing purposes to avoid threading in unit tests.
//      */
//     synchronized void internalRun() {
//         handleNewParticipants();
//         handleSetState();
//         handleSetParticipants();
//     }
// 
//     public synchronized void run() {
//         while (!stopped) {
//             internalRun();
//             try {
//                 wait(1000);
//             } catch (InterruptedException e) {
//                 // Ignore interrupt in wait loop.
//             }
//         }
//     }
// 
//     public synchronized void stopSame() {
//         try {
//             stopped = true;
//             notifyAll();
//             this.join();
//         } catch (InterruptedException e) {
//             logger.warn("Got InterruptedException while waiting for SameState " +
//                     "to finish. Ignoring.");
//         }
//     }
// 
//     public abstract static class ServiceOperation {
//         abstract void run(SameService service);
//     }
//     
//     public synchronized void broadcast(ServiceOperation operation) {
//         for (Map.Entry<String, String> e :
//                 state.getParticipants().entrySet()) {
//             String clientId = e.getKey();
//             String url = e.getValue();
//             if (!clientId.equals(this.clientId)) {
//                 operation.run(connections.getConnection(url));
//             }
//         }
//     }
// }