/**
 * OLAT - Online Learning and Training<br />
 * http://www.olat.org
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License"); <br />
 * you may not use this file except in compliance with the License.<br />
 * You may obtain a copy of the License at
 * <p>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing,<br />
 * software distributed under the License is distributed on an "AS IS" BASIS,
 * <br />
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br />
 * See the License for the specific language governing permissions and <br />
 * limitations under the License.
 * <p>
 * Copyright (c) since 2004 at Multimedia- & E-Learning Services (MELS),<br />
 * University of Zurich, Switzerland.
 * <p>
 */

package org.olat.instantMessaging;

import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.lang.RandomStringUtils;
import org.jivesoftware.smack.Chat;
import org.jivesoftware.smack.ChatManager;
import org.jivesoftware.smack.MessageListener;
import org.jivesoftware.smack.PacketListener;
import org.jivesoftware.smack.filter.PacketTypeFilter;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.packet.Presence;
import org.olat.basesecurity.Authentication;
import org.olat.basesecurity.ManagerFactory;
import org.olat.core.gui.control.Controller;
import org.olat.core.id.Identity;
import org.olat.core.id.UserConstants;
import org.olat.core.logging.OLog;
import org.olat.core.logging.Tracing;
import org.olat.core.util.event.GenericEventListener;

/**
 * Description: <br />
 * Manager class for creation and manipulation of the instant messaging client
 * for each user.
 * <P>
 * Initial Date: 14.10.2004
 * 
 * @author Guido Schnider
 */
public class ClientManagerImpl implements ClientManager {
	OLog log = Tracing.createLoggerFor(this.getClass());
	// each client gets stored in a map under the username
	// o_clusterNOK cache ?? what if the clientmanager runs on each vm? ok? why?
	private Map<String, InstantMessagingClient> clients = Collections.synchronizedMap(new HashMap<String, InstantMessagingClient>());
	Map<String, GenericEventListener> listeners = Collections.synchronizedMap(new HashMap<String, GenericEventListener>());
	/**
	 * empty constructor
	 */
	private ClientManagerImpl() {
	// nothing to do
	}


	/**
	 * Creates an new instant messaging client and connects automatically
	 * to the server. This method should only be used in a constructor and not 
	 * be triggered by GUI events, otherwise clients that lost connections may get recreated
	 * again.
	 * @param username
	 * @return JabberClient even if IM service is down
	 */
	public InstantMessagingClient getInstantMessagingClient(String username) {
		// no need to sync over whole method (get/put) since only called once per
		// UserRequest and username.
		// we do not sync since "new InstantMessagingClient(...)" may last quite
		// long.
		InstantMessagingClient client;
		client = clients.get(username);
		if (client == null) {
			String password = getInstantMessagingCredentialsForUser(username);
			client = new InstantMessagingClient(username, password);
				clients.put(username, client);
			return client;
		} else {
			return client;
		}
	}
	
	/**
	 * Check whether a user has already an IM  client running
	 * Use this method when fetching clients outside a controller constructor as users may have several sessions
	 * to avoid reconnection of an duplicate session 
	 * @param username
	 * @return
	 */
	public boolean hasActiveInstantMessagingClient(String username){
			return clients.containsKey(username);
	}

	/**
	 * 
	 * @param username
	 * @param listener
	 * @param listenToAllMessages - only the main controller needs to listen to all messages
	 */
	public void registerEventListener(String username, GenericEventListener listener, boolean listenToAllMessages) {
			if (listenToAllMessages) {
				listeners.put(username, listener);
			} else {
				listeners.put(username+listener.hashCode(), listener);
			}
	}
	

	public GenericEventListener getRegisteredEventListeners(String username, Controller controller) {
		return listeners.get(username+controller.hashCode());
	}

	public void deregisterControllerListener(String username, Controller controller) {
			listeners.remove(username+controller.hashCode());
	}
	
	public Chat createChat(final String username, String chatPartnerJid, final Controller controller) {
		ChatManager chatmanager = getInstantMessagingClient(username).getConnection().getChatManager();
		Chat chat = chatmanager.createChat(chatPartnerJid, new MessageListener() {

			public void processMessage(Chat chat, Message message) {
				message.setProperty("receiveTime", new Long(new Date().getTime()));
				GenericEventListener listener = listeners.get(username+controller.hashCode());
				listener.event(new InstantMessagingEvent(message, "chatmessage"));
			}
		});
		return chat;
	}

