using LCU.Api.Internal.Dispatcher.Services.QueueServices;
using LCU.Library.Internal.DispatcherModels.Enums;
using LCU.Library.Internal.LcuHttpClient.HttpRequest;
using System.Collections.Generic;
namespace LCU.Api.Internal.Dispatcher.Services.DispatcherOperationServices;
public class ExecutionService : IExecutionService
{
    private readonly IPostRequest _postRequest;
    private readonly IWorkItemService _workItemService;
    private readonly IJobService _jobService;
    private readonly IQueueCompletionService _queueCompletionService;

	private const string HttRequestIsNullMessage = "Http Request is null";

	public ExecutionService(IPostRequest postRequest,
							IWorkItemService workItemService,

							IJobService jobService,
                            IQueueCompletionService queueCompletionService)
	{
        _postRequest = postRequest;
		_workItemService = workItemService;
		_jobService = jobService;
        _queueCompletionService = queueCompletionService;
	}

	public async Task HandleExecutionRequest(WorkItemExecution request)
    {
        try
        {
            var executionResponse = await ExecuteRequest(request);
            if (!executionResponse.IsSuccess)
            {
                await _queueCompletionService.QueueCompletion(new DispatcherReturnResponse() { WorkItemId = executionResponse.WorkItemExecution.WorkItemId },
                                                                    executionResponse.Messages, executionResponse.IsSuccess);
            }
        }
        catch (Exception exception)
        {
            Log.Error(exception, $"Failed to perform execution. WorkItemId: {request.WorkItemId}");
            throw new ServiceException($"Failed to perform execution. WorkItemId: {request.WorkItemId}");
        }
    }

    public async Task<ExecutionResponse> ExecuteRequest(WorkItemExecution request)
    {
        try
        {
            ArgumentNullException.ThrowIfNull(request);

            var requestedWorkItem = await _workItemService.GetByIdAsync(request.WorkItemId);

            await UpdateJobStatusToProcessing(requestedWorkItem);

            var result = await _postRequest.AsyncWithNewtonSerializedNoThrow(new Uri(requestedWorkItem.Url), requestedWorkItem.SerializedPayload);
            if (!result.IsSuccessStatusCode)
            {
                var content = await result.Content.ReadAsStringAsync();
                return new ExecutionResponse(false, request, content);
            }
            return new ExecutionResponse(true, request);
        }
        catch (Exception ex)
        {
            var errorMessage = $"Exception during ExecuteRequest. Exception Message: {ex.Message}. Inner Exception: {ex.InnerException}";
            Log.Error(errorMessage);
            return new ExecutionResponse(false, request, errorMessage);
        }
    }

    private async Task UpdateJobStatusToProcessing(WorkItem requestedWorkItem)
	{
		var job = await _jobService.GetByWorkItemIdExcludingWorkItemsAsync(requestedWorkItem.WorkItemId);
        if (job.JobStatus == JobStatus.Processing)
        {
            return;
        }
		job.JobStatus = JobStatus.Processing;
		await _jobService.UpdateAsync(job);
		Log.Information("Job Id {JobId} was saved with status {Status}", job.JobId, job.JobStatus);
	}

	public struct ExecutionResponse
    {
        public ExecutionResponse(bool isSuccess, WorkItemExecution workItemExecution, string messages = null)
        {
            IsSuccess = isSuccess;
            WorkItemExecution = workItemExecution;
            Messages = messages != null ? new List<string>() { messages } : null;
        }

        public bool IsSuccess { get; set; }
        public List<string> Messages { get; set; }
        public WorkItemExecution WorkItemExecution { get; set; }
    }
}