/****************************************************************************
 * Copyright (c) 2006, 2007 Remy Suen, 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:
 *    Remy Suen <remy.suen@gmail.com> - initial API and implementation
 *****************************************************************************/
package org.eclipse.ecf.internal.provider.msn;

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

import org.eclipse.ecf.core.ContainerConnectException;
import org.eclipse.ecf.core.IContainer;
import org.eclipse.ecf.core.IContainerListener;
import org.eclipse.ecf.core.events.ContainerConnectedEvent;
import org.eclipse.ecf.core.events.ContainerConnectingEvent;
import org.eclipse.ecf.core.events.ContainerDisconnectedEvent;
import org.eclipse.ecf.core.events.ContainerDisconnectingEvent;
import org.eclipse.ecf.core.events.ContainerDisposeEvent;
import org.eclipse.ecf.core.events.IContainerEvent;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.identity.IDCreateException;
import org.eclipse.ecf.core.identity.IDFactory;
import org.eclipse.ecf.core.identity.Namespace;
import org.eclipse.ecf.core.security.IConnectContext;
import org.eclipse.ecf.core.security.ObjectCallback;
import org.eclipse.ecf.core.security.UnsupportedCallbackException;
import org.eclipse.ecf.core.user.IUser;
import org.eclipse.ecf.core.util.ECFException;
import org.eclipse.ecf.presence.IAccountManager;
import org.eclipse.ecf.presence.IIMMessageListener;
import org.eclipse.ecf.presence.IPresence;
import org.eclipse.ecf.presence.IPresenceContainerAdapter;
import org.eclipse.ecf.presence.IPresenceListener;
import org.eclipse.ecf.presence.IPresenceSender;
import org.eclipse.ecf.presence.chatroom.IChatRoomManager;
import org.eclipse.ecf.presence.history.IHistory;
import org.eclipse.ecf.presence.history.IHistoryManager;
import org.eclipse.ecf.presence.im.ChatMessage;
import org.eclipse.ecf.presence.im.ChatMessageEvent;
import org.eclipse.ecf.presence.im.IChat;
import org.eclipse.ecf.presence.im.IChatManager;
import org.eclipse.ecf.presence.im.IChatMessageSender;
import org.eclipse.ecf.presence.im.ITypingMessageSender;
import org.eclipse.ecf.presence.im.TypingMessage;
import org.eclipse.ecf.presence.im.TypingMessageEvent;
import org.eclipse.ecf.presence.im.IChatMessage.Type;
import org.eclipse.ecf.presence.roster.IRoster;
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.IRosterListener;
import org.eclipse.ecf.presence.roster.IRosterManager;
import org.eclipse.ecf.presence.roster.IRosterSubscriptionListener;
import org.eclipse.ecf.presence.roster.IRosterSubscriptionSender;
import org.eclipse.ecf.presence.search.ICriteria;
import org.eclipse.ecf.presence.search.ISearch;
import org.eclipse.ecf.presence.search.IRestriction;
import org.eclipse.ecf.presence.search.IUserSearchListener;
import org.eclipse.ecf.presence.search.IUserSearchManager;
import org.eclipse.ecf.presence.search.UserSearchException;
import org.eclipse.ecf.presence.search.message.IMessageSearchManager;
import org.eclipse.ecf.presence.service.IPresenceService;
import org.eclipse.ecf.protocol.msn.ChatSession;
import org.eclipse.ecf.protocol.msn.Contact;
import org.eclipse.ecf.protocol.msn.Group;
import org.eclipse.ecf.protocol.msn.MsnClient;
import org.eclipse.ecf.protocol.msn.Status;
import org.eclipse.ecf.protocol.msn.events.IChatSessionListener;
import org.eclipse.ecf.protocol.msn.events.IContactListListener;
import org.eclipse.ecf.protocol.msn.events.IContactListener;
import org.eclipse.ecf.protocol.msn.events.ISessionListener;

