using System;
using System.Collections.Generic;
using System.IO;
using LCU.Api.Internal.FileOperations.Validations;
using LCU.Library.Internal.FileOperationsModels.Models;
using LCU.Library.Internal.FileOperationsModels.Shared;
using LCU.Library.Internal.LCUServiceFactory.Configurations;
using Newtonsoft.Json;

namespace LCU.Api.Internal.FileOperations.Services.FileActionServices
{
	public class DeleteEmptyDirectoryService : FileActionService, IFileActionService, IActionService<DeleteEmptyDirectoryRequest>
	{
		public DeleteEmptyDirectoryService(ServicesFactoryConfiguration servicesFactoryConfiguration)
			: base(servicesFactoryConfiguration)
		{
		}

		public RequestResponse ExecuteAction(QueueRequest queueRequest)
		{
			var requestResponse = new RequestResponse();
			try
			{
				var directoryRequest = JsonConvert.DeserializeObject<DeleteEmptyDirectoryRequest>(queueRequest.Request);

				var requests = BuildListOfRequest(directoryRequest);

				foreach (var request in requests)
				{
					if (DirectoryValidation.ValidateDirectoryIsEmpty(request.FinalDirectoryPath, new RequestResponse()).IsSuccessful)
					{
						var temporaryRequestResponse = PerformRequest(request);

						if (!temporaryRequestResponse.IsSuccessful)
						{
							requestResponse.IsSuccessful = temporaryRequestResponse.IsSuccessful;
							requestResponse.MessageStack.AddRange(temporaryRequestResponse.MessageStack);
						}
					}
					else
					{
						requestResponse.MessageStack.Add($"Directory {request.FinalDirectoryPath} is skipped as it is not empty and won't be deleted.");
					}
				}

				requestResponse.ReturnResponse = directoryRequest;
				return requestResponse;
			}
			catch (Exception exception)
			{

				return RequestResponseHelper.ExceptionUpdateRequestResponse(requestResponse,
																			queueRequest.FileOperationType,
																			exception.Message);
			}
		}

		public RequestResponse PerformRequest(DeleteEmptyDirectoryRequest request)
		{
			return OperationService.PerformOperation(request, IsRequestValid, DeleteEmptyDirectory);
		}

		private void DeleteEmptyDirectory(DeleteEmptyDirectoryRequest request)
		{
			try
			{
				Directory.Delete(request.FinalDirectoryPath);

			}
			catch (Exception exception)
			{
				throw new Exception($"Exception thrown while trying to ExecuteRequestAction. " +
									$"Request: {JsonConvert.SerializeObject(request)}" +
									$"ExceptionMessage: {exception.Message}");
			}
		}

		public RequestResponse PreQueueValidation(DeleteEmptyDirectoryRequest originalRequest)
		{
			var requestResponse = new RequestResponse();
			requestResponse = DirectoryValidation.ValidateDirectoryExists(originalRequest.SubDirectoryPath, requestResponse);
			if (!requestResponse.IsSuccessful)
			{
				return requestResponse;
			}

			var requestList = BuildListOfRequest(originalRequest);

			foreach (var request in requestList)
			{
				requestResponse = IsRequestValid(request, requestResponse);
			}

			return requestResponse;
		}

		public RequestResponse IsRequestValid(DeleteEmptyDirectoryRequest request, RequestResponse requestResponse)
		{
			requestResponse = DirectoryValidation.ValidateDirectoryExists(request.FinalDirectoryPath, requestResponse);
			return requestResponse;
		}

		private List<DeleteEmptyDirectoryRequest> BuildListOfRequest(DeleteEmptyDirectoryRequest originalRequest)
		{
			var nameList = RegexNameHandler.BuildDirectoryList(originalRequest.SubDirectoryPath,
															   originalRequest.FinalDirectoryName,
															   originalRequest.DirectoryNameSettings);

			var requests = new List<DeleteEmptyDirectoryRequest>();

			foreach (var name in nameList)
			{
				var newRequest = Clone.DeepClone(originalRequest);
				newRequest.DynamicDirectoryName = name;

				requests.Add(newRequest);
			}

			return requests;
		}
	}
}