	/**
	 * @param username
	 */
	public void addMessageListener(final String username) {
		PacketListener packetListener = new PacketListener() {
			public void processPacket(Packet packet) {
				Message jabbmessage = (Message) packet;
				//TODO:gs:b see issue: http://bugs.olat.org/jira/browse/OLAT-2966
				//filter <script> msg. out - security risk of cross site scripting!
				//or may user ext.util.strip script tag method on client side
				jabbmessage.setProperty("receiveTime", new Long(new Date().getTime()));
				GenericEventListener listener = listeners.get(username);
				if (listener != null){
					listener.event(new InstantMessagingEvent(packet, "message"));
				} else {
					log.warn("could not find listener for IM message for username: "+username);
				}
			}
		};
		getInstantMessagingClient(username).getConnection().addPacketListener(packetListener, new PacketTypeFilter(Message.class));
	}

	/**
	 * 
	 * @param username
	 */
	public void addPresenceListener(final String username) {
		PacketListener packetListener = new PacketListener() {
			public void processPacket(Packet packet) {
				GenericEventListener listener = listeners.get(username);
				listener.event(new InstantMessagingEvent(packet, "presence"));
				Presence presence = (Presence) packet;
			}
		};
		getInstantMessagingClient(username).getConnection().addPacketListener(packetListener, new PacketTypeFilter(Presence.class));
	}
	
	/**
	 * helper method to trigger a presence update even if the server does not send
	 * a presence packet itself (e.g. entering a test but no other buddies are online)
	 * @param username
	 */
	public void sendPresenceEvent(Presence.Type type, String username) {
		Presence presence = new Presence(type);
		presence.setTo(username);
		GenericEventListener listener = listeners.get(username);
		if (listener != null) {
			listener.event(new InstantMessagingEvent(presence, "presence"));
		}
	}

	/**
	 * Looks if user has credentials for IM. If not (auth == null) a new accounts
	 * with a random generated password gets created otherwise the password gets
	 * returned.
	 * 
	 * @param username the OLAT username
	 * @return the password used for instant messaging
	 */
	public String getInstantMessagingCredentialsForUser(String username) {
		Identity identity = ManagerFactory.getManager().findIdentityByName(username);
		// synchronized: not needed here, since the credential is only created once for a user (when that user logs in for the very first time).
		// And a user will almost! never log in at the very same time from two different machines.
		Authentication auth = ManagerFactory.getManager().findAuthentication(identity, PROVIDER_INSTANT_MESSAGING);
		if (auth == null) { // create new authentication for provider and also a new IM-account
			InstantMessaging im = InstantMessagingModule.getAdapter();
			
			//while testing (generate testusers = true) delete user on IM server if account is leftover
			if (im.getConfig().generateTestUsers() && im.hasAccount(username)) {
				im.deleteAccount(username);
			}
			
			String pw = RandomStringUtils.randomAlphanumeric(6);
			if (im.createAccount(username, pw,
					identity.getUser().getProperty(UserConstants.FIRSTNAME, null) + " " + identity.getUser().getProperty(UserConstants.LASTNAME, null), identity.getUser().getProperty(UserConstants.EMAIL, null))) {
				auth = ManagerFactory.getManager().createAndPersistAuthentication(identity, PROVIDER_INSTANT_MESSAGING,
						identity.getName().toLowerCase(), pw);
				Tracing.logAudit("New instant messaging authentication account created for user:" + username, this.getClass());
				return auth.getCredential();
			} else {
				Tracing.logWarn("new instant messaging account creation failed for user: " + username, ClientManagerImpl.class);
				return null;
			}
		}
		return auth.getCredential();
	}

	/**
	 * When a user logs out of olat we logout the client from the jabber server
	 * and free the ressource
	 * 
	 * @param username
	 */
	public void destroyInstantMessagingClient(String username) {
		InstantMessagingClient client;
		client = clients.get(username);
		if (client != null) {
				listeners.remove(username);
			if (client.isConnected()) client.closeConnection();
				clients.remove(username);
		}
	}

	/**
	 * returns the map (its iterator is safe)
	 * 
	 * @return map
	 */
	public Map<String, InstantMessagingClient> getClients() {
			HashMap<String, InstantMessagingClient> hm = new HashMap<String, InstantMessagingClient>(clients);
			return hm;
	}

}