using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using LCU.Library.Internal.LCUServiceFactory.Configurations;
using LCU.Library.Internal.FileOperationsModels.Models;
using LCU.Library.Internal.FileOperationsModels.Shared;
using LCU.Library.Internal.FileOperationsModels.Enums;
using LCU.Api.Internal.FileOperations.Validations;
using LCU.Library.Internal.FileOperationsModels.Models.Requests;
using Microsoft.OpenApi.Extensions;
namespace LCU.Api.Internal.FileOperations.Services.FileActionServices;

public class ValidateFileService : FileActionService, IFileActionService, IActionService<ValidateFileRequest>
{
    public ValidateFileService(ServicesFactoryConfiguration servicesFactoryConfiguration)
        : base(servicesFactoryConfiguration)
    {
    }

    public RequestResponse ExecuteAction(QueueRequest queueRequest)
    {
        var requestResponse = new RequestResponse();
        try
        {
            var fileRequest = JsonConvert.DeserializeObject<ValidateFileRequest>(queueRequest.Request);
            var requests = DynamicNameBuilder.BuildListOfRequests(fileRequest);

            if (fileRequest.FileDoesExist)
            {
                requestResponse = FileValidation.ValidateIfAnyRequest(requests, fileRequest.FileSourceRequest.Source, requestResponse);
            }

            if (fileRequest.CheckFileCount)
            {
                if (!ValidateFileCount(fileRequest, requests))
                {
                    requestResponse.MessageStack.Add($"The file count condition returned false: {requests.Count} {fileRequest.OperatorType.GetDisplayName()} {fileRequest.FileCount} ");
                    requestResponse.IsSuccessful = false;
                }
            }

            requestResponse = PerformRequests(requests, requestResponse);

            requestResponse.ReturnResponse = fileRequest;
            return requestResponse;
        }
        catch (Exception exception)
        {
            return RequestResponseHelper.ExceptionUpdateRequestResponse(requestResponse,
                                                                   queueRequest.FileOperationType,
                                                                   exception.Message);
        }
    }

    public bool ValidateFileCount(ValidateFileRequest fileRequest, List<ValidateFileRequest> requests)
       => fileRequest.OperatorType switch
       {
           OperatorTypes.Equals => (requests.Count == fileRequest.FileCount),
           OperatorTypes.GreaterThan => (requests.Count > fileRequest.FileCount),
           OperatorTypes.GreaterThanEquals => (requests.Count >= fileRequest.FileCount ),
           OperatorTypes.LessThan => (requests.Count < fileRequest.FileCount),
           OperatorTypes.LessThanEquals => (requests.Count <= fileRequest.FileCount ),
           _ => throw new ArgumentOutOfRangeException(nameof(fileRequest.OperatorType), $"Not expected OperatorType value: {fileRequest.OperatorType}"),
       };


    public RequestResponse PerformRequests(List<ValidateFileRequest> requests, RequestResponse requestResponse)
    {
        foreach (var request in requests)
        {
            var temporaryRequestResponse = PerformRequest(request);
            if (!temporaryRequestResponse.IsSuccessful)
            {
                requestResponse.MessageStack.AddRange(temporaryRequestResponse.MessageStack);
                requestResponse.IsSuccessful = false;
            }
        }
        return requestResponse;
    }

    public RequestResponse PerformRequest(ValidateFileRequest request)
    {
        var requestResponse = new RequestResponse();
        if (request.FileDoesExist)
        {
            return FileValidation.ValidateFileExists(request.FileSourceRequest.Source, requestResponse);
        }
        return FileValidation.ValidateFileNotExists(request.FileSourceRequest.Source, requestResponse);
    }

    public RequestResponse PreQueueValidation(ValidateFileRequest originalRequest)
    {
        var requestResponse = new RequestResponse();
        requestResponse = IsRequestValid(originalRequest, requestResponse);
        return requestResponse;
    }

    public RequestResponse IsRequestValid(ValidateFileRequest request, RequestResponse requestResponse)
    {
        requestResponse = FileValidation.ValidateSourceNotEmpty(request.FileSourceRequest.SourceFile, requestResponse);

        requestResponse = FileValidation.ValidateFilenameNotEmpty(request.FileSourceRequest.SourceFile, requestResponse);
        requestResponse = FileValidation.ValidateFilename(request.FileSourceRequest.SourceFile, requestResponse);

        return requestResponse;
    }
}