/*
 * 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.data.user;

import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

import org.openmeetings.app.OpenmeetingsVariables;
import org.openmeetings.app.data.basic.AuthLevelmanagement;
import org.openmeetings.app.data.beans.basic.SearchResult;
import org.openmeetings.app.data.user.dao.UsersDaoImpl;
import org.openmeetings.app.persistence.beans.domain.Organisation;
import org.openmeetings.app.persistence.beans.domain.Organisation_Users;
import org.openmeetings.app.persistence.beans.user.Users;
import org.red5.logging.Red5LoggerFactory;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

/**
 * 
 * @author swagner
 * 
 */
@Transactional
public class Organisationmanagement {

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

	@PersistenceContext
	private EntityManager em;
	@Autowired
	private UsersDaoImpl usersDao;
	@Autowired
	private AuthLevelmanagement authLevelManagement;

	/**
	 * adds a new organisation if userlevel is admin
	 * 
	 * @param user_level
	 * @param orgname
	 * @param user_id
	 * @return
	 */
	public Long addOrganisation(Long user_level, String orgname, long user_id) {
		try {
			if (authLevelManagement.checkAdminLevel(user_level)) {
				Long orgId = this.addOrganisation(orgname, user_id);
				return orgId;
			}
		} catch (Exception err) {
			log.error("addOrganisation", err);
		}
		return null;
	}

	/**
	 * adds a new organisation to the table organisation
	 * 
	 * @param titelname
	 * @param user_id
	 */
	public Long addOrganisation(String orgname, long user_id) {
		try {
			Organisation org = new Organisation();
			org.setName(orgname);
			org.setInsertedby(new Long(user_id));
			org.setDeleted("false");
			org.setStarttime(new Date());
			org = em.merge(org);

			long id = org.getOrganisation_id();
			return id;
		} catch (Exception ex2) {
			log.error("[addOrganisation]", ex2);
		}
		return null;
	}

	public Long addOrganisationObj(Organisation org) {
		try {
			org.setStarttime(new Date());
			org = em.merge(org);
			long id = org.getOrganisation_id();
			return id;
		} catch (Exception ex2) {
			log.error("[addOrganisationObj]", ex2);
		}
		return null;
	}

	/**
	 * 
	 * @param user_level
	 * @param start
	 * @param max
	 * @param orderby
	 * @return
	 */
	public SearchResult<Organisation> getOrganisations(long user_level, int start, int max,
			String orderby, boolean asc) {
		try {
			if (authLevelManagement.checkAdminLevel(user_level)) {
				SearchResult<Organisation> sresult = new SearchResult<Organisation>();
				sresult.setObjectName(Organisation.class.getName());
				sresult.setRecords(this.selectMaxFromOrganisations());
				sresult.setResult(this.getOrganisations(start, max, orderby,
						asc));
				return sresult;
			} else {
				log.error("[getOrganisations] noPremission");
			}
		} catch (Exception ex2) {
			log.error("[getOrganisations]", ex2);
		}
		return null;
	}

	/**
	 * 
	 * @param user_level
	 * @return
	 */
	public List<Organisation> getOrganisations(int start, int max,
			String orderby, boolean asc) {
		try {
			CriteriaBuilder cb = em.getCriteriaBuilder();
			CriteriaQuery<Organisation> cq = cb.createQuery(Organisation.class);
			Root<Organisation> c = cq.from(Organisation.class);
			Predicate condition = cb.equal(c.get("deleted"), "false");
			cq.where(condition);
			cq.distinct(asc);
			if (asc) {
				cq.orderBy(cb.asc(c.get(orderby)));
			} else {
				cq.orderBy(cb.desc(c.get(orderby)));
			}
			TypedQuery<Organisation> q = em.createQuery(cq);
			q.setFirstResult(start);
			q.setMaxResults(max);
			List<Organisation> ll = q.getResultList();
			return ll;
		} catch (Exception ex2) {
			log.error("[getOrganisations]", ex2);
		}
		return null;
	}