final class MSNContainer implements IContainer, IChatManager,
		IChatMessageSender, IPresenceService, IPresenceSender, IRoster,
		IRosterManager, IRosterSubscriptionSender, ITypingMessageSender {

	private final Map chatSessions;

	private final List containerListeners;

	private final List updateListeners;

	private final List messageListeners;

	private final List presenceListeners;

	private final List subscriptionListeners;

	private final List entries;

	private final IUser user;

	private final Namespace namespace;

	private final ID guid;

	private MsnClient client;

	private MSNID connectID;

	protected IHistoryManager historyManager = new IHistoryManager() {

		public IHistory getHistory(ID partnerID, Map options) {
			// TODO Auto-generated method stub
			return null;
		}

		public boolean isActive() {
			// TODO Auto-generated method stub
			return false;
		}

		public void setActive(boolean active) {
			// TODO Auto-generated method stub

		}

		public Object getAdapter(Class adapter) {
			// TODO Auto-generated method stub
			return null;
		}

	};

	MSNContainer() throws IDCreateException {
		guid = IDFactory.getDefault().createGUID();
		namespace = IDFactory.getDefault().getNamespaceByName(
				Activator.NAMESPACE_ID);
		user = new Account();
		chatSessions = new Hashtable();
		containerListeners = new ArrayList();
		updateListeners = new ArrayList();
		messageListeners = new ArrayList();
		presenceListeners = new ArrayList();
		subscriptionListeners = new ArrayList();
		entries = new ArrayList();
	}

	public void connect(ID targetID, IConnectContext connectContext)
			throws ContainerConnectException {
		if (!(targetID instanceof MSNID)) {
			throw new ContainerConnectException(
					Messages.MSNContainer_TargetIDNotMSNID);
		}

		client = new MsnClient();
		ObjectCallback[] cb = { new ObjectCallback() };
		try {
			connectContext.getCallbackHandler().handle(cb);
			client.addSessionListener(new ISessionListener() {
				public void sessionConnected(ChatSession session) {
					try {
						Contact contact = session.getParticipants()[0];
						final ID toID = namespace
								.createInstance(new Object[] { contact
										.getEmail() });
						chatSessions.put(toID, session);
						session.addChatSessionListener(new ChatSessionListener(
								toID));
					} catch (IDCreateException e) {
						// ignored since this should not be possible
					}
				}
			});

			client.getContactList().addContactListListener(
					new IContactListListener() {
						public void contactAdded(Contact contact) {
							final MSNRosterEntry entry = new MSNRosterEntry(
									MSNContainer.this, contact, namespace);

							for (int i = 0; i < entries.size(); i++) {
								Object e = entries.get(i);
								if (e instanceof MSNRosterGroup) {
									MSNRosterGroup group = (MSNRosterGroup) e;
									if (group.getGroup().contains(contact)) {
										MSNRosterEntry check = group
												.getEntryFor(contact);
										if (check == null) {
											check = entry;
											contact
													.addContactListener(new IContactListener() {
														public void nameChanged(
																String name) {
															firePresence(
																	entry
																			.getID(),
																	entry
																			.getPresence());
															fireRosterUpdate(entry);
														}

														public void personalMessageChanged(
																String personalMessage) {
															entry
																	.updatePersonalMessage();
															firePresence(
																	entry
																			.getID(),
																	entry
																			.getPresence());
															fireRosterUpdate(entry);
														}

														public void statusChanged(
																Status status) {
															firePresence(
																	entry
																			.getID(),
																	entry
																			.getPresence());
															fireRosterUpdate(entry);
														}
													});
											group.add(check);
											fireRosterEntryAdded(check);
										}
										fireRosterUpdate(group);
										return;
									}
								} else {
									MSNRosterEntry check = (MSNRosterEntry) e;
									if (entry.getContact().equals(
											check.getContact())) {
										fireRosterEntryAdded(check);
										fireRosterUpdate(check.getParent());
										return;
									}
								}
							}

							contact.addContactListener(new IContactListener() {
								public void nameChanged(String name) {
									firePresence(entry.getID(), entry
											.getPresence());
									fireRosterUpdate(entry);
								}

								public void personalMessageChanged(
										String personalMessage) {
									entry.updatePersonalMessage();
									firePresence(entry.getID(), entry
											.getPresence());
									fireRosterUpdate(entry);
								}

								public void statusChanged(Status status) {
									firePresence(entry.getID(), entry
											.getPresence());
									fireRosterUpdate(entry);
								}
							});
							entries.add(entry);
							entry.setParent(MSNContainer.this);
							fireRosterEntryAdded(entry);
							fireRosterUpdate(MSNContainer.this);
						}

						public void contactRemoved(Contact contact) {
							MSNRosterEntry entry = findEntry(entries, contact
									.getEmail());
							if (entry != null) {
								fireHandleUnsubscribed(entry.getUser().getID());
								fireRosterEntryRemoved(entry);
								fireRosterUpdate(entry.getParent());
								if (entry.getContact().getGroups().isEmpty()) {
									entry.setParent(MSNContainer.this);
									fireRosterUpdate(MSNContainer.this);
								}
							}
						}

						public void contactAddedUser(String email) {
							try {
								fireHandleSubscriptionRequest(namespace
										.createInstance(new Object[] { email }));
							} catch (IDCreateException e) {
								// ignored
							}
						}

						public void contactRemovedUser(String email) {
							// nothing to do
						}

						public void groupAdded(Group group) {
							entries.add(new MSNRosterGroup(MSNContainer.this,
									group));
						}
					});

			fireContainerEvent(new ContainerConnectingEvent(guid, targetID));
			client.connect(targetID.getName(), (String) cb[0].getObject());
			connectID = (MSNID) targetID;
			fireContainerEvent(new ContainerConnectedEvent(guid, connectID));
			Activator.getDefault().registerService(this);
		} catch (UnsupportedCallbackException e) {
			throw new ContainerConnectException(e);
		} catch (IOException e) {
			throw new ContainerConnectException(e);
		}
	}

	private MSNRosterEntry findEntry(Collection entries, String email) {
		for (Iterator it = entries.iterator(); it.hasNext();) {
			Object o = it.next();
			if (o instanceof IRosterGroup) {
				MSNRosterEntry entry = findEntry(((IRosterGroup) o)
						.getEntries(), email);
				if (entry != null) {
					return entry;
				}
			} else {
				MSNRosterEntry entry = (MSNRosterEntry) o;
				if (entry.getUser().getID().getName().equals(email)) {
					return entry;
				}
			}
		}
		return null;
	}

	public void disconnect() {
		if (client != null) {
			fireContainerEvent(new ContainerDisconnectingEvent(guid, connectID));
			client.disconnect();
			fireContainerEvent(new ContainerDisconnectedEvent(guid, connectID));
			for (Iterator it = chatSessions.values().iterator(); it.hasNext();) {
				((ChatSession) it.next()).close();
			}
			chatSessions.clear();
			connectID = null;
			client = null;
			Activator.getDefault().unregisterService(this);
		}
	}

	public void dispose() {
		disconnect();
		fireContainerEvent(new ContainerDisposeEvent(guid));
	}

	private void fireContainerEvent(IContainerEvent event) {
		synchronized (containerListeners) {
			for (int i = 0; i < containerListeners.size(); i++) {
				((IContainerListener) containerListeners.get(i))
						.handleEvent(event);
			}
		}
	}

	private void fireMessageEvent(ID fromID, String message) {
		synchronized (messageListeners) {
			for (int i = 0; i < messageListeners.size(); i++) {
				((IIMMessageListener) messageListeners.get(i))
						.handleMessageEvent(new ChatMessageEvent(fromID,
								new ChatMessage(fromID, message)));
			}
		}
	}

	private void fireTypingMessageEvent(ID fromID) {
		synchronized (messageListeners) {
			for (int i = 0; i < messageListeners.size(); i++) {
				((IIMMessageListener) messageListeners.get(i))
						.handleMessageEvent(new TypingMessageEvent(fromID,
								new TypingMessage(fromID, true, null)));
			}
		}
	}

	private void fireRosterUpdate(IRosterItem item) {
		synchronized (updateListeners) {
			for (int i = 0; i < updateListeners.size(); i++) {
				((IRosterListener) updateListeners.get(i)).handleRosterUpdate(
						this, item);
			}
		}
	}

	private void fireRosterEntryAdded(IRosterEntry entry) {
		synchronized (updateListeners) {
			for (int i = 0; i < updateListeners.size(); i++) {
				((IRosterListener) updateListeners.get(i))
						.handleRosterEntryAdd(entry);
			}
		}
	}

	private void fireRosterEntryRemoved(IRosterEntry entry) {
		synchronized (updateListeners) {
			for (int i = 0; i < updateListeners.size(); i++) {
				((IRosterListener) updateListeners.get(i))
						.handleRosterEntryRemove(entry);
			}
		}
	}

	private void firePresence(ID id, IPresence presence) {
		synchronized (presenceListeners) {
			for (int i = 0; i < presenceListeners.size(); i++) {
				((IPresenceListener) presenceListeners.get(i)).handlePresence(
						id, presence);
			}
		}
	}

	private void fireHandleSubscriptionRequest(ID fromID) {
		synchronized (subscriptionListeners) {
			for (int i = 0; i < subscriptionListeners.size(); i++) {
				((IRosterSubscriptionListener) subscriptionListeners.get(i))
						.handleSubscribeRequest(fromID);
			}
		}
	}

	private void fireHandleUnsubscribed(ID fromID) {
		synchronized (subscriptionListeners) {
			for (int i = 0; i < subscriptionListeners.size(); i++) {
				((IRosterSubscriptionListener) subscriptionListeners.get(i))
						.handleUnsubscribed(fromID);
			}
		}
	}

	public Object getAdapter(Class serviceType) {
		if (serviceType != null && serviceType.isInstance(this)) {
			return this;
		} else {
			return null;
		}
	}

	public Namespace getConnectNamespace() {
		return IDFactory.getDefault()
				.getNamespaceByName(Activator.NAMESPACE_ID);
	}

	public ID getConnectedID() {
		return connectID;
	}

	public ID getID() {
		return guid;
	}

	public IAccountManager getAccountManager() {
		return null;
	}

	public IChatRoomManager getChatRoomManager() {
		return null;
	}

	public IPresenceSender getPresenceSender() {
		return this;
	}

	public void addListener(IContainerListener listener) {
		if (listener != null) {
			synchronized (containerListeners) {
				if (!containerListeners.contains(listener)) {
					containerListeners.add(listener);
				}
			}
		}
	}

	public void removeListener(IContainerListener listener) {
		if (listener != null) {
			synchronized (containerListeners) {
				containerListeners.remove(listener);
			}
		}
	}

	private class ChatSessionListener implements IChatSessionListener {

		private ID toID;

		private ChatSessionListener(ID toID) {
			this.toID = toID;
		}

		public void contactIsTyping(Contact contact) {
			fireTypingMessageEvent(toID);
		}

		public void contactJoined(Contact contact) {
		}

		public void contactLeft(Contact contact) {
			chatSessions.remove(toID);
		}

		public void messageReceived(Contact contact, String message) {
			fireMessageEvent(toID, message);
		}

		public void sessionTimedOut() {
			chatSessions.remove(toID);
		}

	}

	public void sendPresenceUpdate(ID toID, IPresence presence)
			throws ECFException {
		if (presence == null || client == null) {
			throw new ECFException();
		}

		IPresence.Mode mode = presence.getMode();
		try {
			client.setPersonalMessage(presence.getStatus());
			if (presence.getType() == IPresence.Type.UNAVAILABLE) {
				disconnect();
			} else if (mode == IPresence.Mode.AVAILABLE
					|| mode == IPresence.Mode.CHAT) {
				client.setStatus(Status.ONLINE);
			} else if (mode == IPresence.Mode.AWAY
					|| mode == IPresence.Mode.EXTENDED_AWAY) {
				client.setStatus(Status.AWAY);
			} else if (mode == IPresence.Mode.DND) {
				client.setStatus(Status.BUSY);
			} else {
				client.setStatus(Status.APPEAR_OFFLINE);
			}
		} catch (IOException e) {
			throw new ECFException(e);
		}
	}

	public IRosterManager getRosterManager() {
		return this;
	}

	public void addRosterListener(IRosterListener listener) {
		synchronized (updateListeners) {
			if (!updateListeners.contains(listener)) {
				updateListeners.add(listener);
			}
		}
	}

	public IRoster getRoster() {
		return this;
	}

	public IRosterSubscriptionSender getRosterSubscriptionSender() {
		return this;
	}

	public void addRosterSubscriptionListener(
			IRosterSubscriptionListener listener) {
		if (listener != null) {
			synchronized (subscriptionListeners) {
				if (!subscriptionListeners.contains(listener)) {
					subscriptionListeners.add(listener);
				}
			}
		}
	}

	public void removeRosterSubscriptionListener(
			IRosterSubscriptionListener listener) {
		if (listener != null) {
			synchronized (subscriptionListeners) {
				subscriptionListeners.remove(listener);
			}
		}
	}

	public void removeRosterListener(IRosterListener listener) {
		if (listener != null) {
			synchronized (updateListeners) {
				updateListeners.remove(listener);
			}
		}
	}

	public Collection getItems() {
		return Collections.unmodifiableCollection(entries);
	}

	public IUser getUser() {
		return connectID == null ? null : user;
	}

	public void addPresenceListener(IPresenceListener listener) {
		if (listener != null) {
			synchronized (presenceListeners) {
				if (!presenceListeners.contains(listener)) {
					presenceListeners.add(listener);
				}
			}
		}
	}

	public void removePresenceListener(IPresenceListener listener) {
		if (listener != null) {
			synchronized (presenceListeners) {
				presenceListeners.remove(listener);
			}
		}
	}

	public IChatManager getChatManager() {
		return this;
	}

	public IChatMessageSender getChatMessageSender() {
		return this;
	}

	public ITypingMessageSender getTypingMessageSender() {
		return this;
	}

	public void sendChatMessage(ID toID, ID threadID, Type type,
			String subject, String body, Map properties) throws ECFException {
		sendChatMessage(toID, body);
	}

	public void sendChatMessage(ID toID, String body) throws ECFException {
		try {
			ChatSession cs = (ChatSession) chatSessions.get(toID);
			if (cs == null) {
				cs = client.createChatSession(toID.getName());
				cs.addChatSessionListener(new ChatSessionListener(toID));
				chatSessions.put(toID, cs);
			}
			cs.sendMessage(body);
		} catch (IOException e) {
			throw new ECFException(e);
		}
	}

	public void sendTypingMessage(ID toID, boolean isTyping, String body)
			throws ECFException {
		try {
			if (isTyping) {
				ChatSession cs = (ChatSession) chatSessions.get(toID);
				if (cs == null) {
					cs = client.createChatSession(toID.getName());
					cs.addChatSessionListener(new ChatSessionListener(toID));
					chatSessions.put(toID, cs);
				}
				cs.sendTypingNotification();
			}
		} catch (IOException e) {
			throw new ECFException(e);
		}
	}

	public void addMessageListener(IIMMessageListener listener) {
		if (listener != null) {
			synchronized (messageListeners) {
				if (!messageListeners.contains(listener)) {
					messageListeners.add(listener);
				}
			}
		}
	}

	public void removeMessageListener(IIMMessageListener listener) {
		if (listener != null) {
			synchronized (messageListeners) {
				messageListeners.remove(listener);
			}
		}
	}

	private class Account implements IUser {

		private static final long serialVersionUID = 7497082891662391996L;

		public Object getAdapter(Class adapter) {
			return null;
		}

		public ID getID() {
			return connectID;
		}

		public Map getProperties() {
			return null;
		}

		public String getName() {
			return client.getUserEmail();
		}

		public String getNickname() {
			return client.getDisplayName();
		}

	}

	public void sendRosterAdd(String user, String name, String[] groups)
			throws ECFException {
		try {
			client.getContactList().addContact(user, name);
		} catch (IOException e) {
			throw new ECFException(e);
		}
	}

	public void sendRosterRemove(ID userID) throws ECFException {
		MSNRosterEntry entry = findEntry(entries, userID.getName());
		if (entry != null) {
			try {
				client.getContactList().removeContact(entry.getContact());
			} catch (IOException e) {
				throw new ECFException(e);
			}
		}
	}

	public String getName() {
		IUser user = getUser();
		return user == null ? null : user.getName();
	}

	public IRosterItem getParent() {
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ecf.presence.im.IChatManager#getHistoryManager()
	 */
	public IHistoryManager getHistoryManager() {
		// TODO Auto-generated method stub
		return historyManager;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ecf.presence.roster.IRoster#getPresenceContainerAdapter()
	 */
	public IPresenceContainerAdapter getPresenceContainerAdapter() {
		return this;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ecf.presence.im.IChatManager#createChat(org.eclipse.ecf.core.identity.ID)
	 */
	public IChat createChat(ID targetUser, IIMMessageListener messageListener) throws ECFException {
		// TODO Auto-generated method stub
		return null;
	}

	/**
	 * TODO Implement a User Search Manager for MSN
	 * for while it just returns a manger
	 * to inform that user search is not allow
	 * for this provider see {@link IUserSearchManager#isEnabled()}
	 */
	public IUserSearchManager getUserSearchManager() {
		return new IUserSearchManager(){

			public ICriteria createCriteria() {
				// TODO Auto-generated method stub
				return null;
			}

			public IRestriction createRestriction() {
				// TODO Auto-generated method stub
				return null;
			}

			public String[] getUserPropertiesFields()
					throws ContainerConnectException {
				// TODO Auto-generated method stub
				return null;
			}

			public boolean isEnabled() {
				// TODO Auto-generated method stub
				return false;
			}

			public ISearch search(ICriteria criteria)
					throws UserSearchException {
				// TODO Auto-generated method stub
				return null;
			}

			public void search(ICriteria criteria, IUserSearchListener listener) {
				// TODO Auto-generated method stub
				
			}
			
		};
	}

	public IMessageSearchManager getMessageSearchManager() {
		// TODO Auto-generated method stub
		return null;
	}

}