/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License") +  you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.openmeetings.app.remote.red5;

import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import org.openmeetings.app.OpenmeetingsVariables;
import org.openmeetings.app.conference.session.RoomClient;
import org.openmeetings.app.data.beans.basic.SearchResult;
import org.openmeetings.utils.crypt.ManageCryptStyle;
import org.red5.logging.Red5LoggerFactory;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;

public class ClientListManager {
	private static HashMap<String, RoomClient> clientList = new HashMap<String, RoomClient>();

	private static final Logger log = Red5LoggerFactory.getLogger(
			ClientListManager.class, OpenmeetingsVariables.webAppRootKey);

	@Autowired
	private ManageCryptStyle manageCryptStyle;
	
	/**
	 * Get current clients and extends the room client with its potential 
	 * audio/video client and settings
	 * 
	 * @param room_id
	 * @return
	 */
	public HashMap<String, RoomClient> getRoomClients(Long room_id) {
		try {

			HashMap<String, RoomClient> roomClientList = new HashMap<String, RoomClient>();
			HashMap<String, RoomClient> clientListRoom = this.getClientListByRoom(room_id);
			for (Iterator<String> iter = clientListRoom.keySet().iterator(); iter
					.hasNext();) {
				String key = iter.next();
				RoomClient rcl = this.getClientByStreamId(key);
				
				if (rcl.getIsAVClient()) {
					continue;
				}
				
				// Add user to List
				roomClientList.put(key, rcl);
			}

			return roomClientList;
		} catch (Exception err) {
			log.error("[getRoomClients]", err);
		}
		return null;
	}

	public synchronized RoomClient addClientListItem(String streamId,
			String scopeName, Integer remotePort, String remoteAddress,
			String swfUrl, boolean isAVClient) {
		try {

			// Store the Connection into a bean and add it to the HashMap
			RoomClient rcm = new RoomClient();
			rcm.setConnectedSince(new Date());
			rcm.setStreamid(streamId);
			rcm.setScope(scopeName);
			long thistime = new Date().getTime();
			rcm.setPublicSID(manageCryptStyle.getInstanceOfCrypt()
					.createPassPhrase(String.valueOf(thistime).toString()));

			rcm.setUserport(remotePort);
			rcm.setUserip(remoteAddress);
			rcm.setSwfurl(swfUrl);
			rcm.setIsMod(new Boolean(false));
			rcm.setCanDraw(new Boolean(false));
			rcm.setIsAVClient(isAVClient);

			if (clientList.containsKey(streamId)) {
				log.error("Tried to add an existing Client " + streamId);
				return null;
			}

			clientList.put(rcm.getStreamid(), rcm);

			log.debug(" :: addClientListItem :: " + rcm.getRoomClientId());

			return rcm;
		} catch (Exception err) {
			log.error("[addClientListItem]", err);
		}
		return null;
	}

	public synchronized Collection<RoomClient> getAllClients() {
		return clientList.values();
	}

	public synchronized RoomClient getClientByStreamId(String streamId) {
		try {
			if (!clientList.containsKey(streamId)) {
				log.debug("Tried to get a non existing Client " + streamId);
				return null;
			}
			return clientList.get(streamId);
		} catch (Exception err) {
			log.error("[getClientByStreamId]", err);
		}
		return null;
	}
	
	/**
	 * Additionally checks if the client receives sync events
	 * 
	 * Sync events will no be broadcasted to:
	 * - Screensharing users
	 * - Audio/Video connections only
	 * 
	 * @param streamId
	 * @return
	 */
	public synchronized RoomClient getSyncClientByStreamId(String streamId) {
		try {
			if (!clientList.containsKey(streamId)) {
				log.debug("Tried to get a non existing Client " + streamId);
				return null;
			}
			
			RoomClient rcl = clientList.get(streamId);
			
			if (rcl == null) {
				return null;
			}
			
			if (rcl.getIsScreenClient() != null && rcl.getIsScreenClient()) {
				return null;
			}
			
			return clientList.get(streamId);
		} catch (Exception err) {
			log.error("[getClientByStreamId]", err);
		}
		return null;
	}


	public synchronized RoomClient getClientByPublicSID(String publicSID, Boolean isAVClient) {
		try {
			for (Iterator<String> iter = clientList.keySet().iterator(); iter
					.hasNext();) {
				RoomClient rcl = clientList.get(iter.next());
				
				if (!rcl.getPublicSID().equals(publicSID)) {
					continue;
				}
				if (rcl.getIsAVClient() != isAVClient) {
					continue;
				}
				
				return rcl;
			}
		} catch (Exception err) {
			log.error("[getClientByPublicSID]", err);
		}
		return null;
	}

	public synchronized RoomClient getClientByUserId(Long userId) {
		try {
			for (Iterator<String> iter = clientList.keySet().iterator(); iter
					.hasNext();) {
				RoomClient rcl = clientList.get(iter.next());
				if (rcl.getUser_id().equals(userId)) {
					return rcl;
				}
			}
		} catch (Exception err) {
			log.error("[getClientByPublicSID]", err);
		}
		return null;
	}
	
