using FabApprovalWorkerService.Models;
using FabApprovalWorkerService.Services;

using Quartz;

using System.Text;

namespace FabApprovalWorkerService.Workers;

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

    public ExpiredOOOStatusWorker(ILogger<ExpiredOOOStatusWorker> 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 = "ExpiredOOOStatusWorker";

        try {
            _logger.LogInformation("Attempting to remove OOO status for users with OOO expired earlier than now");

            List<User> expiredOOOUsers = await _userService.GetAllExpiredOOOUsersAsync();
            
            foreach (User user in expiredOOOUsers) {
                bool approvalsRemoved = await _userService.RemoveDelegatedApprovalsForUser(user.UserID, user.DelegatedTo);
                bool subRolesRemoved = await _userService.RemoveDelegatedUserSubRoles(user.UserID, user.DelegatedTo);
                bool rolesRemoved = await _userService.RemoveDelegatedRoles(user.UserID);
                bool oooFlagRemoved = await _userService.RemoveOOOFlagForUser(user.UserID);

                if (approvalsRemoved && subRolesRemoved && rolesRemoved && oooFlagRemoved) {
                    _logger.LogInformation("Successfully removed OOO status for users {id}", user.UserID);
                } else {
                    StringBuilder errMsgBuilder = new();
                    errMsgBuilder.Append($"An error occurred when attempting to remove OOO status for user {user.UserID}. ");
                    errMsgBuilder.Append($"Approvals removed: {approvalsRemoved}, ");
                    errMsgBuilder.Append($"sub roles removed: {subRolesRemoved}, ");
                    errMsgBuilder.Append($"roles removed: {rolesRemoved}, ");
                    errMsgBuilder.Append($"OOO flag removed: {oooFlagRemoved}");
                    throw new Exception(errMsgBuilder.ToString());
                }
            } 
        } catch (Exception ex) {
            StringBuilder errMsgBuilder = new();
            errMsgBuilder.Append("An exception occurred when attempting to remove OOO status for users with OOO expired ");
            errMsgBuilder.Append($"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);
            }
        }
    }
}