	public List<Organisation> getOrganisations(Long user_level) {
		try {
			if (authLevelManagement.checkAdminLevel(user_level)) {
				CriteriaBuilder cb = em.getCriteriaBuilder();
				CriteriaQuery<Organisation> cq = cb
						.createQuery(Organisation.class);
				Root<Organisation> c = cq.from(Organisation.class);
				Predicate condition = cb.equal(c.get("deleted"), "false");
				cq.where(condition);
				TypedQuery<Organisation> q = em.createQuery(cq);
				List<Organisation> ll = q.getResultList();
				return ll;
			} else {
				log.error("[getOrganisations] noPremission");
			}
		} catch (Exception ex2) {
			log.error("[getOrganisations]", ex2);
		}
		return null;
	}

	/**
	 * 
	 * @return
	 */
	private Long selectMaxFromOrganisations() {
		try {
			// get all users
			TypedQuery<Long> query = em
					.createQuery("select max(c.organisation_id) from Organisation c where c.deleted LIKE 'false'", Long.class);
			Long l = query.getSingleResult();
			log.debug("selectMaxFromOrganisations" + l);
			return l;
		} catch (Exception ex2) {
			log.error("[selectMaxFromUsers] ", ex2);
		}
		return null;
	}

	/**
	 * updates an organisation if user_level is admin
	 * 
	 * @param user_level
	 * @param organisation_id
	 * @param orgname
	 * @param users_id
	 * @param users
	 * @return
	 */
	public Long updateOrganisation(Long user_level, long organisation_id,
			String orgname, long users_id) {
		try {

			Organisation org = this.getOrganisationById(organisation_id);
			org.setName(orgname);
			org.setUpdatedby(users_id);
			org.setUpdatetime(new Date());

			em.merge(org);

			return org.getOrganisation_id();
		} catch (Exception err) {
			log.error("updateOrganisation", err);
		}
		return null;
	}

	/**
	 * checks if a user is already stored
	 * 
	 * @param userIdToAdd
	 * @param usersStored
	 * @return
	 * @throws Exception
	 */
	private boolean checkUserAlreadyStored(Long userIdToAdd, List<?> usersStored)
			throws Exception {
		for (Iterator<?> it2 = usersStored.iterator(); it2.hasNext();) {
			Users us = (Users) it2.next();
			if (us.getUser_id().equals(userIdToAdd)) {
				log.debug("userIdToAdd found: " + userIdToAdd);
				return true;
			}
		}
		return false;
	}