	/**
	 * Update the session object of the audio/video-connection and additionally swap the 
	 * values to the session object of the user that holds the full session object
	 * @param streamId
	 * @param rcm
	 * @return
	 */
	public synchronized Boolean updateAVClientByStreamId(String streamId,
			RoomClient rcm) {
		try {
			
			//get the corresponding user session object and update the settings
			RoomClient rclUsual = getClientByPublicSID(rcm.getPublicSID(), false);
			if (rclUsual != null) {
				rclUsual.setBroadCastID(rcm.getBroadCastID());
				rclUsual.setAvsettings(rcm.getAvsettings());
				rclUsual.setVHeight(rcm.getVHeight());
				rclUsual.setVWidth(rcm.getVWidth());
				rclUsual.setVX(rcm.getVX());
				rclUsual.setVY(rcm.getVY());
				if (clientList.containsKey(rclUsual.getStreamid())) {
					clientList.put(rclUsual.getStreamid(), rclUsual);
				} else {
					 log.debug("Tried to update a non existing Client " + rclUsual.getStreamid());
				}
			}
			
			updateClientByStreamId(streamId, rcm);
		} catch (Exception err) {
			log.error("[updateAVClientByStreamId]", err);
		}
		return null;
	}

	public synchronized Boolean updateClientByStreamId(String streamId,
			RoomClient rcm) {
		try {
			if (clientList.containsKey(streamId)) {
				clientList.put(streamId, rcm);
				return true;
			} else {
				log.debug("Tried to update a non existing Client " + streamId);
				return false;
			}
		} catch (Exception err) {
			log.error("[updateClientByStreamId]", err);
		}
		return null;
	}

	public synchronized Boolean removeClient(String streamId) {
		try {
			if (clientList.containsKey(streamId)) {
				clientList.remove(streamId);
				// log.debug(":: removeClient ::"+clientList.size());
				return true;
			} else {
				log.debug("Tried to remove a non existing Client " + streamId);
				return false;
			}
		} catch (Exception err) {
			log.error("[removeClient]", err);
		}
		return null;
	}

	/**
	 * Get all ClientList Objects of that room and domain This Function is
	 * needed cause it is invoked internally AFTER the current user has been
	 * already removed from the ClientList to see if the Room is empty again and
	 * the PollList can be removed
	 * 
	 * @return
	 */
	// FIXME seems like there is no need to return HashMap
	public synchronized HashMap<String, RoomClient> getClientListByRoom(
			Long room_id) {
		HashMap<String, RoomClient> roomClientList = new HashMap<String, RoomClient>();
		try {
			for (Iterator<String> iter = clientList.keySet().iterator(); iter
					.hasNext();) {
				String key = iter.next();
				RoomClient rcl = clientList.get(key);
				
				// client initialized and same room
				if (rcl.getRoom_id() == null || !room_id.equals(rcl.getRoom_id())) {
					continue;
				}
				if (rcl.getIsScreenClient() == null ||
						rcl.getIsScreenClient()) {
					continue;
				}
				if (rcl.getIsAVClient()) {
					continue;
				}
					
				//Only parse really those users out that are really a full session object 
				//and no pseudo session object like the audio/video or screen sharing connection 
				roomClientList.put(key, rcl);
					
			}
		} catch (Exception err) {
			log.error("[getClientListByRoom]", err);
		}
		return roomClientList;
	}
	
	
	// FIXME seems to be copy/pasted with previous one
	public synchronized HashMap<String, RoomClient> getClientListByRoomAll(
			Long room_id) {
		HashMap<String, RoomClient> roomClientList = new HashMap<String, RoomClient>();
		try {
			for (Iterator<String> iter = clientList.keySet().iterator(); iter
					.hasNext();) {
				String key = iter.next();
				// log.debug("getClientList key: "+key);
				RoomClient rcl = clientList.get(key);

				if (rcl.getRoom_id() != null
						&& rcl.getRoom_id().equals(room_id)) {
					// same room
					roomClientList.put(key, rcl);
				}
			}
		} catch (Exception err) {
			log.error("[getClientListByRoom]", err);
		}
		return roomClientList;
	}

	/**
	 * get the current Moderator in this room
	 * 
	 * @param roomname
	 * @return
	 */
	public synchronized List<RoomClient> getCurrentModeratorByRoom(Long room_id) {

		List<RoomClient> rclList = new LinkedList<RoomClient>();
		for (Iterator<String> iter = clientList.keySet().iterator(); iter
				.hasNext();) {
			String key = iter.next();
			RoomClient rcl = clientList.get(key);
			//
			log.debug("*..*unsetModerator ClientList key: " + rcl.getStreamid());
			//
			// Check if the Client is in the same room
			if (room_id != null && room_id.equals(rcl.getRoom_id())
					&& rcl.getIsMod()) {
				log.debug("found client who is the Moderator: " + rcl);
				rclList.add(rcl);
			}
		}

		return rclList;
	}

	public synchronized SearchResult<RoomClient> getListByStartAndMax(int start, int max,
			String orderby, boolean asc) {
		SearchResult<RoomClient> sResult = new SearchResult<RoomClient>();
		sResult.setObjectName(RoomClient.class.getName());
		sResult.setRecords(Long.valueOf(clientList.size()).longValue());
		LinkedList<RoomClient> myList = new LinkedList<RoomClient>();

		int i = 0;
		// TODO Auto-generated method stub
		Iterator<String> iter = clientList.keySet().iterator();
		while (iter.hasNext()) {
			String key = iter.next();
			if (i >= start) {
				myList.add(clientList.get(key));
			}
			if (i > max) {
				break;
			}
			i++;
		}
		sResult.setResult(myList);

		return sResult;
	}

	public synchronized void removeAllClients() {
		try {
			clientList.clear();
		} catch (Exception err) {
			log.error("[removeAllClients]", err);
		}
	}
}