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.Requests;

namespace LCU.Api.Internal.Dispatcher.Services.DispatcherOperationServices
{
    public class DetermineOperationService : IDetermineOperationService
	{
        private readonly IJobService _jobService;
        private readonly IWorkItemService _workItemService;
        private readonly IWorkItemExecutionService _workItemExecutionService;
        private readonly IQueueExecutionService _queueExecutionService;

        public DetermineOperationService(IJobService jobService, 
                                            IWorkItemService workItemService, 
                                            IWorkItemExecutionService workItemExecutionService, 
                                            IQueueExecutionService queueExecutionService)
        {
            _jobService = jobService;
            _workItemService = workItemService;
            _workItemExecutionService = workItemExecutionService;
            _queueExecutionService = queueExecutionService;
        }

        public async Task HandleDetermineOperationRequest(DetermineOperationRequest determineOperationRequest)
		{
			try
			{
                switch (determineOperationRequest.DetermineOperationType)
                {
                    case DetermineOperationType.Failed:
                        await HandleFailedWorkItem(determineOperationRequest);
                        break;
                    case DetermineOperationType.Skipped:
                        await HandleWorkItemCompletion(determineOperationRequest, StatusType.Skipped);
                        break;
                    case DetermineOperationType.Completed:
                        await HandleWorkItemCompletion(determineOperationRequest, StatusType.Completed);
                        break;
                    default:
                        throw new NotImplementedException();
                }
                return;
            }
            catch (ServiceException serviceException)
            {
                Log.Error(serviceException, $"Dispatcher Determine Operation Failure. " +
                                            $"The Dispatcher Determine Operation is placed on LCU.Dispatcher.DetermineOperation_error.");
                throw new ServiceException($"Failed to handle DetermineOperationRequest.");
            }
            catch (Exception exception)
            {
                Log.Error(exception, $"Failed to handle DetermineOperationRequest.");
                throw new ServiceException($"Failed to handle DetermineOperationRequest.");
            }
		}

        public async Task HandleFailedWorkItem(DetermineOperationRequest determineOperationRequest)
        {
            await _jobService.CompleteJobAndWorkItem(determineOperationRequest.CurrentJob, determineOperationRequest.CurrentWorkItem.CurrentWorkItemExecution, StatusType.Failed);
        }

        public async Task HandleWorkItemCompletion(DetermineOperationRequest determineOperationRequest, StatusType status)
        {
            var nextWorkItem = await _workItemService.GetNextWorkItemByJobId(determineOperationRequest.CurrentJob.JobId, determineOperationRequest.CurrentWorkItem.Order);
            if (nextWorkItem == null)
            {
                await _jobService.CompleteJobAndWorkItem(determineOperationRequest.CurrentJob, determineOperationRequest.CurrentWorkItem.CurrentWorkItemExecution, status);
                return;
            }

            await _jobService.CompleteWorkItemAndContinueProcessingJob(determineOperationRequest.CurrentJob,
                                                                        determineOperationRequest.CurrentWorkItem.CurrentWorkItemExecution,
                                                                        status);
            var newWorkItemExecution = await _workItemExecutionService.CreateWorkItemExecution(nextWorkItem.WorkItemId);

            await _queueExecutionService.QueueExecution(newWorkItemExecution);
        }
    }
}