using LCU.Api.Internal.Dispatcher.Services.QueueServices;
using LCU.Api.Internal.MaidBotLib.Models;
using LCU.Library.Internal.DispatcherModels.Entities;
using LCU.Library.Internal.DispatcherModels.Enums;
using LCU.Library.Internal.DispatcherModels.Models;
using LCU.Library.Internal.DispatcherModels.Models.Requests;
using LCU.Library.Internal.DocumentIngestorModels.Models.IndexFileDocuments;
using LCU.Library.Internal.Exceptions;
using System;
using System.Collections.Generic;

namespace LCU.Api.Internal.Dispatcher.Services.DispatcherOperationServices
{
    public class JobFailureService : IJobFailureService
	{
        private readonly IWorkItemService _workItemService;
        private readonly IWorkItemExecutionService _workItemExecutionService;
        private readonly IJobService _jobService;
        private readonly IExecutionMessageService _executionMessageService;
        private readonly IQueueDetermineOperationService _queueDetermineOperationService;
        private readonly IQueueSendErroredJobAlertService _queueSendErroredJobAlertService;

        public JobFailureService(IWorkItemService workItemService, 
                                    IWorkItemExecutionService workItemExecutionService, 
                                    IJobService jobService, 
                                    IExecutionMessageService executionMessageService,
                                    IQueueDetermineOperationService queueDetermineOperationService,
                                    IQueueSendErroredJobAlertService queueSendErroredJobAlertService)
        {
            _workItemService = workItemService;
            _workItemExecutionService = workItemExecutionService;
            _jobService = jobService;
            _executionMessageService = executionMessageService;
            _queueDetermineOperationService = queueDetermineOperationService;
            _queueSendErroredJobAlertService = queueSendErroredJobAlertService;
        }

        public async Task HandleJobFailureRequest(JobFailureRequest jobFailureRequest)
		{
            try
            {
                var workItem = await _workItemService.GetByIdAsync(jobFailureRequest.WorkItemId);

                var updatedWorkItemExecution = await _workItemExecutionService.UpdateFailedWorkItemExecution(workItem.CurrentWorkItemExecution);

                if (workItem.CancelJobOnFailure)
                {
                    workItem = await _workItemService.IncreaseCanceledJobCounter(workItem);
                }

                var job = await _jobService.GetByWorkItemIdExcludingWorkItemsIncludeErrorRecipientsAsync(jobFailureRequest.WorkItemId);

                if (workItem.RequiresJobCancellation)
                {
                    var message = $"This Job will be canceled and if scheduleable, rescheduled. The " +
                              $"WorkItem's canceled Job counter is currently at {workItem.CanceledJobCounter} and has " +
                              $"not yet went over the cancel Job limit of {workItem.CancelJobLimit}.";
                    jobFailureRequest.ExecutionMessages.Add(message);
                    job.JobStatus = JobStatus.DeterminingOperation;
                }
                else
                {
                    job.JobStatus = JobStatus.Failed;
                }

                await _executionMessageService.SaveExecutionMessages(workItem.CurrentWorkItemExecution.WorkItemExecutionId, jobFailureRequest.ExecutionMessages);
                var updatedJob = await _jobService.UpdateAsync(job);

                if (updatedJob.JobStatus == JobStatus.DeterminingOperation)
                {
                    await _queueDetermineOperationService.QueueDetermineOperation(updatedJob, workItem, DetermineOperationType.Failed);
                }
                else
                {
                    await _queueSendErroredJobAlertService.QueueSendErroredJobAlert(job, workItem);
                }
            }
            catch (ServiceException serviceException)
            {
                Log.Error(serviceException, $"Dispatcher Job Failure Request Failure. " +
                                            $"The Dispatcher Job Failure Request is placed on LCU.Dispatcher.JobFailure_error.");
                throw new ServiceException($"Failed to handle JobFailureRequest.");
            }
            catch(Exception exception)
            {
                Log.Error(exception, $"Failed to handle JobFailureRequest.");
                throw new ServiceException($"Failed to handle JobFailureRequest.");
            }
		}
	}
}