	/**
	 * 
	 * @param user_id
	 * @param usersToStore
	 * @return
	 * @throws Exception
	 */
	private boolean checkUserShouldBeStored(Long user_id,
			@SuppressWarnings("rawtypes") LinkedHashMap usersToStore)
			throws Exception {
		for (Iterator<?> it2 = usersToStore.keySet().iterator(); it2.hasNext();) {
			Integer key = (Integer) it2.next();
			Long usersIdToCheck = Long
					.valueOf(usersToStore.get(key).toString()).longValue();
			log.debug("usersIdToCheck: " + usersIdToCheck);
			if (user_id.equals(usersIdToCheck)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * TODO
	 * 
	 * @param org
	 * @param users
	 * @return
	 */
	@SuppressWarnings({ "unused", "rawtypes" })
	private Long updateOrganisationUsersByHashMap(Organisation org,
			LinkedHashMap users, long insertedby) {
		try {
			LinkedList<Long> usersToAdd = new LinkedList<Long>();
			LinkedList<Long> usersToDel = new LinkedList<Long>();

			List usersStored = this.getUsersByOrganisationId(org
					.getOrganisation_id());

			for (Iterator it = users.keySet().iterator(); it.hasNext();) {
				Integer key = (Integer) it.next();
				Long userIdToAdd = Long.valueOf(users.get(key).toString())
						.longValue();
				log.error("userIdToAdd: " + userIdToAdd);
				if (!this.checkUserAlreadyStored(userIdToAdd, usersStored))
					usersToAdd.add(userIdToAdd);
			}

			for (Iterator it = usersStored.iterator(); it.hasNext();) {
				Users us = (Users) it.next();
				Long userIdStored = us.getUser_id();
				log.error("userIdStored: " + userIdStored);
				if (!this.checkUserShouldBeStored(userIdStored, users))
					usersToDel.add(userIdStored);
			}

			log.debug("usersToAdd.size " + usersToAdd.size());
			log.debug("usersToDel.size " + usersToDel.size());

			for (Iterator<Long> it = usersToAdd.iterator(); it.hasNext();) {
				Long user_id = it.next();
				this.addUserToOrganisation(user_id, org.getOrganisation_id(),
						insertedby);
			}

			for (Iterator<Long> it = usersToDel.iterator(); it.hasNext();) {
				Long user_id = it.next();
				this.deleteUserFromOrganisation(new Long(3), user_id,
						org.getOrganisation_id());
			}

		} catch (Exception err) {
			log.error("updateOrganisationUsersByHashMap", err);
		}
		return null;
	}

	/**
	 * get an organisation by id and only as admin
	 * 
	 * @param user_level
	 * @param organisation_id
	 * @return
	 */
	public Organisation getOrganisationById(long user_level,
			long organisation_id) {
		try {
			if (authLevelManagement.checkAdminLevel(user_level)) {
				return this.getOrganisationById(organisation_id);
			} else {
				log.error("[getOrganisationById] authorization required");
			}
		} catch (Exception ex2) {
			log.error("[getOrganisationById]", ex2);
		}
		return null;
	}

	/**
	 * Gets an organisation by its id
	 * 
	 * @param organisation_id
	 * @return
	 */
	public Organisation getOrganisationById(long organisation_id) {
		try {
			TypedQuery<Organisation> query = em.createNamedQuery("getOrganisationById", Organisation.class);
			query.setParameter("organisation_id", organisation_id);
			query.setParameter("deleted", "true");
			Organisation o = null;
			try {
				o = query.getSingleResult();
			} catch (NoResultException e) {
				// o = null;
			}
			return o;
		} catch (Exception ex2) {
			log.error("[getOrganisationById]", ex2);
		}
		return null;
	}

	public Organisation getOrganisationByIdBackup(long organisation_id) {
		try {
			TypedQuery<Organisation> query = em.createNamedQuery("getAnyOrganisationById", Organisation.class);
			query.setParameter("organisation_id", organisation_id);
			Organisation o = null;
			try {
				o = query.getSingleResult();
			} catch (NoResultException e) {
				// o = null;
			}
			return o;
		} catch (Exception ex2) {
			log.error("[getOrganisationById]", ex2);
		}
		return null;
	}

	public Organisation getOrganisationByIdAndDeleted(long organisation_id) {
		return getOrganisationByIdBackup(organisation_id);
	}

	public Long deleteOrganisation(long user_level, long organisation_id,
			long updatedby) {
		try {
			if (authLevelManagement.checkAdminLevel(user_level)) {
				return this.deleteOrganisation(organisation_id, updatedby);
			}
		} catch (Exception ex2) {
			log.error("[deleteOrganisation]", ex2);
		}
		return null;
	}

	/**
	 * 
	 * @param organisation_id
	 * @param updatedby
	 * @return
	 */
	public Long deleteOrganisation(long organisation_id, long updatedby) {
		try {
			em.createNamedQuery("deleteUsersFromOrganisation")
				.setParameter("organisation_id", organisation_id)
				.executeUpdate();

			Organisation org = this.getOrganisationById(organisation_id);
			org.setDeleted("true");
			org.setUpdatedby(updatedby);

			if (org.getOrganisation_id() == null) {
				em.persist(org);
			} else {
				if (!em.contains(org)) {
					em.merge(org);
				}
			}

			return org.getOrganisation_id();

		} catch (Exception ex2) {
			log.error("[deleteOrganisation]", ex2);
		}
		return null;
	}

	/**
	 * Adds a user to a given organisation-unit
	 * 
	 * @param user_id
	 * @param organisation_id
	 * @param insertedby
	 * @return
	 */
	public Long addUserToOrganisation(Long user_id, Long organisation_id,
			Long insertedby) {
		try {
			if (this.getOrganisation_UserByUserAndOrganisation(user_id, organisation_id) == null) {
				return addOrganisationUserObj(user_id, getOrgUser(organisation_id, insertedby));
			} else {
				return -35L;
			}
		} catch (Exception ex2) {
			log.error("[addUserToOrganisation]", ex2);
		}
		return null;
	}
	
	public Organisation_Users getOrgUser(Long organisation_id,
			Long insertedby) {
		
		Organisation_Users orgUser = new Organisation_Users();
		orgUser.setOrganisation(getOrganisationById(organisation_id));
		orgUser.setDeleted("false");
		
		return orgUser;
	}
	
	public Long addOrganisationUserObj(Long user_id, Organisation_Users orgUser) {
		try {
			Users u = usersDao.getUser(user_id);
			
			orgUser.setStarttime(new Date());
			orgUser = em.merge(orgUser);

			//user should be updated to have recent organisation_users list
			List<Organisation_Users> l = u.getOrganisation_users();
			l.add(orgUser);
			u.setOrganisation_users(l);
			usersDao.updateUser(u);
			
			return orgUser.getOrganisation_users_id();
		} catch (Exception ex2) {
			log.error("[addUserToOrganisation]", ex2);
		}
		return null;
	}

	public Organisation_Users getOrganisation_UserByUserAndOrganisation(
			long user_id, long organisation_id) {
		try {
			log.debug("getOrganisation_UserByUserAndOrganisation " + user_id
					+ "  " + organisation_id);

			TypedQuery<Organisation_Users> q = em.createNamedQuery("getOrganisation_UserByUserAndOrganisation", Organisation_Users.class);
			q.setParameter("organisation_id", organisation_id);
			q.setParameter("user_id", user_id);
			List<Organisation_Users> oul = q.getResultList();
			return oul.size() > 0 ? oul.get(0) : null;
		} catch (Exception ex2) {
			log.error("[getOrganisation_UserByUserAndOrganisation]", ex2);
		}
		return null;
	}

	public Long deleteUserFromOrganisation(Long user_level, long user_id,
			long organisation_id) {
		try {
			if (authLevelManagement.checkAdminLevel(user_level)) {

				log.error("deleteUserFromOrganisation " + user_id + "  "
						+ organisation_id);
				//user should be updated to have recent organisation_users list
				Long id = null;
				Users u = usersDao.getUser(user_id);
				List<Organisation_Users> l = u.getOrganisation_users();
				for (Organisation_Users ou : l) {
					if (ou.getOrganisation().getOrganisation_id().equals(organisation_id)) {
						l.remove(ou);
						id = ou.getOrganisation_users_id();
						em.remove(ou);
						break;
					}
				}
				u.setOrganisation_users(l);
				usersDao.updateUser(u);

				return id;
			} else {
				log.error("[deleteUserFromOrganisation] authorization required");
			}
		} catch (Exception ex2) {
			log.error("[deleteuserFromOrganisation]", ex2);
		}
		return null;
	}

	public SearchResult<Users> getUsersSearchResultByOrganisationId(
			long organisation_id, int start, int max, String orderby,
			boolean asc) {
		try {

			SearchResult<Users> sResult = new SearchResult<Users>();
			sResult.setObjectName(Users.class.getName());
			sResult.setRecords(selectMaxUsersByOrganisationId(organisation_id));
			sResult.setResult(getUsersByOrganisationId(organisation_id,
					start, max, orderby, asc));
			return sResult;

		} catch (Exception ex2) {
			log.error("[getUsersSearchResultByOrganisationId]", ex2);
		}
		return null;
	}

	private Long selectMaxUsersByOrganisationId(long organisation_id) {
		try {
			TypedQuery<Long> query = em.createNamedQuery("selectMaxUsersByOrganisationId", Long.class);
			query.setParameter("organisation_id", organisation_id);

			Long l = query.getSingleResult();
			log.debug("selectMaxUsersByOrganisationId" + l);
			return l;

		} catch (Exception ex2) {
			log.error("[getUsersByOrganisationId]", ex2);
		}
		return null;
	}

	/**
	 * get a list of all users of an organisation
	 * 
	 * @param user_level
	 * @param organisation_id
	 * @param start
	 * @param max
	 * @param orderby
	 * @param asc
	 * @return
	 */
	public List<Users> getUsersByOrganisationId(long organisation_id, int start,
			int max, String orderby, boolean asc) {
		try {
			String hql =
				"SELECT c FROM "
				+ "Users c "
				+ ", IN(c.organisation_users) ou "
				+ "WHERE c.deleted = 'false' AND ou.organisation.organisation_id = :organisation_id ";
			if (orderby.startsWith("c.")) {
				hql += "ORDER BY " + orderby;
			} else {
				hql += "ORDER BY " + "c." + orderby;
			}
			if (asc) {
				hql += " ASC";
			} else {
				hql += " DESC";
			}

			TypedQuery<Users> q = em.createQuery(hql, Users.class);
			q.setParameter("organisation_id", organisation_id);
			q.setFirstResult(start);
			q.setMaxResults(max);

			List<Users> userL = q.getResultList();
			return userL;
		} catch (Exception ex2) {
			log.error("[getUsersByOrganisationId]", ex2);
		}
		return null;
	}

	/**
	 * 
	 * @param organisation_id
	 * @return
	 */
	public List<Users> getUsersByOrganisationId(long organisation_id) {
		try {

			// get all users
			TypedQuery<Users> q = em.createNamedQuery("getUsersByOrganisationId", Users.class);
			q.setParameter("organisation_id", organisation_id);
			List<Users> userL = q.getResultList();
			Collections.sort(userL, new UsersLoginComparator());
			return userL;

		} catch (Exception ex2) {
			log.error("[getUsersByOrganisationId]", ex2);
		}
		return null;
	}

	class UsersLoginComparator implements Comparator<Users> {
		public int compare(Users o1, Users o2) {
			if (o1 == null || o2 == null)
				return 0;

			return o1.getLogin().compareTo(o2.getLogin());
		}
	}

	/**
	 * Filter all Organisations by user TODO: Add sorting
	 * 
	 * @param user_level
	 * @param users_id
	 * @param start
	 * @param max
	 * @param orderby
	 * @return
	 */
	public List<Organisation> getOrganisationsByUserId(long user_level,
			long user_id, int start, int max, String orderby, boolean asc) {
		try {
			if (authLevelManagement.checkAdminLevel(user_level)) {
				TypedQuery<Organisation> q = em.createNamedQuery("getOrganisationsByUserId", Organisation.class);
				q.setParameter("user_id", user_id);
				q.setFirstResult(start);
				q.setMaxResults(max);

				List<Organisation> userOrg = q.getResultList();

				return userOrg;
			}
		} catch (Exception ex2) {
			log.error("[getOrganisationsByUserId]", ex2);
		}
		return null;
	}

	/**
	 * 
	 * @param user_level
	 * @param user_id
	 * @param start
	 * @param max
	 * @param orderby
	 * @param asc
	 * @return
	 */
	public List<Organisation> getRestOrganisationsByUserId(long user_level,
			long user_id, int start, int max, String orderby, boolean asc) {
		try {
			if (authLevelManagement.checkAdminLevel(user_level)) {
				String qSQL =
					"SELECT o FROM Organisation AS o "
					+ "WHERE o.organisation_id NOT IN ("
					+ "	SELECT ou.organisation.organisation_id "
					+ "	FROM Users u, IN(u.organisation_users) ou WHERE u.deleted = 'false' AND u.user_id = :user_id)";
				TypedQuery<Organisation> q = em.createQuery(qSQL, Organisation.class);
				q.setParameter("user_id", user_id);
				q.setFirstResult(start);
				q.setMaxResults(max);
				return q.getResultList();
			}
		} catch (Exception ex2) {
			log.error("[getRestOrganisationsByUserId]", ex2);
		}
		return null;
	}

	/**
	 * checks if the orgId is in the list of orgIds which have been send as
	 * organisations
	 * 
	 * @param orgId
	 * @param org
	 * @return
	 * @throws Exception
	 */
	private boolean checkOrgInList(Long orgId, List<Long> org) throws Exception {
		return org != null && org.contains(orgId);
	}

	/**
	 * checks if an orgId is already stored in the Users Organisations Object
	 * 
	 * @param orgId
	 * @param org
	 * @return
	 * @throws Exception
	 */
	private boolean checkOrgInStoredList(long orgId, List<Organisation_Users> org) throws Exception {
		// log.debug("checkOrgInStoredList "+orgId);
		for (Organisation_Users orgUsers : org) {
			// log.debug("checkOrgInStoredList 2 "+orgUsers.getOrganisation().getOrganisation_id());
			if (orgUsers.getOrganisation().getOrganisation_id().equals(orgId)) {
				// log.debug("checkOrgInStoredList 3 found");
				return true;
			}
		}
		return false;
	}

	/**
	 * updates users-organisations by a given params
	 * 
	 * @param us
	 * @param organisations
	 * @return
	 */
	//FIXME need to refactor
	public Long updateUserOrganisationsByUser(Users us, List<Long> organisations) {
		try {
			LinkedList<Long> orgIdsToAdd = new LinkedList<Long>();
			LinkedList<Long> orgIdsToDelete = new LinkedList<Long>();

			if (us.getOrganisation_users() != null) {
				for (Long orgIdToAdd : organisations) {
					boolean isAlreadyStored = this.checkOrgInStoredList(
							orgIdToAdd, us.getOrganisation_users());
					if (!isAlreadyStored)
						orgIdsToAdd.add(orgIdToAdd);
				}

				for (Organisation_Users orgUsers : us.getOrganisation_users()) {
					Long orgIdStored = orgUsers.getOrganisation()
							.getOrganisation_id();
					// log.error("updateUserOrganisationsByUser check1 : "+orgIdStored);
					boolean shouldBeStored = this.checkOrgInList(orgIdStored,
							organisations);
					if (!shouldBeStored)
						orgIdsToDelete.add(orgIdStored);
				}

				// log.error("updateUserOrganisationsByUser size ADD: "+orgIdsToAdd.size());
				for (Long orgToAdd : orgIdsToAdd) {
					this.addUserToOrganisation(us.getUser_id(), orgToAdd,
							us.getUser_id());
				}

				// log.error("updateUserOrganisationsByUser size DELETE: "+orgIdsToDelete.size());
				for (Long orgToDel : orgIdsToDelete) {
					this.deleteUserFromOrganisation(new Long(3),
							us.getUser_id(), orgToDel);
				}
			}
		} catch (Exception err) {
			log.error("[updateUserOrganisationsByUser] ", err);
		}
		return null;
	}

	/**
	 * adds all send organisations to this User-Object (for newly
	 * registered/created Users)
	 * 
	 * @param us
	 * @param org
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	public Long addUserOrganisationsByHashMap(long us, List org) {
		try {
			if (org != null) {
				for (Iterator it = org.iterator(); it.hasNext();) {
					Integer key = (Integer) it.next();
					Long newOrgId = key.longValue();
					this.addUserToOrganisation(us, newOrgId, new Long(1));
				}
			}
		} catch (Exception ex) {
			log.error("addUserOrganisationsByHashMap", ex);
		}
		return null;
	}

}