using FabApprovalWorkerService.Models;
using FabApprovalWorkerService.Services;

using Infineon.Monitoring.MonA;

using Quartz;

using System.Text;

namespace FabApprovalWorkerService.Workers;

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

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

        _monInClient = monInClient;
        if (_monInClient is null) {
            throw new ArgumentNullException("IMonInClient 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();

            _logger.LogInformation($"There are {pendingOOOUsers.Count()} pending OOO users");
            
            foreach (OOOTemp oooTemp in pendingOOOUsers) {
                bool userAlreadyOOO = await _userService.IsUserAlreadyOOO(oooTemp.OOOUserID);
                bool delegateAlreadyADelegate = await _userService.IsDelegatorAlreadyDelegatedTo(oooTemp.DelegatedTo);

                if (!userAlreadyOOO && !delegateAlreadyADelegate) {
                    await _userService.InsertDelegatedRoles(oooTemp.OOOUserID);
                    await _userService.DelegateUserSubRoles(oooTemp.OOOUserID, oooTemp.DelegatedTo);
                    await _userService.DelegateApprovalsForUser(oooTemp.OOOUserID, oooTemp.DelegatedTo);

                    bool userIsNowOOO = await _userService.FlagUserAsOOO(oooTemp);
                    if (userIsNowOOO) {
                        oooTemp.Processed = true;
                        await _userService.SetOOOTempProcessed(oooTemp);
                    }
                } else if (userAlreadyOOO) {
                    _logger.LogInformation($"User {oooTemp.OOOUserID} is already OOO");
                } else if (delegateAlreadyADelegate) {
                    _logger.LogInformation($"Delegate {oooTemp.DelegatedTo} is already a delegate");
                }
            }

            _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.PostMetric(metricName + "Latency", latencyInMS);

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