/*******************************************************************************
 * Copyright (c) 2004 Composent, Inc. and others. 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: Composent, Inc. - initial API and implementation
 ******************************************************************************/
package org.eclipse.ecf.internal.provider.xmpp;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;

import org.eclipse.core.runtime.IAdapterManager;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.identity.IDFactory;
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.SharedObjectInitException;
import org.eclipse.ecf.core.sharedobject.events.ISharedObjectActivatedEvent;
import org.eclipse.ecf.core.sharedobject.events.ISharedObjectMessageEvent;
import org.eclipse.ecf.core.sharedobject.events.ISharedObjectMessageListener;
import org.eclipse.ecf.core.user.IUser;
import org.eclipse.ecf.core.user.User;
import org.eclipse.ecf.core.util.AsyncResult;
import org.eclipse.ecf.core.util.ECFException;
import org.eclipse.ecf.core.util.Event;
import org.eclipse.ecf.core.util.IAsyncResult;
import org.eclipse.ecf.core.util.ICallable;
import org.eclipse.ecf.internal.provider.xmpp.events.IQEvent;
import org.eclipse.ecf.internal.provider.xmpp.events.MessageEvent;
import org.eclipse.ecf.internal.provider.xmpp.events.PresenceEvent;
import org.eclipse.ecf.internal.provider.xmpp.smack.ECFConnection;
import org.eclipse.ecf.presence.IPresence;
import org.eclipse.ecf.presence.IPresenceListener;
import org.eclipse.ecf.presence.IPresenceSender;
import org.eclipse.ecf.presence.im.IChatManager;
import org.eclipse.ecf.presence.im.ITypingMessage;
import org.eclipse.ecf.presence.im.TypingMessage;
import org.eclipse.ecf.presence.roster.AbstractRosterManager;
import org.eclipse.ecf.presence.roster.IRosterEntry;
import org.eclipse.ecf.presence.roster.IRosterGroup;
import org.eclipse.ecf.presence.roster.IRosterItem;
import org.eclipse.ecf.presence.roster.IRosterManager;
import org.eclipse.ecf.presence.roster.IRosterSubscriptionSender;
import org.eclipse.ecf.provider.xmpp.XMPPContainer;
import org.eclipse.ecf.provider.xmpp.identity.XMPPID;
import org.eclipse.ecf.provider.xmpp.identity.XMPPRoomID;
import org.jivesoftware.smack.Roster;
import org.jivesoftware.smack.RosterEntry;
import org.jivesoftware.smack.RosterGroup;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.packet.IQ;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smack.packet.RosterPacket;
import org.jivesoftware.smack.packet.Presence.Mode;
import org.jivesoftware.smack.packet.Presence.Type;
import org.jivesoftware.smackx.packet.VCard;

public class XMPPContainerPresenceHelper implements ISharedObject {

	public static final String VCARD = "vcard";
	public static final String VCARD_EMAIL = VCARD + ".email";
	public static final String VCARD_EMAIL_HOME = VCARD_EMAIL + ".home";
	public static final String VCARD_EMAIL_WORK = VCARD_EMAIL + ".work";
	public static final String VCARD_NAME = VCARD + ".name";
	public static final String VCARD_NAME_FIRST = VCARD_NAME + ".first";
	public static final String VCARD_NAME_MIDDLE = VCARD_NAME + ".middle";
	public static final String VCARD_NAME_LAST = VCARD_NAME + ".last";
	public static final String VCARD_NAME_NICK = VCARD_NAME + ".nick";
	public static final String VCARD_PHONE = VCARD + ".phone";
	public static final String VCARD_PHONE_HOME = VCARD_PHONE + ".home";
	public static final String VCARD_PHONE_HOME_VOICE = VCARD_PHONE_HOME + ".voice";
	public static final String VCARD_PHONE_HOME_CELL = VCARD_PHONE_HOME + ".cell";
	public static final String VCARD_PHONE_WORK = VCARD_PHONE + ".work";
	public static final String VCARD_PHONE_WORK_VOICE = VCARD_PHONE_WORK + ".voice";
	public static final String VCARD_PHONE_WORK_CELL = VCARD_PHONE_WORK + ".cell";

	private ISharedObjectConfig config = null;

	private final List sharedObjectMessageListeners = new ArrayList();

	private XMPPContainer container = null;

	private XMPPChatManager chatManager = null;

	private final List presenceListeners = new ArrayList();

	public XMPPContainerPresenceHelper(XMPPContainer container) {
		this.container = container;
		chatManager = new XMPPChatManager(this);
		roster = new org.eclipse.ecf.presence.roster.Roster(container);
		rosterManager = new PresenceRosterManager(roster);
	}

