using System;
using System.Collections.Generic;
using System.Configuration;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Mail;
using System.Security.Cryptography;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Text;
using System.Text.RegularExpressions;
using System.Xml;

using BeWo.Data;
using BeWo.Data.Entities;
using BeWo.Data.Security;
using BeWo.ServerUtils.Core;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.Extensions;

namespace BeWo.Service.Core
{
	public class Utils
	{
		private static readonly Regex indexRegex = new Regex("(?:Index=\"){1}([0-9]+)\"{1}");
		private static readonly Regex idRegex = new Regex("(?:Id=\")(([a-z0-9]{8})-{1}([a-z0-9]{4})-{1}([a-z0-9]{4})-{1}([a-z0-9]{4})-{1}([a-z0-9]{12}))(?=\"{1})");

		public static FaultException<BeWoFault> CreateBeWoFaultException(Exception ex)
		{
			try
			{
				//SendErrorMail("MYSQL EXCEPTION - AUTOMATED MAIL NOTIFICATION", ex.ToString());
			}
			catch
			{
			}

			return new FaultException<BeWoFault>(new BeWoFault(ex), ex.ToString());
		}

		public static string GetClientIP()
		{
			if (OperationContext.Current != null)
			{
				MessageProperties properties = OperationContext.Current.IncomingMessageProperties;
				var endpoint = properties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty;
				return endpoint.Address;
			}
			return null;
		}

		public static string GetMD5(string val)
		{
			var lMD5 = new MD5CryptoServiceProvider();
			string lHash = BitConverter.ToString(lMD5.ComputeHash(Encoding.UTF8.GetBytes(val)));
			return lHash;
		}

		public static string GetSHA256(string val)
		{
			var csp = new SHA256CryptoServiceProvider();
			string lHash = BitConverter.ToString(csp.ComputeHash(Encoding.UTF8.GetBytes(val)));
			return lHash;
		}

		public static bool SendErrorMail(string subject, string body)
		{
			string sendMailSetting = ConfigurationManager.AppSettings.Get("SendMailOnError");
			bool sendMail = false;
			if (bool.TryParse(sendMailSetting, out sendMail))
			{
				if (sendMail)
					return SendMail(subject, body, ConfigurationManager.AppSettings.Get("Recipient"));
			}
			return false;
		}

		//public static bool SendMail(string subject, string body, string toAddress)
		//      {
		//       return SendMail(subject, body, toAddress, null, null);
		//      }

		public static bool SendMail(string subject, string body, string toAddress,
			string senderName = null, string senderEMail = null, bool skipTenant = false,
			string smtpServer = null, string smtpUser = null, string smtpPassword = null)
		{
			if (string.IsNullOrEmpty(smtpServer))
				smtpServer = ConfigurationManager.AppSettings.Get("SmptServer");

			if (string.IsNullOrEmpty(smtpUser))
				smtpUser = ConfigurationManager.AppSettings.Get("SmtpUser");

			if (string.IsNullOrEmpty(smtpPassword))
				smtpPassword = ConfigurationManager.AppSettings.Get("SmtpPassword");
			if (string.IsNullOrEmpty(smtpPassword))
				smtpPassword = "JJVjJntw2yaRDAxInotF";

			string to = toAddress;
			if (string.IsNullOrEmpty(to))
				to = ConfigurationManager.AppSettings.Get("SupportEMail");
			if (string.IsNullOrEmpty(to))
				to = "support@bewoplaner.de";

			if (string.IsNullOrEmpty(senderEMail))
				senderEMail = "bewoapp@bewoplaner.de";

			bool sendAsync = true;
			if (to.Equals("support@bewoplaner.de"))
			{
				sendAsync = false;
			}

			string body2;
			if (skipTenant)
			{
				body2 = "Kunde: " + (MultitenancyOperationContextExt.Current?.Tenant ?? "unknown");
				sendAsync = false;
			}
			else
			{
				body2 = "Kunde: " + MultitenancyOperationContextExt.Current.Tenant;
				body2 += "\nRPL2-Mail: " + senderEMail;
				//body2 += "\r\nIP: " + GetClientIP();
			}

			body += "\n\n" + body2;

			senderEMail = senderEMail.Trim();

			return SendMail2(subject, body, to, senderName, senderEMail, smtpServer, smtpUser, smtpPassword, sendAsync);
		}

