/*
 * 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.apache.openmeetings.data.calendar.management;

import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;

import org.apache.openmeetings.data.basic.FieldManager;
import org.apache.openmeetings.data.basic.dao.ConfigurationDao;
import org.apache.openmeetings.data.basic.dao.OmTimeZoneDao;
import org.apache.openmeetings.data.calendar.daos.AppointmentDao;
import org.apache.openmeetings.data.calendar.daos.MeetingMemberDao;
import org.apache.openmeetings.data.conference.InvitationManager;
import org.apache.openmeetings.data.conference.RoomManager;
import org.apache.openmeetings.data.conference.dao.RoomDao;
import org.apache.openmeetings.data.user.UserManager;
import org.apache.openmeetings.persistence.beans.basic.OmTimeZone;
import org.apache.openmeetings.persistence.beans.calendar.Appointment;
import org.apache.openmeetings.persistence.beans.calendar.MeetingMember;
import org.apache.openmeetings.persistence.beans.invitation.Invitations;
import org.apache.openmeetings.persistence.beans.lang.Fieldlanguagesvalues;
import org.apache.openmeetings.persistence.beans.room.Room;
import org.apache.openmeetings.persistence.beans.user.User;
import org.apache.openmeetings.utils.math.CalendarPatterns;
import org.apache.openmeetings.utils.math.TimezoneUtil;
import org.red5.logging.Red5LoggerFactory;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;

public class AppointmentLogic {

	private static final Logger log = Red5LoggerFactory.getLogger(
			AppointmentLogic.class, "openmeetings");

	@Autowired
	private AppointmentDao appointmentDao;
	@Autowired
	private ConfigurationDao configurationDao;
	@Autowired
	private UserManager userManager;
	@Autowired
	private FieldManager fieldManager;
	@Autowired
	private OmTimeZoneDao omTimeZoneDaoImpl;
	@Autowired
	private RoomManager roomManager;
	@Autowired
	private RoomDao roomDao;
	@Autowired
	private InvitationManager invitationManager;
	@Autowired
	private MeetingMemberDao meetingMemberDao;
	@Autowired
	private MeetingMemberLogic meetingMemberLogic;
	@Autowired
	private TimezoneUtil timezoneUtil;

	private static int DEFAULT_MINUTES_REMINDER_SEND = 15;

	public List<Appointment> getAppointmentByRange(Long userId, Date starttime,
			Date endtime) {
		try {
			return appointmentDao.getAppointmentsByRange(userId, starttime,
					endtime);
		} catch (Exception err) {
			log.error("[getAppointmentByRange]", err);
		}
		return null;
	}

	public List<Appointment> getTodaysAppointmentsForUser(Long userId) {
		log.debug("getTodaysAppointmentsForUser");

		List<Appointment> points = appointmentDao
				.getTodaysAppointmentsbyRangeAndMember(userId);

		log.debug("Count Appointments for Today : " + points.size());

		return points;

	}

	/**
	 * @author o.becherer
	 * @param room_id
	 * @return
	 */
	// --------------------------------------------------------------------------------------------
	public Appointment getAppointmentByRoom(Long room_id) throws Exception {
		log.debug("getAppointmentByRoom");

		Room room = roomDao.get(room_id);

		if (room == null)
			throw new Exception("Room does not exist in database!");

		if (!room.getAppointment())
			throw new Exception("Room " + room.getName()
					+ " isnt part of an appointed meeting");

		return appointmentDao.getAppointmentByRoom(room_id);
	}

	// --------------------------------------------------------------------------------------------

	// next appointment to current date
	public Appointment getNextAppointment() {
		try {
			return appointmentDao.getNextAppointment(new Date());
		} catch (Exception err) {
			log.error("[getNextAppointmentById]", err);
		}
		return null;
	}

	public List<Appointment> searchAppointmentByName(String appointmentName) {
		try {
			return appointmentDao.searchAppointmentsByName(appointmentName);
		} catch (Exception err) {
			log.error("[searchAppointmentByName]", err);
		}
		return null;
	}

	public Long saveAppointment(String appointmentName, Long userId,
			String appointmentLocation, String appointmentDescription,
			Date appointmentstart, Date appointmentend,
			Boolean isDaily, Boolean isWeekly, Boolean isMonthly,
			Boolean isYearly, Long categoryId, Long remind,
			@SuppressWarnings("rawtypes") List mmClient, Long roomType,
			String baseUrl, Long language_id, Boolean isPasswordProtected,
			String password, long roomId) {

		log.debug("Appointmentlogic.saveAppointment");
		
		// TODO:Add this user as the default Moderator of the Room

		Long numberOfParticipants = configurationDao.getConfValue(
				"calendar.conference.rooms.default.size", Long.class, "50");

		try {

			// Adding creator as MeetingMember
			User user = userManager.getUserById(userId);
			
			Long room_id = roomId > 0 ? roomId : roomManager.addRoom(3, // user level
					appointmentName, // name
					roomType, // RoomType
					"", // Comment
					numberOfParticipants, // Number of participants
					true, // public
					null, // organizations
					true, // Appointment
					false, // Demo Room => Meeting Timer
					null, // Meeting Timer time in seconds
					false, // Is Moderated Room
					null, // Moderation List Room
					true, // Allow User Questions
					false, // isAudioOnly
					true, // allowFontStyles
					false, // isClosed
					"", // redirectURL
					"", // conferencePIN
					null, // ownerID
					null, null, 
					false, // hideTopBar
					false, // hideChat
					false, // hideActivitiesAndActions
					false, // hideFilesExplorer
					false, // hideActionsMenu
					false, // hideScreenSharing 
					false, // hideWhiteboard
					false, //showMicrophoneStatus
					false, // chatModerated
					false, // chatOpened
					false, // filesOpened
					false, // autoVideoSelect
					false //sipEnabled
				);

			log.debug("Appointmentlogic.saveAppointment : Room - " + room_id);
			log.debug("Appointmentlogic.saveAppointment : Reminder - " + remind);
	
			Room room = roomDao.get(room_id);

			// Re-factor the given time ignoring the Date is always UTC!
			TimeZone timezone = timezoneUtil.getTimezoneByUser(user);
			
			Long appointmentId = appointmentDao.addAppointment(appointmentName,
					userId, appointmentLocation, appointmentDescription,
					appointmentstart, appointmentend, isDaily, isWeekly,
					isMonthly, isYearly, categoryId, remind, room, language_id,
					isPasswordProtected, password, false, user.getOmTimeZone().getJname());

			String invitorName = user.getFirstname() + " " + user.getLastname()
					+ " [" + user.getAdresses().getEmail() + "]";

			// Add the creator of the meeting calendar event
			meetingMemberLogic.addMeetingMember(user.getFirstname(), user
					.getLastname(), "", "", appointmentId, userId, user
					.getAdresses().getEmail(), user.getPhoneForSMS(), baseUrl, userId, true,
					language_id, isPasswordProtected, password, timezone, user.getOmTimeZone(),
					invitorName);

			// iterate through all members of this meeting and add them to the
			// event and send invitation
			if (mmClient != null) {

				for (int i = 0; i < mmClient.size(); i++) {

					@SuppressWarnings("rawtypes")
					Map clientMember = (Map) mmClient.get(i);

					log.debug("clientMember.get('userId') "
							+ clientMember.get("userId"));
					
					for (Object tString : clientMember.entrySet()) {
						log.debug("tString " + tString);
					}
					log.debug("clientMember.get('meetingMemberId') "
							+ clientMember.get("meetingMemberId"));

					// We need two different timeZones, the internal Java Object
					// TimeZone, and
					// the one for the UI display object to map to, cause the UI
					// only has around 24 timezones
					// and Java around 600++
					Long sendToUserId = 0L;
					TimeZone timezoneMember = null;
					OmTimeZone omTimeZone = null;
					if (clientMember.get("userId") != null) {
						sendToUserId = Long.valueOf(
								clientMember.get("userId").toString())
								.longValue();
					}

					String phone = "";
					// Check if this is an internal user, if yes use the
					// timezone from his profile otherwise get the timezones
					// from the variable jNameTimeZone
					if (sendToUserId > 0) {
						User interalUser = userManager
								.getUserById(sendToUserId);
						phone = interalUser.getPhoneForSMS();
						timezoneMember = timezoneUtil
								.getTimezoneByUser(interalUser);
						omTimeZone = interalUser.getOmTimeZone();
					} else {
						// Get the internal-name of the timezone set in the
						// client object and convert it to a real one
						Object jName = clientMember.get("jNameTimeZone");
						if (jName == null) {
							log.error("jNameTimeZone not set in user object variable");
							jName = "";
						}
						omTimeZone = omTimeZoneDaoImpl.getOmTimeZone(jName
								.toString());
						timezoneMember = timezoneUtil
								.getTimezoneByInternalJName(jName.toString());
					}

					// Not In Remote List available - intern OR extern user
					meetingMemberLogic.addMeetingMember(
							clientMember.get("firstname").toString(),
							clientMember.get("lastname").toString(),
							"0", // memberStatus
							"0", // appointmentStatus
							appointmentId,
							sendToUserId, // sending To: External users have a 0
											// here
							clientMember.get("email").toString(),
							phone,
							baseUrl,
							userId, // meeting_organizer
							new Boolean(false), // invitor
							language_id, //language_id
							isPasswordProtected, // isPasswordProtected
							password, // password
							timezoneMember, omTimeZone, invitorName);

				}
			}

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

	/**
	 * 
	 * @param appointmentId
	 * @return
	 */
	// -------------------------------------------------------------------------------------
	public Long deleteAppointment(Long appointmentId, Long users_id,
			Long language_id) {
		log.debug("deleteAppointment : " + appointmentId);

		try {

			Appointment point = getAppointMentById(appointmentId);
			
			if (point == null) {
				log.error("No appointment found for ID " + appointmentId);
				return null;
			}

			if (point.getIsConnectedEvent() != null
					&& point.getIsConnectedEvent()) {
				List<Appointment> appointments = appointmentDao
						.getAppointmentsByRoomId(point.getRoom().getRooms_id());

				for (Appointment appointment : appointments) {

					if (!appointment.getAppointmentId().equals(appointmentId)) {

						appointmentDao.deleteAppointement(appointment
								.getAppointmentId());

					}

				}

			}

			Room room = point.getRoom();

			// Deleting/Notifing Meetingmembers
			List<MeetingMember> members = meetingMemberDao
					.getMeetingMemberByAppointmentId(appointmentId);

			if (members == null)
				log.debug("Appointment " + point.getAppointmentName()
						+ " has no meeting members");

			if (members != null) {
				for (int i = 0; i < members.size(); i++) {
					log.debug("deleting member " + members.get(i).getEmail());
					meetingMemberLogic.deleteMeetingMember(members.get(i)
							.getMeetingMemberId(), users_id, language_id);
				}
			}

			// Deleting Appointment itself
			appointmentDao.deleteAppointement(appointmentId);

			// Deleting Room
			boolean isAppRoom = room.getAppointment();
			if (isAppRoom) {
				roomDao.delete(room, users_id);
			}

			return appointmentId;

		} catch (Exception err) {
			log.error("[deleteAppointment]", err);
		}

		return null;

	}

	// -------------------------------------------------------------------------------------

	/**
	 * Retrieving Appointment by ID
	 */
	// ----------------------------------------------------------------------------------------------
	public Appointment getAppointMentById(Long appointment) {
		log.debug("getAppointMentById");

		return appointmentDao.getAppointmentById(appointment);
	}

	// ----------------------------------------------------------------------------------------------

	/**
	 * Sending Reminder in Simple mail format 5 minutes before Meeting begins
	 */
	// ----------------------------------------------------------------------------------------------
	public void doScheduledMeetingReminder() throws Exception {
		// log.debug("doScheduledMeetingReminder");

		Integer minutesReminderSend = configurationDao.getConfValue(
				"number.minutes.reminder.send", Integer.class, ""
						+ DEFAULT_MINUTES_REMINDER_SEND);
		if (minutesReminderSend == null) {
			throw new Exception("minutesReminderSend is null!");
		}

		if (minutesReminderSend == 0) {
			log.warn("minutesReminderSend is 0, disabling reminder scheduler");
			return;
		}

		long millisecondsToCheck = (minutesReminderSend * 60 * 1000);

		List<Appointment> points = appointmentDao
				.getAppointmentsForAllUsersByTimeRangeStartingNow(
						millisecondsToCheck, false);

		if (points == null || points.size() < 1) {
			log.debug("doScheduledMeetingReminder : no Appointments in range");
			return;
		}

		Long language_id = configurationDao.getConfValue("default_lang_id", Long.class, "1");

		// Get the required labels one time for all meeting members. The
		// Language of the email will be the system default language
		String labelid1158 = fieldManager.getString(1158L, language_id);
		Fieldlanguagesvalues labelid1153 = fieldManager
				.getFieldByIdAndLanguage(1153L, language_id);
		Fieldlanguagesvalues labelid1154 = fieldManager
				.getFieldByIdAndLanguage(1154L, language_id);

		for (int i = 0; i < points.size(); i++) {
			Appointment ment = points.get(i);

			// Prevent email from being send twice, even if the cycle takes
			// very long to send each
			if (ment.getIsReminderEmailSend() != null
					&& ment.getIsReminderEmailSend()) {
				continue;
			}

			// Checking ReminderType - only ReminderType simple mail is
			// concerned!
			if (ment.getRemind().getTypId() == 2
					|| ment.getRemind().getTypId() == 3) {

				// Update Appointment to not send invitation twice
				ment.setIsReminderEmailSend(true);
				appointmentDao.updateAppointment(ment);

				List<MeetingMember> members = meetingMemberDao
						.getMeetingMemberByAppointmentId(ment
								.getAppointmentId());

				if (members == null) {
					log.debug("doScheduledMeetingReminder : no members in meeting!");
					continue;
				}

				// Iterate through all MeetingMembers
				for (MeetingMember mm : members) {

					log.debug("doScheduledMeetingReminder : Member "
							+ mm.getEmail());

					Invitations inv = mm.getInvitation();

					if (inv == null) {
						log.error("Error retrieving Invitation for member "
								+ mm.getEmail() + " in Appointment "
								+ ment.getAppointmentName());
						continue;
					}

					if (inv.getBaseUrl() == null
							|| inv.getBaseUrl().length() < 1) {
						log.error("Error retrieving baseUrl from Invitation ID : "
								+ inv.getInvitations_id());
						continue;
					}

					TimeZone tZone = null;

					if (mm.getOmTimeZone() != null) {
						tZone = timezoneUtil.getTimezoneByOmTimeZoneId(mm
								.getOmTimeZone().getOmtimezoneId());
					} else {
						tZone = TimeZone.getDefault();
					}

					String subject = generateSubject(labelid1158, ment, tZone);
					String smsSubject = generateSMSSubject(labelid1158, ment);

					String message = generateMessage(labelid1158, ment,
							language_id, labelid1153, labelid1154, tZone);

					invitationManager.sendInvitationReminderLink(language_id, message,
							inv.getBaseUrl(), mm.getEmail(), subject,
							inv.getHash());

					invitationManager.sendInvitationReminderSMS(mm.getPhone(), smsSubject, language_id);
					inv.setUpdatetime(new Date());
					invitationManager.updateInvitation(inv);
				}
			}
		}
	}

	private String generateSubject(String labelid1158,
			Appointment ment, TimeZone timezone) {

		String message = labelid1158 + " "
				+ ment.getAppointmentName();

		message += ' ' + CalendarPatterns
				.getDateWithTimeByMiliSecondsAndTimeZone(
						ment.getAppointmentStarttime(), timezone);

		message += " - "
				+ CalendarPatterns.getDateWithTimeByMiliSecondsAndTimeZone(
						ment.getAppointmentEndtime(), timezone);

		return message;

	}

	private String generateSMSSubject(String labelid1158, Appointment ment) {
		String subj = configurationDao.getConfValue("sms.subject", String.class, null);
		return subj == null || subj.length() == 0 ? 
				labelid1158 + " " + ment.getAppointmentName() : subj;
	}
	
	/**
	 * Generate a localized message including the time and date of the meeting
	 * event
	 * 
	 * @param labelid1158
	 * @param ment
	 * @param language_id
	 * @param labelid1153
	 * @param jNameTimeZone
	 * @param labelid1154
	 * @return
	 */
	private String generateMessage(String labelid1158,
			Appointment ment, Long language_id,
			Fieldlanguagesvalues labelid1153, Fieldlanguagesvalues labelid1154,
			TimeZone timezone) {

		String message = labelid1158 + " "
				+ ment.getAppointmentName();

		if (ment.getAppointmentDescription().length() != 0) {

			Fieldlanguagesvalues labelid1152 = fieldManager
					.getFieldByIdAndLanguage(new Long(1152), language_id);
			message += labelid1152.getValue()
					+ ment.getAppointmentDescription();

		}

		message += "<br/>"
				+ labelid1153.getValue()
				+ ' '
				+ CalendarPatterns.getDateWithTimeByMiliSecondsAndTimeZone(
						ment.getAppointmentStarttime(), timezone) + "<br/>";

		message += labelid1154.getValue()
				+ ' '
				+ CalendarPatterns.getDateWithTimeByMiliSecondsAndTimeZone(
						ment.getAppointmentEndtime(), timezone) + "<br/>";

		return message;
	}

}