/*******************************************************************************
 * Copyright (c) 2004 Peter Nehrer and Composent, Inc.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     Peter Nehrer - initial API and implementation
 *******************************************************************************/
package org.eclipse.ecf.example.sdo.editor;

import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import org.eclipse.ecf.core.events.IContainerConnectedEvent;
import org.eclipse.ecf.core.events.IContainerDisconnectedEvent;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.sharedobject.ISharedObject;
import org.eclipse.ecf.core.sharedobject.ISharedObjectConfig;
import org.eclipse.ecf.core.sharedobject.ISharedObjectContext;
import org.eclipse.ecf.core.sharedobject.ReplicaSharedObjectDescription;
import org.eclipse.ecf.core.sharedobject.SharedObjectInitException;
import org.eclipse.ecf.core.sharedobject.events.ISharedObjectActivatedEvent;
import org.eclipse.ecf.core.sharedobject.events.ISharedObjectCreateResponseEvent;
import org.eclipse.ecf.core.sharedobject.events.ISharedObjectDeactivatedEvent;
import org.eclipse.ecf.core.sharedobject.events.ISharedObjectMessageEvent;
import org.eclipse.ecf.core.util.ECFException;
import org.eclipse.ecf.core.util.Event;

/**
 * <p>
 * Tracks explicit data graph publication (or any shared object presence,
 * really) across all containers in a connected group using the server replica
 * to bootstrap new members.
 * </p>
 * <p>
 * It works something like this:
 * </p>
 * <ul>
 * <li>The container should first check if an instance of this shared object
 * already exists in their container. If not, create one and add it.</li>
 * <li>The container should call {@link #add(ID) add()}once published/subscribed
 * to a data graph. The method will block until this object activates (if it
 * hasn't already).</li>
 * <li>Upon activation, the primary instance replicates everywhere. This is to
 * assure that there is a server replica (and a replica in the initial set of
 * connected containers).</li>
 * <li>When a new container joins the group, the server will create a replica
 * in it, initialized with its current graph location table. This is to assure
 * that new members are properly bootstrapped.</li>
 * <li>All replicas broadcast additions/removals of their local data graphs and
 * listen to remote additions/removals in order to keep track of what is
 * published and where.</li>
 * <li>When a container leaves the group, all replicas note it and update their
 * graph location tables. Likewise, when a replica deactivates, it broadcasts
 * its departure so others may update their tables.</li>
 * </ul>
 * <p>
 * It is assumed that the container implementation used with this class is
 * server-centric. That is, there is a server that is always connected before
 * any other container may connect. When the server disconnects, everyone else
 * in effect disconnects.
 * </p>
 * 
 * @author pnehrer
 */
public class PublishedGraphTracker implements ISharedObject {

	private static final ID[] NO_GRAPHS = {};

	private static final int ADD = 0;

	private static final int REMOVE = 1;

	private static final int LEAVE = 2;

	private static final String ARG_TABLE = "table";

	private class Table {

		private final Hashtable graphs = new Hashtable();

		private final Hashtable containers = new Hashtable();

		public synchronized void add(ID containerID, ID graphID) {
			HashSet list = (HashSet) graphs.get(containerID);
			if (list == null) {
				list = new HashSet();
				graphs.put(containerID, list);
			}

			list.add(graphID);
			list = (HashSet) containers.get(containerID);
			if (list == null) {
				list = new HashSet();
				containers.put(graphID, list);
			}

			list.add(containerID);
		}

		public synchronized void remove(ID containerID, ID graphID) {
			HashSet list = (HashSet) graphs.get(containerID);
			if (list != null) {
				list.remove(graphID);
				if (list.isEmpty())
					graphs.remove(containerID);
			}

			list = (HashSet) containers.get(graphID);
			if (list != null) {
				list.remove(containerID);
				if (list.isEmpty())
					containers.remove(graphID);
			}
		}

		public synchronized void remove(ID containerID) {
			HashSet list = (HashSet) graphs.get(containerID);
			if (list != null) {
				for (Iterator i = list.iterator(); i.hasNext();) {
					ID graphID = (ID) i.next();
					list = (HashSet) containers.get(graphID);
					if (list != null) {
						list.remove(containerID);
						if (list.isEmpty())
							containers.remove(graphID);
					}
				}
			}
		}

		public synchronized boolean contains(ID graphID) {
			return containers.containsKey(graphID);
		}

		public synchronized ID[] getGraphs(ID containerID) {
			HashSet list = (HashSet) graphs.get(containerID);
			return list == null ? NO_GRAPHS : (ID[]) list.toArray(new ID[list
					.size()]);
		}

		public synchronized Object createMemento() {
			return new Hashtable[] { graphs, containers };
		}

		public synchronized void load(Object memento) {
			Hashtable[] tables = (Hashtable[]) memento;
			graphs.putAll(tables[0]);
			containers.putAll(tables[1]);
		}
	}

	private final Table table = new Table();

	private ISharedObjectConfig config;

	private ISharedObjectContext context;

	private final Object activationMutex = new Object();

	private boolean activated;

	/**
	 * Adds a graph to the list of published graphs.
	 * 
	 * @param graphID
	 *            identifier of the graph that was published
	 * @throws ECFException
	 */
	public synchronized void add(ID graphID) throws ECFException {
		if (config == null)
			throw new ECFException("Not initialized.");

		// wait to be activated before proceeding
		synchronized (activationMutex) {
			if (!activated)
				try {
					activationMutex.wait(1000);
				} catch (InterruptedException e) {
					throw new ECFException(e);
				}

			if (!activated)
				throw new ECFException("Not activated.");
		}

		// tell everyone a graph was published
		try {
			getContext().sendMessage(null,
					new Object[] { new Integer(ADD), graphID });
		} catch (IOException e) {
			throw new ECFException(e);
		}

		// track it yourself
		handleAdd(getContext().getLocalContainerID(), graphID);
	}