		private static bool SendMail2(string subject, string body, string toAddress, string senderName, string senderEMail, string smtpServer, string smtpUser, string smtpPassword, bool sendAsync)
		{
			try
			{
				if (!MailUtils.IsValidEmail(toAddress) || !MailUtils.IsValidEmail(senderEMail))
				{
					return false;
				}

				String from = senderEMail;

				if (toAddress.Equals("support@bewoplaner.de"))
				{
					var supportSenderMail = ConfigurationManager.AppSettings.Get("SupportSenderEMail");
					if (String.IsNullOrEmpty(supportSenderMail))
						supportSenderMail = "noreply@bewoplaner.de";

					from = supportSenderMail;

				}


				MailMessage message = null;
				if (String.IsNullOrEmpty(senderName))
					message = new MailMessage(from, toAddress, subject, body);
				else
				{
					MailAddress fromMailAddress = new MailAddress(from);
					MailAddress toMailAddress = new MailAddress(toAddress);

					message = new MailMessage(fromMailAddress, toMailAddress);
					message.Subject = subject;
					message.Body = body;
				}
				if (senderEMail != from)
				{
					//Das hier rausnehmen wenn Mike OK gibt
					//message.ReplyToList.Add(new MailAddress(senderEMail, senderName));
				}


				message.BodyEncoding = Encoding.UTF8;
				message.IsBodyHtml = false;

				var mailClient = new SmtpClient(smtpServer, 587) { Credentials = new NetworkCredential(smtpUser, smtpPassword) };
				mailClient.EnableSsl = true;

				if (sendAsync)
				{
					mailClient.SendAsync(message, null);
				}
				else
				{
					mailClient.Send(message);
				}

				return true;
			}
			catch (Exception e)
			{
				return false;
			}
		}

		public static string[][] T(List<string> pSearchParameter, int pSearchFieldCount)
		{
			//List<string> lDifferentParameter;

			return null;
		}

		public static string GetRecurringAppointmentsId(SchedulerAppointment appointment)
		{
			var erg = string.Empty;

			if (appointment.RecurrenceInfo == null)
				return erg;

			using (var reader = XmlReader.Create(new StringReader(appointment.RecurrenceInfo)))
			{
				reader.ReadToFollowing("RecurrenceInfo");
				reader.MoveToAttribute("Id");
				erg = reader.Value;
			}

			return erg;
		}

		public static DateTime[] GetRecurrenceInterval(SchedulerAppointment appointment)
		{
			var erg = new DateTime[2];

			using (var reader = XmlReader.Create(new StringReader(appointment.RecurrenceInfo)))
			{
				reader.ReadToFollowing("RecurrenceInfo");

				reader.MoveToAttribute("Start");
				DateTime outValue;
				var parsingSuccessful = DateTime.TryParseExact(reader.Value, @"MM\/dd\/yyyy HH:mm:ss", null, DateTimeStyles.None, out outValue);
				erg[0] = outValue;
				reader.MoveToAttribute("End");
				parsingSuccessful = DateTime.TryParseExact(reader.Value, @"MM\/dd\/yyyy HH:mm:ss", null, DateTimeStyles.None, out outValue);
				erg[1] = outValue;
			}

			return erg;
		}


		public static bool UserHasRight(ApplicationUser user, UserRightType right) => UserRightHelper.UserHasRight(user, right);
		public static List<UserRightType> GetGrantedRights(ApplicationUser user) => UserRightHelper.GetGrantedRights(user);

		public static string GetRecurrenceIdFromRecurrenceInfo(string pRecurrenceInfo)
		{
			var regex = new Regex("(Id=\\\"[a-z0-9-]+\\\")");

			var match = regex.Match(pRecurrenceInfo);
			if (match.Success)
			{
				var value = match.Value;
				var actualId = value.Split("\"");
				if (actualId.Count > 1)
				{
					return actualId[1];
				}
			}

			return null;
		}

		public static string GetRecurrenceIndexFromRecurrenceInfo(string pRecurrenceInfo)
		{
			if (!pRecurrenceInfo.Contains("Index"))
			{
				return null;
			}

			var regex = new Regex("(Index=\\\"\\d+\\\")");

			var match = regex.Match(pRecurrenceInfo);
			if (match.Success)
			{
				var value = match.Value;
				var actualIndex = value.Split("\"");

				if (actualIndex.Count > 1)
				{
					return actualIndex[1];
				}
			}

			return null;
		}

		public static List<string> ExtractRecurrenceIdFromRecurrenceString(List<SchedulerAppointment> appointments)
		{
			var result = new List<string>();

			foreach (var recurrenceInfo in appointments.Where(w => w.RecurrenceInfo != null).Select(s => s.RecurrenceInfo))
			{
				var id = GetRecurrenceIdFromRecurrenceInfo(recurrenceInfo);

				if (id != null)
				{
					result.AddIfNotIn(id);
				}
			}

			return result;
		}

		public static string ExtractIdFromRecurrenceInfo(string pRecurrenceInfo)
		{
			return pRecurrenceInfo != null ? idRegex.Match(pRecurrenceInfo).Groups[1].Value : null;
		}

		public static int ExtractIndexFromRecurrenceInfo(string pRecurrenceInfo)
		{
			if (pRecurrenceInfo != null)
			{
				var indexString = indexRegex.Match(pRecurrenceInfo).Groups[1].Value;

				var index = !string.IsNullOrEmpty(indexString) ? int.Parse(indexString) : 0;

				return index;
			}

			return -1;
		}
	}
}