using System;
using System.Linq.Expressions;
using Hangfire;
using LeafWeb.Core.DAL;
using LeafWeb.Core.Entities;
using LeafWeb.Core.Remote;
using NLog;
using Polly;

namespace LeafWeb.Web.Services.PiscalQueue
{
	public abstract class PiscalQueueBase : IDisposable
	{
		protected readonly DataService DataService;
		protected readonly PiscalService PiscalService;
		protected readonly Logger Logger;
		private readonly Policy _retryPolicy;

		protected PiscalQueueBase(DataService dataService, PiscalService piscalService)
		{
			DataService = dataService;
			PiscalService = piscalService;
			Logger = LogManager.GetLogger(GetType().Name);

			_retryPolicy = 
				Policy
				.Handle<TimeoutException>()
				.Retry(3, 
					(exception, i) => Logger.Warn($"Retry {i} after exception: {exception.Message}"));
		}

		protected PiscalQueueBase() : this(new DataService(), new PiscalService()) { }

		protected string FormatException(Exception ex)
		{
			return
				(ex is PiscalClientException ? $"LeafInput: {((PiscalClientException) ex).LeafInputId}{Environment.NewLine}" : "") +
				$"Class: {GetType().Name}{Environment.NewLine}" + 
				$"Exception message: {ex.Message}{Environment.NewLine}" +
				(ex.InnerException != null ? $"InnerException: {ex.InnerException}{Environment.NewLine}" : string.Empty)
				+ $"StackTrace: {ex.StackTrace}";
		}

		protected void PiscalExceptionHandler(PiscalClientException ex, LeafInput leafInput)
		{
			var errorMessage = FormatException(ex);
			Logger.Error(errorMessage);

			// send admin an email
			BackgroundJobEnqueueRetry<EmailNotificationService>(
				email => email.SendAdministratorMessage($"LeafWeb: PiscalQueue {GetType().Name} Exception", errorMessage));

			// send user email too
			BackgroundJobEnqueueRetry<EmailNotificationService>(
				email => email.SendLeafWebSystemException(leafInput.Identifier, leafInput.Email));

			if (leafInput != null)
			{
				DataService.SetLeafInputStatus(leafInput, LeafInputStatusType.Exception, "Error occurred processing LeafInput",
					ex.Message);
			}
		}
		
		public void Dispose()
		{
			DataService.Dispose();
		}

		protected string BackgroundJobEnqueueRetry<T>(Expression<Action<T>> a)
		{
			return _retryPolicy.Execute(() => BackgroundJob.Enqueue(a));
		}
	}
}