using FabApprovalWorkerService.Models;
using FabApprovalWorkerService.Services;

using Quartz;

using System.Text;

namespace FabApprovalWorkerService.Workers;

public sealed class PendingOOOStatusWorker : IJob {
    private readonly ILogger<PendingOOOStatusWorker> _logger;
    private readonly IMonInWorkerClient _monInClient;
    private readonly IUserService _userService;

    public PendingOOOStatusWorker(ILogger<PendingOOOStatusWorker> logger,
                                  IMonInWorkerClient monInClient,
                                  IUserService userService) {
        _logger = logger;
        if (_logger is null)
            throw new ArgumentNullException("ILogger not injected");

        _monInClient = monInClient;
        if (_monInClient is null) {
            throw new ArgumentNullException("IMonInWorkerClient not injected");
        }

        _userService = userService;
        if (_userService is null)
            throw new ArgumentNullException("IUserService not injected");
    }

    public async Task Execute(IJobExecutionContext context) {
        DateTime start = DateTime.Now;
        bool isInternalError = false;
        StringBuilder errorMessage = new();
        string metricName = "PendingOOOStatusWorker";

        try {
            _logger.LogInformation("Attempting to set OOO status for users pending earlier than now");

            List<OOOTemp> pendingOOOUsers = await _userService.GetAllPendingOOOUsersAsync();
            
            foreach (OOOTemp oooTemp in pendingOOOUsers) {
                Task<bool> userAlreadyOOO = _userService.IsUserAlreadyOOO(oooTemp.OOOUserID);
                Task<bool> delegateAlreadyADelegate = _userService.IsDelegatorAlreadyDelegatedTo(oooTemp.DelegatedTo);

                if (!userAlreadyOOO.Result && !delegateAlreadyADelegate.Result) {
                    List<Task> enableOOOTasks = new();
                    enableOOOTasks.Add(_userService.InsertDelegatedRoles(oooTemp.OOOUserID));
                    enableOOOTasks.Add(_userService.DelegateUserSubRoles(oooTemp.OOOUserID, oooTemp.DelegatedTo));
                    enableOOOTasks.Add(_userService.DelegateApprovalsForUser(oooTemp.OOOUserID, oooTemp.DelegatedTo));
                    Task enableOOOTasksResult = Task.WhenAll(enableOOOTasks);

                    if (enableOOOTasksResult.IsCompletedSuccessfully) {
                        bool userIsNowOOO = await _userService.FlagUserAsOOO(oooTemp);
                        if (userIsNowOOO) {
                            oooTemp.Processed = true;
                            await _userService.SetOOOTempProcessed(oooTemp);
                        }
                    }
                }
            }

            _logger.LogInformation("Successfully set OOO status for users pending earlier than now");
        } catch (Exception ex) {
            StringBuilder errMsgBuilder = new();
            errMsgBuilder.Append("An exception occurred when attempting to set OOO status for users ");
            errMsgBuilder.Append($"pending earlier than now. Exception: {ex.Message}");
            _logger.LogError(errMsgBuilder.ToString());
            isInternalError = true;
        } finally {
            DateTime end = DateTime.Now;
            double latencyInMS = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", latencyInMS);

            if (isInternalError) {
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }
}