	// ISharedObject implementation

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ecf.core.ISharedObject#init(org.eclipse.ecf.core.ISharedObjectConfig)
	 */
	public void init(ISharedObjectConfig initData) throws SharedObjectInitException {
		this.config = initData;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ecf.core.ISharedObject#handleEvent(org.eclipse.ecf.core.util.Event)
	 */
	public void handleEvent(Event event) {
		trace("handleEvent(" + event + ")");
		if (event instanceof ISharedObjectActivatedEvent) {
		} else if (event instanceof IQEvent) {
			handleIQEvent((IQEvent) event);
		} else if (event instanceof MessageEvent) {
			handleMessageEvent((MessageEvent) event);
		} else if (event instanceof PresenceEvent) {
			handlePresenceEvent((PresenceEvent) event);
		} else if (event instanceof ISharedObjectMessageEvent) {
			handleSharedObjectMessageEvent((ISharedObjectMessageEvent) event);
		} else {
			trace("unhandled event=" + event);
		}
	}

	/*
	 * (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]);
		}
	}

	public void disconnect() {
		rosterManager.disconnect();
		chatManager.disconnect();
		synchronized (sharedObjectMessageListeners) {
			sharedObjectMessageListeners.clear();
		}
		synchronized (presenceListeners) {
			presenceListeners.clear();
		}
		vcardCache.clear();
	}

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

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ecf.core.ISharedObject#getAdapter(java.lang.Class)
	 */
	public Object getAdapter(Class adapter) {
		if (adapter == null)
			return null;
		if (adapter.isInstance(this))
			return this;
		final IAdapterManager adapterManager = XmppPlugin.getDefault().getAdapterManager();
		return (adapterManager == null) ? null : adapterManager.loadAdapter(this, adapter.getName());
	}

	// end ISharedObject implementation

	protected org.eclipse.ecf.presence.roster.Roster roster;

	protected PresenceRosterManager rosterManager;

	class PresenceRosterManager extends AbstractRosterManager {

		public PresenceRosterManager(org.eclipse.ecf.presence.roster.Roster roster) {
			super(roster);
		}

		public void notifySubscriptionListener(ID fromID, IPresence presence) {
			this.fireSubscriptionListener(fromID, presence.getType());
		}

		public void notifyRosterUpdate(IRosterItem changedItem) {
			fireRosterUpdate(changedItem);
		}

		public void notifyRosterAdd(IRosterEntry entry) {
			fireRosterAdd(entry);
		}

		public void notifyRosterRemove(IRosterEntry entry) {
			fireRosterRemove(entry);
		}

		public void disconnect() {
			getRoster().getItems().clear();
			super.disconnect();
			fireRosterUpdate(roster);
		}

		public void setUser(IUser user) {
			final org.eclipse.ecf.presence.roster.Roster roster = (org.eclipse.ecf.presence.roster.Roster) getRoster();
			roster.setUser(user);
			notifyRosterUpdate(roster);
		}

		org.eclipse.ecf.presence.IPresenceSender rosterPresenceSender = new org.eclipse.ecf.presence.IPresenceSender() {
			public void sendPresenceUpdate(ID toID, org.eclipse.ecf.presence.IPresence presence) throws ECFException {
				try {
					getConnectionOrThrowIfNull().sendPresenceUpdate(toID, createPresence(presence));
				} catch (final IOException e) {
					traceAndThrowECFException("sendPresenceUpdate", e);
				}
			}

		};

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.ecf.presence.roster.AbstractRosterManager#getPresenceSender()
		 */
		public IPresenceSender getPresenceSender() {
			return rosterPresenceSender;
		}

		org.eclipse.ecf.presence.roster.IRosterSubscriptionSender rosterSubscriptionSender = new org.eclipse.ecf.presence.roster.IRosterSubscriptionSender() {
			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.ecf.presence.roster.IRosterSubscriptionSender#sendRosterAdd(java.lang.String,
			 *      java.lang.String, java.lang.String[])
			 */
			public void sendRosterAdd(String user, String name, String[] groups) throws ECFException {
				try {
					getConnectionOrThrowIfNull().sendRosterAdd(user, name, groups);
				} catch (final Exception e) {
					traceAndThrowECFException("sendRosterAdd", e);
				}
			}

			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.ecf.presence.roster.IRosterSubscriptionSender#sendRosterRemove(org.eclipse.ecf.core.identity.ID)
			 */
			public void sendRosterRemove(ID userID) throws ECFException {
				try {
					if (!(userID instanceof XMPPID))
						throw new ECFException("invalid userID");
					final XMPPID xmppID = (XMPPID) userID;
					getConnectionOrThrowIfNull().sendRosterRemove(xmppID.getUsernameAtHost());
				} catch (final Exception e) {
					traceAndThrowECFException("sendRosterRemove", e);
				}
			}

		};

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.ecf.presence.roster.AbstractRosterManager#getRosterSubscriptionSender()
		 */
		public IRosterSubscriptionSender getRosterSubscriptionSender() {
			return rosterSubscriptionSender;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.ecf.presence.roster.IRosterManager#addPresenceListener(org.eclipse.ecf.presence.roster.IPresenceListener)
		 */
		public void addPresenceListener(IPresenceListener listener) {
			synchronized (presenceListeners) {
				presenceListeners.add(listener);
			}
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.ecf.presence.roster.IRosterManager#removePresenceListener(org.eclipse.ecf.presence.roster.IPresenceListener)
		 */
		public void removePresenceListener(IPresenceListener listener) {
			synchronized (presenceListeners) {
				presenceListeners.add(listener);
			}
		}

	}

	/**
	 * @return IRosterManager roster manager. Will not return <code>null</code>.
	 */
	public IRosterManager getRosterManager() {
		return rosterManager;
	}

	/**
	 * @param user
	 *            set the user for this presence helper.
	 */
	public void setUser(IUser user) {
		rosterManager.setUser(user);
	}

	protected void addSharedObjectMessageListener(ISharedObjectMessageListener listener) {
		synchronized (sharedObjectMessageListeners) {
			sharedObjectMessageListeners.add(listener);
		}
	}

	protected void sendTypingMessage(ID toID, boolean isTyping, String body) throws IOException {
		getContext().sendMessage(toID, new TypingMessage(rosterManager.getRoster().getUser().getID(), isTyping, body));
	}

	protected void handleSharedObjectMessageEvent(ISharedObjectMessageEvent event) {
		List toNotify = null;
		synchronized (sharedObjectMessageListeners) {
			toNotify = new ArrayList(sharedObjectMessageListeners);
		}
		for (final Iterator i = toNotify.iterator(); i.hasNext();) {
			final ISharedObjectMessageListener l = (ISharedObjectMessageListener) i.next();
			l.handleSharedObjectMessage(event);
		}

		final Object data = event.getData();
		if (data instanceof ITypingMessage) {
			final ITypingMessage tmess = (ITypingMessage) data;
			chatManager.fireTypingMessage(tmess.getFromID(), tmess);
		}

	}

	protected void removeSharedObjectMessageListener(ISharedObjectMessageListener listener) {
		synchronized (sharedObjectMessageListeners) {
			sharedObjectMessageListeners.remove(listener);
		}
	}

	private void addToRoster(IRosterItem[] items) {
		for (int i = 0; i < items.length; i++) {
			roster.addItem(items[i]);
		}
		rosterManager.notifyRosterUpdate(roster);
	}

	protected ISharedObjectContext getContext() {
		return config.getContext();
	}

	protected String getUserNameFromXMPPAddress(XMPPID userID) {
		return userID.getUsername();
	}

	protected IRosterEntry createRosterEntry(RosterEntry entry) {
		return createRosterEntry(createIDFromName(entry.getUser()), entry.getName(), entry.getGroups());
	}

	protected IRosterEntry createRosterEntry(RosterPacket.Item entry) {
		return createRosterEntry(createIDFromName(entry.getUser()), entry.getName(), entry.getGroupNames());
	}

	protected void handleIQEvent(IQEvent evt) {
		final IQ iq = evt.getIQ();
		if (iq instanceof RosterPacket) {
			// Roster packet...report to UI
			final RosterPacket rosterPacket = (RosterPacket) iq;
			if (rosterPacket.getType() == IQ.Type.SET || rosterPacket.getType() == IQ.Type.RESULT) {
				for (final Iterator i = rosterPacket.getRosterItems(); i.hasNext();) {
					final RosterPacket.Item item = (RosterPacket.Item) i.next();
					final RosterPacket.ItemType itemType = item.getItemType();
					boolean remove = false;
					final IRosterItem items[] = createRosterEntries(item);
					final IRosterEntry entry = createRosterEntry(item);
					if (itemType == RosterPacket.ItemType.NONE || itemType == RosterPacket.ItemType.REMOVE) {
						removeItemFromRoster(roster.getItems(), createIDFromName(item.getUser()));
						remove = true;
					} else {
						remove = false;
						addToRoster(items);
					}
					// In both cases fire set roster entry
					fireSetRosterEntry(remove, entry);
				}
			}
		} else {
			trace("Received non rosterpacket IQ message");
		}
	}

	protected void fireSetRosterEntry(boolean remove, IRosterEntry entry) {
		if (remove)
			rosterManager.notifyRosterRemove(entry);
		else
			rosterManager.notifyRosterAdd(entry);
	}

	private void removeItemFromRoster(Collection rosterItems, XMPPID itemIDToRemove) {
		boolean removed = false;
		synchronized (rosterItems) {
			for (final Iterator i = rosterItems.iterator(); i.hasNext();) {
				final IRosterItem item = (IRosterItem) i.next();
				if (item instanceof org.eclipse.ecf.presence.roster.RosterGroup) {
					final org.eclipse.ecf.presence.roster.RosterGroup group = (org.eclipse.ecf.presence.roster.RosterGroup) item;
					removed = removeItemFromRosterGroup(group, itemIDToRemove);
					// If group is empty, remove it too
					if (group.getEntries().size() == 0)
						i.remove();
				} else if (item instanceof org.eclipse.ecf.presence.roster.RosterEntry) {
					if (((org.eclipse.ecf.presence.roster.RosterEntry) item).getUser().getID().equals(itemIDToRemove)) {
						i.remove();
						removed = true;
					}
				}
			}
		}
		if (removed)
			rosterManager.notifyRosterUpdate(roster);

	}

	private boolean removeItemFromRosterGroup(org.eclipse.ecf.presence.roster.RosterGroup group, XMPPID itemIDToRemove) {
		final Collection groupEntries = group.getEntries();
		synchronized (groupEntries) {
			for (final Iterator i = group.getEntries().iterator(); i.hasNext();) {
				final org.eclipse.ecf.presence.roster.RosterEntry entry = (org.eclipse.ecf.presence.roster.RosterEntry) i.next();
				if (entry.getUser().getID().equals(itemIDToRemove)) {
					i.remove();
					return true;
				}
			}
		}
		return false;
	}

	protected void handleMessageEvent(MessageEvent evt) {
		Message msg = evt.getMessage();
		final String from = msg.getFrom();
		final String body = msg.getBody();
		final String subject = msg.getSubject();
		final ID fromID = createIDFromName(from);
		final ID threadID = createThreadID(msg.getThread());
		msg = filterMessageType(msg);
		if (msg != null) {
			if (msg.getExtension("composing", //$NON-NLS-1$
					"http://jabber.org/protocol/chatstates") != null) { //$NON-NLS-1$
				chatManager.fireTypingMessage(fromID, new TypingMessage(fromID, true, body));
			} else if (msg.getExtension("paused", //$NON-NLS-1$
					"http://jabber.org/protocol/chatstates") != null) { //$NON-NLS-1$
				chatManager.fireTypingMessage(fromID, new TypingMessage(fromID, false, body));
			} else {
				final Iterator xhtmlbodies = evt.getXHTMLBodies();
				if (xhtmlbodies != null) {
					final List xhtmlbodylist = new ArrayList();
					for (; xhtmlbodies.hasNext();)
						xhtmlbodylist.add(xhtmlbodies.next());
					chatManager.fireXHTMLChatMessage(fromID, threadID, msg.getType(), subject, body, ECFConnection.getPropertiesFromPacket(msg), xhtmlbodylist);
				} else if (body != null) {
					chatManager.fireChatMessage(fromID, threadID, msg.getType(), subject, body, ECFConnection.getPropertiesFromPacket(msg));
				}
			}
		}
	}

	protected void handlePresenceEvent(PresenceEvent evt) {
		final Presence xmppPresence = evt.getPresence();
		final String from = xmppPresence.getFrom();
		final IPresence newPresence = createIPresence(xmppPresence);
		final XMPPID fromID = createIDFromName(from);
		if (newPresence.getType().equals(IPresence.Type.SUBSCRIBE) || newPresence.getType().equals(IPresence.Type.UNSUBSCRIBE) || newPresence.getType().equals(IPresence.Type.SUBSCRIBED) || newPresence.getType().equals(IPresence.Type.UNSUBSCRIBED)) {
			rosterManager.notifySubscriptionListener(fromID, newPresence);
		} else {
			updatePresence(fromID, newPresence);
			firePresenceListeners(fromID, newPresence);
		}
	}

	private void firePresenceListeners(ID fromID, IPresence presence) {
		List toNotify = null;
		synchronized (presenceListeners) {
			toNotify = new ArrayList(presenceListeners);
		}
		for (final Iterator i = toNotify.iterator(); i.hasNext();) {
			final IPresenceListener l = (IPresenceListener) i.next();
			l.handlePresence(fromID, presence);
		}
	}

	private void updatePresence(XMPPID fromID, IPresence newPresence) {
		final Collection rosterItems = roster.getItems();
		synchronized (rosterItems) {
			for (final Iterator i = roster.getItems().iterator(); i.hasNext();) {
				final IRosterItem item = (IRosterItem) i.next();
				if (item instanceof IRosterGroup) {
					updatePresenceInGroup((IRosterGroup) item, fromID, newPresence);
				} else if (item instanceof org.eclipse.ecf.presence.roster.RosterEntry) {
					updatePresenceForMatchingEntry((org.eclipse.ecf.presence.roster.RosterEntry) item, fromID, newPresence);
				}
			}
		}
	}

	private void updatePresenceForMatchingEntry(org.eclipse.ecf.presence.roster.RosterEntry entry, XMPPID fromID, IPresence newPresence) {
		final IUser user = entry.getUser();
		if (fromID.equals(user.getID())) {
			entry.setPresence(newPresence);
			rosterManager.notifyRosterUpdate(entry);
		}
	}

	private void updatePresenceInGroup(IRosterGroup group, XMPPID fromID, IPresence newPresence) {
		final Collection groupEntries = group.getEntries();
		synchronized (groupEntries) {
			for (final Iterator i = group.getEntries().iterator(); i.hasNext();) {
				updatePresenceForMatchingEntry((org.eclipse.ecf.presence.roster.RosterEntry) i.next(), fromID, newPresence);
			}
		}
	}

	protected void handleRoster(Roster roster) {
		for (final Iterator i = roster.getEntries(); i.hasNext();) {
			final IRosterItem[] items = createRosterEntries((RosterEntry) i.next());
			for (int j = 0; j < items.length; j++) {
				this.roster.addItem(items[j]);
			}
		}
		rosterManager.notifyRosterUpdate(this.roster);
	}

	protected XMPPID createIDFromName(String uname) {
		try {
			if (uname.indexOf('@') == -1) {
				return new XMPPID(container.getConnectNamespace(), "admin" + "@" + uname);
			}
			return new XMPPID(container.getConnectNamespace(), uname);
		} catch (final Exception e) {
			traceStack("Exception in createIDFromName", e);
			return null;
		}
	}

	protected ID createThreadID(String thread) {
		try {
			if (thread == null || thread.equals(""))
				return null;
			return IDFactory.getDefault().createStringID(thread);
		} catch (final Exception e) {
			traceStack("Exception in createThreadID", e);
			return null;
		}

	}

	private final Map vcardCache = new WeakHashMap();

	private VCard getFromCache(String id) {
		if (id == null)
			return null;
		return (VCard) vcardCache.get(id);
	}

	private void addToCache(String id, VCard card) {
		vcardCache.put(id, card);
	}

	private VCard getVCardForPresence(Presence xmppPresence) {
		VCard result = null;
		if (xmppPresence.getExtension("x", "vcard-temp:x:update") != null) {
			final String from = xmppPresence.getFrom();
			result = getFromCache(from);
			if (result == null && from != null) {
				result = new VCard();
				try {
					result.load(container.getXMPPConnection(), from);
					addToCache(from, result);
				} catch (final XMPPException e) {
					traceStack("vcard loading exception", e);
				}
			}
		}
		return result;
	}

	private Map addVCardProperties(VCard vcard, Map props) {
		if (vcard == null)
			return props;
		final String emailHome = vcard.getEmailHome();
		if (emailHome != null && !emailHome.equals(""))
			props.put(VCARD_EMAIL_HOME, emailHome);
		final String emailWork = vcard.getEmailWork();
		if (emailWork != null && !emailWork.equals(""))
			props.put(VCARD_EMAIL_WORK, emailWork);
		final String firstName = vcard.getFirstName();
		if (firstName != null && !firstName.equals(""))
			props.put(VCARD_NAME_FIRST, firstName);
		final String middleName = vcard.getMiddleName();
		if (middleName != null && !middleName.equals(""))
			props.put(VCARD_NAME_MIDDLE, middleName);
		final String lastName = vcard.getLastName();
		if (lastName != null && !lastName.equals(""))
			props.put(VCARD_NAME_LAST, lastName);
		final String nickName = vcard.getNickName();
		if (nickName != null && !nickName.equals(""))
			props.put(VCARD_NAME_NICK, nickName);
		final String phoneHomeVoice = vcard.getPhoneHome("VOICE");
		if (phoneHomeVoice != null && !phoneHomeVoice.equals(""))
			props.put(VCARD_PHONE_HOME_VOICE, phoneHomeVoice);
		final String phoneHomeCell = vcard.getPhoneHome("CELL");
		if (phoneHomeCell != null && !phoneHomeCell.equals(""))
			props.put(VCARD_PHONE_HOME_CELL, phoneHomeCell);
		final String phoneWorkVoice = vcard.getPhoneWork("VOICE");
		if (phoneWorkVoice != null && !phoneWorkVoice.equals(""))
			props.put(VCARD_PHONE_WORK_VOICE, phoneWorkVoice);
		final String phoneWorkCell = vcard.getPhoneWork("CELL");
		if (phoneWorkCell != null && !phoneWorkCell.equals(""))
			props.put(VCARD_PHONE_WORK_CELL, phoneWorkCell);
		return props;
	}

	class XMPPPresence extends org.eclipse.ecf.presence.Presence {

		private static final long serialVersionUID = 7843634971520771692L;

		IAsyncResult asyncResult = null;
		String fromID = null;

		XMPPPresence(String fromID, Presence xmppPresence, IAsyncResult future) {
			super(createIPresenceType(xmppPresence), xmppPresence.getStatus(), createIPresenceMode(xmppPresence), ECFConnection.getPropertiesFromPacket(xmppPresence), null);
			this.fromID = fromID;
		}

		private void fillFromVCard() {
			VCard card = getFromCache(fromID);
			if (card == null && asyncResult != null) {
				try {
					card = (VCard) asyncResult.get();
					asyncResult = null;
				} catch (final Exception e) {
				}
			}
			if (card != null) {
				addToCache(fromID, card);
				final byte[] bytes = card.getAvatar();
				this.pictureData = (bytes == null) ? new byte[0] : bytes;
				this.properties = addVCardProperties(card, this.properties);
			}
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.ecf.presence.Presence#getPictureData()
		 */
		public byte[] getPictureData() {
			fillFromVCard();
			return this.pictureData;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.ecf.presence.Presence#getProperties()
		 */
		public Map getProperties() {
			fillFromVCard();
			return this.properties;
		}
	}

	protected IPresence createIPresence(final Presence xmppPresence) {
		final AsyncResult asyncResult = new AsyncResult();
		final Thread t = new Thread(asyncResult.setter(new ICallable() {
			public Object call() throws Throwable {
				return getVCardForPresence(xmppPresence);
			}
		}));
		t.start();
		return new XMPPPresence(xmppPresence.getFrom(), xmppPresence, asyncResult);
	}

	protected Presence createPresence(IPresence ipresence) {
		final Presence newPresence = new Presence(createPresenceType(ipresence), ipresence.getStatus(), 0, createPresenceMode(ipresence));
		ECFConnection.setPropertiesInPacket(newPresence, ipresence.getProperties());
		return newPresence;
	}

	protected IPresence.Mode createIPresenceMode(Presence xmppPresence) {
		if (xmppPresence == null)
			return IPresence.Mode.AVAILABLE;
		final Mode mode = xmppPresence.getMode();
		if (mode == Presence.Mode.AVAILABLE) {
			return IPresence.Mode.AVAILABLE;
		} else if (mode == Presence.Mode.AWAY) {
			return IPresence.Mode.AWAY;
		} else if (mode == Presence.Mode.CHAT) {
			return IPresence.Mode.CHAT;
		} else if (mode == Presence.Mode.DO_NOT_DISTURB) {
			return IPresence.Mode.DND;
		} else if (mode == Presence.Mode.EXTENDED_AWAY) {
			return IPresence.Mode.EXTENDED_AWAY;
		} else if (mode == Presence.Mode.INVISIBLE) {
			return IPresence.Mode.INVISIBLE;
		}
		return IPresence.Mode.AVAILABLE;
	}

	protected Presence.Mode createPresenceMode(IPresence ipresence) {
		if (ipresence == null)
			return Presence.Mode.AVAILABLE;
		final IPresence.Mode mode = ipresence.getMode();
		if (mode == IPresence.Mode.AVAILABLE) {
			return Presence.Mode.AVAILABLE;
		} else if (mode == IPresence.Mode.AWAY) {
			return Presence.Mode.AWAY;
		} else if (mode == IPresence.Mode.CHAT) {
			return Presence.Mode.CHAT;
		} else if (mode == IPresence.Mode.DND) {
			return Presence.Mode.DO_NOT_DISTURB;
		} else if (mode == IPresence.Mode.EXTENDED_AWAY) {
			return Presence.Mode.EXTENDED_AWAY;
		} else if (mode == IPresence.Mode.INVISIBLE) {
			return Presence.Mode.INVISIBLE;
		}
		return Presence.Mode.AVAILABLE;
	}

	protected IPresence.Type createIPresenceType(Presence xmppPresence) {
		if (xmppPresence == null)
			return IPresence.Type.AVAILABLE;
		final Type type = xmppPresence.getType();
		if (type == Presence.Type.AVAILABLE) {
			return IPresence.Type.AVAILABLE;
		} else if (type == Presence.Type.ERROR) {
			return IPresence.Type.ERROR;
		} else if (type == Presence.Type.SUBSCRIBE) {
			return IPresence.Type.SUBSCRIBE;
		} else if (type == Presence.Type.SUBSCRIBED) {
			return IPresence.Type.SUBSCRIBED;
		} else if (type == Presence.Type.UNSUBSCRIBE) {
			return IPresence.Type.UNSUBSCRIBE;
		} else if (type == Presence.Type.UNSUBSCRIBED) {
			return IPresence.Type.UNSUBSCRIBED;
		} else if (type == Presence.Type.UNAVAILABLE) {
			return IPresence.Type.UNAVAILABLE;
		}
		return IPresence.Type.AVAILABLE;
	}

	protected Presence.Type createPresenceType(IPresence ipresence) {
		if (ipresence == null)
			return Presence.Type.AVAILABLE;
		final IPresence.Type type = ipresence.getType();
		if (type == IPresence.Type.AVAILABLE) {
			return Presence.Type.AVAILABLE;
		} else if (type == IPresence.Type.ERROR) {
			return Presence.Type.ERROR;
		} else if (type == IPresence.Type.SUBSCRIBE) {
			return Presence.Type.SUBSCRIBE;
		} else if (type == IPresence.Type.SUBSCRIBED) {
			return Presence.Type.SUBSCRIBED;
		} else if (type == IPresence.Type.UNSUBSCRIBE) {
			return Presence.Type.UNSUBSCRIBE;
		} else if (type == IPresence.Type.UNSUBSCRIBED) {
			return Presence.Type.UNSUBSCRIBED;
		} else if (type == IPresence.Type.UNAVAILABLE) {
			return Presence.Type.UNAVAILABLE;
		}
		return Presence.Type.AVAILABLE;
	}

	protected IRosterItem[] createRosterEntries(RosterEntry entry) {
		return createRosterEntries(entry.getGroups(), roster, new User(createIDFromName(entry.getUser()), entry.getName()));
	}

	private IRosterItem[] createRosterEntries(Iterator grps, IRosterItem parent, IUser user) {
		final List result = new ArrayList();
		if (grps.hasNext()) {
			for (; grps.hasNext();) {
				final Object o = grps.next();
				// Get group name
				final String groupName = (o instanceof String) ? (String) o : ((RosterGroup) o).getName();

				if (groupName == null || groupName.equals("")) {
					createRosterEntries(parent, user, result);
					continue;
				}
				// See if group is already in roster
				org.eclipse.ecf.presence.roster.RosterGroup rosterGroup = findRosterGroup(parent, groupName);
				// Set flag if not
				final boolean groupFound = rosterGroup != null;
				if (!groupFound)
					rosterGroup = new org.eclipse.ecf.presence.roster.RosterGroup(parent, groupName);

				if (findRosterEntry(rosterGroup, user) == null) {
					// Now create new roster entry
					new org.eclipse.ecf.presence.roster.RosterEntry(rosterGroup, user, new org.eclipse.ecf.presence.Presence(IPresence.Type.UNAVAILABLE, IPresence.Type.UNAVAILABLE.toString(), IPresence.Mode.AWAY));
				}
				// Only add localGrp if not already in list
				if (!groupFound)
					result.add(rosterGroup);
			}
		} else
			createRosterEntries(parent, user, result);
		return (IRosterItem[]) result.toArray(new IRosterItem[] {});
	}

	protected IRosterEntry createRosterEntry(ID userID, String name, Iterator grps) {
		final List groups = new ArrayList();
		for (; grps.hasNext();) {
			final Object o = grps.next();
			final String groupName = (o instanceof String) ? (String) o : ((RosterGroup) o).getName();
			final IRosterGroup localGrp = new org.eclipse.ecf.presence.roster.RosterGroup(roster, groupName);
			groups.add(localGrp);
		}
		final IUser user = new User(userID, name);
		IRosterEntry newEntry = null;
		if (groups.size() == 0)
			return new org.eclipse.ecf.presence.roster.RosterEntry(roster, user, null);
		else
			for (int i = 0; i < groups.size(); i++) {
				final IRosterGroup grp = (IRosterGroup) groups.get(i);
				if (i == 0)
					newEntry = new org.eclipse.ecf.presence.roster.RosterEntry(grp, user, null);
				else {
					grp.getEntries().add(newEntry);
					newEntry.getGroups().add(grp);
				}
			}
		return newEntry;
	}

	private void createRosterEntries(IRosterItem parent, IUser user, List result) {
		final org.eclipse.ecf.presence.roster.RosterEntry oldEntry = findRosterEntry((org.eclipse.ecf.presence.roster.RosterGroup) null, user);
		if (oldEntry == null) {
			final org.eclipse.ecf.presence.roster.RosterEntry newEntry = new org.eclipse.ecf.presence.roster.RosterEntry(parent, user, new org.eclipse.ecf.presence.Presence(IPresence.Type.UNAVAILABLE, IPresence.Type.UNAVAILABLE.toString(), IPresence.Mode.AWAY));
			result.add(newEntry);
		}
	}

	private org.eclipse.ecf.presence.roster.RosterEntry findRosterEntry(org.eclipse.ecf.presence.roster.RosterGroup rosterGroup, IUser user) {
		if (rosterGroup != null)
			return findRosterEntry(rosterGroup.getEntries(), user);
		else
			return findRosterEntry(roster.getItems(), user);
	}

	private org.eclipse.ecf.presence.roster.RosterEntry findRosterEntry(Collection entries, IUser user) {
		for (final Iterator i = entries.iterator(); i.hasNext();) {
			final Object o = i.next();
			if (o instanceof org.eclipse.ecf.presence.roster.RosterEntry) {
				final org.eclipse.ecf.presence.roster.RosterEntry entry = (org.eclipse.ecf.presence.roster.RosterEntry) o;
				if (entry.getUser().getID().equals(user.getID()))
					return entry;
			}
		}
		return null;
	}

	protected IRosterItem[] createRosterEntries(RosterPacket.Item entry) {
		final XMPPID id = createIDFromName(entry.getUser());
		String name = entry.getName();
		if (name == null)
			name = id.getUsername();
		return createRosterEntries(entry.getGroupNames(), roster, new User(id, name));
	}

	protected org.eclipse.ecf.presence.roster.RosterGroup findRosterGroup(Object parent, String grp) {
		final Collection items = roster.getItems();
		for (final Iterator i = items.iterator(); i.hasNext();) {
			final IRosterItem item = (IRosterItem) i.next();
			if (item.getName().equals(grp))
				return (org.eclipse.ecf.presence.roster.RosterGroup) item;
		}
		return null;
	}

	// utility methods

	protected ECFConnection getConnectionOrThrowIfNull() throws IOException {
		final ECFConnection conn = container.getECFConnection();
		if (conn == null)
			throw new IOException("Not connected");
		return conn;
	}

	protected void traceAndThrowECFException(String msg, Throwable t) throws ECFException {
		throw new ECFException(msg, t);
	}

	protected void trace(String msg) {

	}

	protected void traceStack(String msg, Throwable e) {

	}

	protected ID createRoomIDFromName(String from) {
		try {
			final ECFConnection ecfConnection = getConnectionOrThrowIfNull();
			return new XMPPRoomID(container.getConnectNamespace(), ecfConnection.getXMPPConnection(), from);
		} catch (final Exception e) {
			traceStack("Exception in createRoomIDFromName", e);
			return null;
		}
	}

	protected ID createUserIDFromName(String name) {
		ID result = null;
		try {
			result = new XMPPID(container.getConnectNamespace(), name);
			return result;
		} catch (final Exception e) {
			traceStack("Exception in createIDFromName", e);
			return null;
		}
	}

	protected Message.Type[] ALLOWED_MESSAGES = {Message.Type.CHAT, Message.Type.ERROR, Message.Type.HEADLINE, Message.Type.NORMAL};

	protected Message filterMessageType(Message msg) {
		for (int i = 0; i < ALLOWED_MESSAGES.length; i++) {
			if (ALLOWED_MESSAGES[i].equals(msg.getType())) {
				return msg;
			}
		}
		return null;
	}

	/**
	 * @return chat manager.
	 */
	public IChatManager getChatManager() {
		return chatManager;
	}

}