using MesaFabApproval.API.Services;
using MesaFabApproval.Shared.Models;
using MesaFabApproval.Shared.Services;

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.StaticFiles;

namespace MesaFabApproval.API.Controllers;

[ApiController]
[Authorize]
public class MRBController : ControllerBase {
    private readonly ILogger<MRBController> _logger;
    private readonly IMRBService _mrbService;
    private readonly IMonInWorkerClient _monInClient;

    public MRBController(ILogger<MRBController> logger, IMRBService mrbService, IMonInWorkerClient monInClient) {
        _logger = logger ?? throw new ArgumentNullException("ILogger not injected");
        _mrbService = mrbService ?? throw new ArgumentNullException("IMRBService not injected");
        _monInClient = monInClient ?? throw new ArgumentNullException("IMonInWorkerClient not injected");
    }

    [HttpPost]
    [Route("mrb/new")]
    public async Task<IActionResult> CreateNewMRB(MRB mrb) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to generate a new MRB");

            if (mrb is null) throw new ArgumentNullException("MRB cannot be null");

            await _mrbService.CreateNewMRB(mrb);

            return Ok();
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot create new MRB, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "CreateNewMRB";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpDelete]
    [Route("mrb/delete")]
    public async Task<IActionResult> DeleteMRB(int mrbNumber) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation($"Attempting to delete MRB# {mrbNumber}");

            if (mrbNumber <= 0) throw new ArgumentException($"{mrbNumber} is not a valid MRB number");

            await _mrbService.DeleteMRB(mrbNumber);

            return Ok();
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot delete MRB {mrbNumber}, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "DeleteMRB";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpGet]
    [Route("mrb/all")]
    public async Task<IActionResult> GetAllMRBs(bool bypassCache) {
        DateTime start = DateTime.Now;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to get all MRBs");

            IEnumerable<MRB> allMrbs = await _mrbService.GetAllMRBs(bypassCache);

            return Ok(allMrbs);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot get all MRBs, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "GetAllMRBs";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

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

    [HttpGet]
    [Route("mrb/numberIsValid")]
    public async Task<IActionResult> NumberIsValid(int number) {
        DateTime start = DateTime.Now;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation($"Attempting to determine if {number} is a valid MRB#");

            bool isValid = await _mrbService.MRBNumberIsValid(number);

            return Ok(isValid);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Unable to determine if {number} is a valid MRB#, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "IsValidMRBNumber";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

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

    [HttpGet]
    [Route("mrb/getById")]
    public async Task<IActionResult> GetMRBById(int id, bool bypassCache = false) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to get an MRB by Id");

            if (id <= 0) throw new ArgumentException("Invalid MRB number");

            MRB mrb = await _mrbService.GetMRBById(id, bypassCache);

            return Ok(mrb);
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot get MRB by Id, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "GetMRBbyId";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpGet]
    [Route("mrb/getByTitle")]
    public async Task<IActionResult> GetMRBByTitle(string title, bool bypassCache) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to get an MRB by Title");

            if (string.IsNullOrWhiteSpace(title)) throw new ArgumentException("Title cannot be null or empty");

            MRB mrb = await _mrbService.GetMRBByTitle(title, bypassCache);

            return Ok(mrb);
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot get MRB by title, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "GetMRBbyTitle";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpPut]
    [Route("mrb")]
    public async Task<IActionResult> UpdateMRB(MRB mrb) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to update an MRB");

            if (mrb is null) throw new ArgumentNullException("MRB cannot be null");

            await _mrbService.UpdateMRB(mrb);

            return Ok();
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot update MRB, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "UpdateMRB";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpPost]
    [Route("mrbAction")]
    public async Task<IActionResult> CreateMRBAction(MRBAction mrbAction) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to generate a new MRB");

            if (mrbAction is null) throw new ArgumentNullException("MRB action cannot be null");

            await _mrbService.CreateMRBAction(mrbAction);

            return Ok();
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot create new MRB action, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "CreateNewMRBAction";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpGet]
    [Route("mrbAction")]
    public async Task<IActionResult> GetMRBActionsForMRB(int mrbNumber, bool bypassCache) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to get all MRBs");

            if (mrbNumber <= 0) throw new ArgumentException($"{mrbNumber} is not a valid MRB number");

            IEnumerable<MRBAction> mrbActions = await _mrbService.GetMRBActionsForMRB(mrbNumber, bypassCache);

            return Ok(mrbActions);
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot get all MRBs, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "GetMRBActionsForMRB";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpPut]
    [Route("mrbAction")]
    public async Task<IActionResult> UpdateMRBAction(MRBAction mrbAction) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to update an MRB action");

            if (mrbAction is null) throw new ArgumentNullException("MRB action cannot be null");

            await _mrbService.UpdateMRBAction(mrbAction);

            return Ok();
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot update MRB action, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "UpdateMRBAction";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpDelete]
    [Route("mrbAction")]
    public async Task<IActionResult> DeleteMRBAction(int mrbActionID, int mrbNumber) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation($"Attempting to delete MRB action {mrbActionID}");

            if (mrbActionID <= 0) throw new ArgumentException($"{mrbActionID} is not a valid MRB ActionID");
            if (mrbNumber <= 0) throw new ArgumentException($"{mrbNumber} is not a valid MRBNumber");

            await _mrbService.DeleteMRBAction(mrbActionID, mrbNumber);

            return Ok();
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot delete MRB action, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "DeleteMRBAction";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpGet]
    [Route("mrb/attachments")]
    public async Task<IActionResult> GetAttachmentsForMRB(int mrbNumber, bool bypassCache) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation($"Attempting to get MRB attachments for MRB {mrbNumber}");

            if (mrbNumber <= 0) throw new ArgumentException($"{mrbNumber} is not a valid MRB number");

            List<MRBAttachment> attachments = (await _mrbService.GetAllAttachmentsForMRB(mrbNumber, bypassCache)).ToList();

            return Ok(attachments);
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot get attachments for MRB {mrbNumber}, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "GetMRBAttachments";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpGet]
    [Route("mrb/action/attachments")]
    public async Task<IActionResult> GetActionAttachmentsForMRB(int mrbNumber, bool bypassCache) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation($"Attempting to get action attachments for MRB {mrbNumber}");

            if (mrbNumber <= 0) throw new ArgumentException($"{mrbNumber} is not a valid MRB#");

            List<MRBActionAttachment> attachments = 
                (await _mrbService.GetAllActionAttachmentsForMRB(mrbNumber, bypassCache)).ToList();

            return Ok(attachments);
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot get action attachments for MRB# {mrbNumber}, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "GetMRBActionAttachments";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpPost]
    [Route("mrb/attach")]
    public async Task<IActionResult> SaveMRBAttachment([FromForm] IEnumerable<IFormFile> files, int mrbNumber) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to save MRB attachments");

            if (files is null) throw new ArgumentNullException("Files cannot be null");
            if (files.Count() <= 0) throw new ArgumentException("Files cannot be empty");
            if (mrbNumber <= 0) throw new ArgumentException($"{mrbNumber} is not a valid MRB number");

            IEnumerable<UploadResult> uploadResults = (await _mrbService.UploadAttachments(files, mrbNumber)).ToList();

            return Ok(uploadResults);
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot save MRB attachments, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "SaveMRBAttachments";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpPost]
    [Route("mrb/action/attach")]
    public async Task<IActionResult> SaveMRBActionAttachment([FromForm] IEnumerable<IFormFile> files, int actionId) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to save MRB action attachments");

            if (files is null) throw new ArgumentNullException("Files cannot be null");
            if (files.Count() <= 0) throw new ArgumentException("Files cannot be empty");
            if (actionId <= 0) throw new ArgumentException($"{actionId} is not a valid MRB action ID");

            IEnumerable<UploadResult> uploadResults = (await _mrbService.UploadActionAttachments(files, actionId)).ToList();

            return Ok(uploadResults);
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot save MRB action attachments, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "SaveMRBActionAttachments";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [AllowAnonymous]
    [HttpGet]
    [Route("mrb/attachmentFile")]
    public async Task<IActionResult> GetMRBAttachmentFile(string path, string fileName) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to get MRB attachment file");

            if (string.IsNullOrWhiteSpace(path)) throw new ArgumentException("Path cannot be null or empty");
            if (!System.IO.File.Exists(path)) throw new ArgumentException("No file exists at provided path");
            if (string.IsNullOrWhiteSpace(fileName)) throw new ArgumentException("Filename cannot be null or empty");

            byte[] fs = System.IO.File.ReadAllBytes(path);

            const string defaultContentType = "application/octet-stream";

            FileExtensionContentTypeProvider contentTypeProvider = new FileExtensionContentTypeProvider();

            if (!contentTypeProvider.TryGetContentType(path, out string? contentType)) {
                contentType = defaultContentType;
            }

            return new FileContentResult(fs, contentType) {
                FileDownloadName = fileName
            };
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot get MRB attachment file, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "GetMRBAttachmentFile";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpDelete]
    [Route("mrb/attach")]
    public async Task<IActionResult> DeleteMRBAttachment(MRBAttachment attachment) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to delete MRB attachment");

            if (attachment is null) throw new ArgumentNullException("Attachment cannot be null");

            await _mrbService.DeleteAttachment(attachment);

            return Ok();
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot get MRB attachment file, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "DeleteMRBAttachment";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpPost]
    [Route("mrb/notify/new-approvals")]
    public async Task<IActionResult> NotifyNewApprovals(MRB mrb) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to notify new approvers");

            if (mrb is null) throw new ArgumentNullException("MRB cannot be null");

            await _mrbService.NotifyNewApprovals(mrb);

            return Ok();
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Unable to notify new approvers, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "NotifyNewMRBApprovers";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpPost]
    [Route("mrb/notify/approvers")]
    public async Task<IActionResult> NotifyApprovers(MRBNotification notification) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to notify approvers");

            if (notification is null) throw new ArgumentNullException("notification cannot be null");
            if (notification.MRB is null) throw new ArgumentNullException("MRB cannot be null");
            if (string.IsNullOrWhiteSpace(notification.Message)) throw new ArgumentException("message cannot be null or empty");

            await _mrbService.NotifyApprovers(notification);

            return Ok();
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Unable to notify approvers, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "NotifyMRBApprovers";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpPost]
    [Route("mrb/notify/originator")]
    public async Task<IActionResult> NotifyOriginator(MRBNotification notification) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to notify originator");

            if (notification is null) throw new ArgumentNullException("MRBNotification cannot be null");
            if (notification.MRB is null) throw new ArgumentNullException("MRB cannot be null");
            if (string.IsNullOrWhiteSpace(notification.Message)) throw new ArgumentException("Message cannot be null or empty");

            await _mrbService.NotifyOriginator(notification);

            return Ok();
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Unable to notify originator, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "NotifyMRBOriginator";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpPost]
    [Route("mrb/notify/qa-pre-approver")]
    public async Task<IActionResult> NotifyQAPreApprover(MRBNotification notification) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to notify QA pre approver");

            if (notification is null) throw new ArgumentNullException("MRBNotification cannot be null");
            if (notification.MRB is null) throw new ArgumentNullException("MRB cannot be null");
            if (string.IsNullOrWhiteSpace(notification.Message)) throw new ArgumentException("Message cannot be null or empty");

            await _mrbService.NotifyQAPreApprover(notification);

            return Ok();
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Unable to notify QA pre approver, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "NotifyQAPreApprover";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }
}