	/**
	 * Answers whether a graph is published (at the time of invocation).
	 * 
	 * @param graphID
	 *            identifier of the graph whose publishing status to return
	 * @return <code>true</code> if the graph is published
	 */
	public synchronized boolean isPublished(ID graphID) {
		return table.contains(graphID);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ecf.core.ISharedObject#init(org.eclipse.ecf.core.ISharedObjectConfig)
	 */
	public synchronized void init(ISharedObjectConfig initData)
			throws SharedObjectInitException {
		if (config == null)
			config = initData;
		else
			throw new SharedObjectInitException("Already initialized.");

		Map props = (Map) config.getProperties();
		if (props != null) {
			Object memento = props.get(ARG_TABLE);
			if (memento != null)
				table.load(memento);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ecf.core.ISharedObject#handleEvent(org.eclipse.ecf.core.util.Event)
	 */
	public void handleEvent(Event event) {
		if (event instanceof ISharedObjectCreateResponseEvent) {
			// Ignore
		} else if (event instanceof ISharedObjectMessageEvent) {
			// track graph additions/removals and peer departures
			// (deactivations)
			ISharedObjectMessageEvent e = (ISharedObjectMessageEvent) event;
			Object[] data = (Object[]) e.getData();
			Integer type = (Integer) data[0];
			switch (type.intValue()) {
			case ADD:
				handleAdd(e.getRemoteContainerID(), (ID) data[1]);
				break;

			case REMOVE:
				handleRemove(e.getRemoteContainerID(), (ID) data[1]);
				break;

			case LEAVE:
				handleLeave(e.getRemoteContainerID());
				break;
			}
		} else if (event instanceof IContainerConnectedEvent) {
			IContainerConnectedEvent e = (IContainerConnectedEvent) event;
			if (e.getTargetID().equals(
					getContext().getLocalContainerID()))
				// this container joined
				handleJoined();
			else if (getContext().isGroupManager())
				// some other container joined and we're the server
				handleJoined(e.getTargetID());
		} else if (event instanceof IContainerDisconnectedEvent) {
			IContainerDisconnectedEvent e = (IContainerDisconnectedEvent) event;
			// some other container departed -- same as peer deactivation
			if (!e.getTargetID().equals(
					getContext().getLocalContainerID()))
				handleLeave(e.getTargetID());
		} else if (event instanceof ISharedObjectActivatedEvent) {
			ISharedObjectActivatedEvent e = (ISharedObjectActivatedEvent) event;
			if (e.getActivatedID().equals(config.getSharedObjectID()))
				// we're being activated
				handleActivated();
		} else if (event instanceof ISharedObjectDeactivatedEvent) {
			ISharedObjectDeactivatedEvent e = (ISharedObjectDeactivatedEvent) event;
			if (e.getDeactivatedID().equals(config.getSharedObjectID()))
				// we're being deactivated
				handleDeactivated();
			else if (table.contains(e.getDeactivatedID()))
				// a local graph we track is being deactivated
				handleRemoved(e.getDeactivatedID());
		}
	}

	private void handleAdd(ID containerID, ID graphID) {
		table.add(containerID, graphID);
	}

	private void handleRemove(ID containerID, ID graphID) {
		table.remove(containerID, graphID);
	}

	private void handleLeave(ID containerID) {
		table.remove(containerID);
	}

	private void handleJoined() {
		if (config.getHomeContainerID().equals(
				getContext().getLocalContainerID())) {
			// we're the primary copy -- replicate everywhere
			try {
				getContext().sendCreate(
						null,
						new ReplicaSharedObjectDescription(getClass(),config.getSharedObjectID(),
								config.getHomeContainerID()));
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	private void handleJoined(ID containerID) {
		Map props = new HashMap(1);
		props.put(ARG_TABLE, table.createMemento());
		try {
			getContext().sendCreate(
					containerID,
					new ReplicaSharedObjectDescription(getClass(),config.getSharedObjectID(),
							config.getHomeContainerID(), props));
		} catch (IOException ex) {
			// TODO Auto-generated catch block
			ex.printStackTrace();
		}
	}

	private void handleActivated() {
		handleJoined();
		synchronized (activationMutex) {
			activated = true;
			activationMutex.notifyAll();
		}
	}

	private void handleDeactivated() {
		try {
			getContext().sendMessage(null, new Object[] { new Integer(LEAVE) });
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		synchronized (activationMutex) {
			activated = false;
			activationMutex.notifyAll();
		}
	}

	private void handleRemoved(ID graphID) {
		try {
			getContext().sendMessage(null,
					new Object[] { new Integer(REMOVE), graphID });
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		handleRemove(getContext().getLocalContainerID(), graphID);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ecf.core.ISharedObject#handleEvents(org.eclipse.ecf.core.util.Event[])
	 */
	public void handleEvents(Event[] events) {
		for (int i = 0; i < events.length; ++i)
			handleEvent(events[i]);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ecf.core.ISharedObject#dispose(org.eclipse.ecf.core.identity.ID)
	 */
	public synchronized void dispose(ID containerID) {
		config = null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.core.runtime.PlatformObject#getAdapter(java.lang.Class)
	 */
	public Object getAdapter(Class adapter) {
		return null;
	}

	private ISharedObjectContext getContext() {
		if (context == null)
			context = config.getContext();

		return context;
	}
}