using DigitalData.Core.DTO;
using EnvelopeGenerator.Application.Contracts.Services;
using EnvelopeGenerator.Application.EnvelopeReceivers.Commands.Create;
using EnvelopeGenerator.Application.EnvelopeReceivers.Queries.Read;
using MediatR;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace EnvelopeGenerator.GeneratorAPI.Controllers;

/// <summary>
/// Controller für die Verwaltung von Umschlagempfängern.
/// </summary>
/// <remarks>
/// Dieser Controller bietet Endpunkte für das Abrufen und Verwalten von Umschlagempfängerdaten.
/// </remarks>
[Route("api/[controller]")]
[Authorize]
[ApiController]
public class EnvelopeReceiverController : ControllerBase
{
    private readonly ILogger<EnvelopeReceiverController> _logger;

    private readonly IEnvelopeReceiverService _erService;

    private readonly IMediator _mediator;

    /// <summary>
    /// Konstruktor für den EnvelopeReceiverController.
    /// </summary>
    /// <param name="logger">Logger-Instanz zur Protokollierung von Informationen und Fehlern.</param>
    /// <param name="envelopeReceiverService">Service zur Verwaltung von Umschlagempfängern.</param>
    /// <param name="mediator">Mediator-Instanz zur Verarbeitung von Befehlen und Abfragen.</param>
    public EnvelopeReceiverController(ILogger<EnvelopeReceiverController> logger, IEnvelopeReceiverService envelopeReceiverService, IMediator mediator)
    {
        _logger = logger;
        _erService = envelopeReceiverService;
        _mediator = mediator;
    }

    /// <summary>
    /// Ruft eine Liste von Umschlagempfängern basierend auf den angegebenen Abfrageparametern ab.
    /// </summary>
    /// <param name="envelopeReceiver">Die Abfrageparameter, die den Status und andere Filterkriterien enthalten.</param>
    /// <returns>Eine HTTP-Antwort mit der Liste der gefundenen Umschlagempfänger oder einem Fehlerstatus.</returns>
    /// <remarks>
    /// Dieser Endpunkt ermöglicht es, Umschlagempfänger basierend auf dem Benutzernamen und optionalen Statusfiltern abzurufen.
    /// Wenn der Benutzername nicht ermittelt werden kann, wird ein Serverfehler zurückgegeben.
    /// </remarks>
    /// <response code="200">Die Liste der Umschlagempfänger wurde erfolgreich abgerufen.</response>
    /// <response code="500">Ein unerwarteter Fehler ist aufgetreten.</response>
    [HttpGet]
    public async Task<IActionResult> GetEnvelopeReceiver([FromQuery] ReadEnvelopeReceiverQuery envelopeReceiver)
    {
        try
        {
            var username = User.GetUsername();

            if (username is null)
            {
                _logger.LogError(@"Envelope Receiver dto cannot be sent because username claim is null. Potential authentication and authorization error. The value of other claims are [id: {id}], [username: {username}], [name: {name}], [prename: {prename}], [email: {email}].",
                    User.GetId(), User.GetUsername(), User.GetName(), User.GetPrename(), User.GetEmail());
                return StatusCode(StatusCodes.Status500InternalServerError);
            }

            return await _erService.ReadByUsernameAsync(username: username, min_status: envelopeReceiver.Status.Min, max_status: envelopeReceiver.Status.Min, ignore_statuses: envelopeReceiver.Status.Ignore ?? Array.Empty<int>()).ThenAsync(
                    Success: Ok,
                    Fail: IActionResult (msg, ntc) =>
                    {
                        _logger.LogNotice(ntc);
                        return StatusCode(StatusCodes.Status500InternalServerError, msg);
                    });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "An unexpected error occurred. {message}", ex.Message);
            return new StatusCodeResult(StatusCodes.Status500InternalServerError);
        }
    }

    /// <summary>
    /// Ruft den Namen des letzten verwendeten Empfängers basierend auf der angegebenen E-Mail-Adresse ab.
    /// </summary>
    /// <param name="mail">Die E-Mail-Adresse des Empfängers.</param>
    /// <returns>Eine HTTP-Antwort mit dem Namen des Empfängers oder einem Fehlerstatus.</returns>
    /// <remarks>
    /// Dieser Endpunkt ermöglicht es, den Namen des letzten Empfängers abzurufen, der mit der angegebenen E-Mail-Adresse verknüpft ist.
    /// Wenn kein Empfänger gefunden wird, wird ein leerer String zurückgegeben.
    /// </remarks>
    /// <response code="200">Der Name des Empfängers wurde erfolgreich abgerufen.</response>
    /// <response code="404">Kein Empfänger mit der angegebenen E-Mail-Adresse gefunden.</response>
    /// <response code="500">Ein unerwarteter Fehler ist aufgetreten.</response>
    [HttpGet("receiver-name/{mail}")]
    public async Task<IActionResult> GetReceiverName([FromRoute] string mail)
    {
        try
        {
            return await _erService.ReadLastUsedReceiverNameByMail(mail).ThenAsync(
                            Success: res => res is null ? Ok(string.Empty) : Ok(res),
                            Fail: IActionResult (msg, ntc) =>
                            {
                                if (ntc.HasFlag(Flag.NotFound))
                                    return NotFound();

                                _logger.LogNotice(ntc);
                                return StatusCode(StatusCodes.Status500InternalServerError);
                            });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "{message}", ex.Message);
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
    }

    /// <summary>
    /// Ruft geheime Informationen basierend auf der angegebenen UUID ab.
    /// </summary>
    /// <param name="uuid">Die eindeutige Kennung (UUID), die verwendet wird, um die geheimen Informationen abzurufen.</param>
    /// <returns>Eine HTTP-Antwort mit den geheimen Informationen oder einem Fehlerstatus.</returns>
    /// <remarks>
    /// Dieser Endpunkt ermöglicht es, geheime Informationen zu einem Umschlagempfänger basierend auf der UUID abzurufen.
    /// Wenn keine Informationen gefunden werden, wird ein entsprechender Fehlerstatus zurückgegeben.
    /// </remarks>
    /// <response code="200">Die geheimen Informationen wurden erfolgreich abgerufen.</response>
    /// <response code="500">Ein unerwarteter Fehler ist aufgetreten.</response>
    [HttpGet("secret")]
    [Authorize]
    public async Task<IActionResult> GetSecretAsync([FromQuery] string uuid)
    {
        try
        {
            return await _erService.ReadWithSecretByUuidAsync(uuid: uuid).ThenAsync(
                Success: Ok,
                Fail: IActionResult (msg, ntc) =>
                {
                    _logger.LogNotice(ntc);
                    return StatusCode(StatusCodes.Status500InternalServerError);
                });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "{message}", ex.Message);
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
    }

    /// <summary>
    /// Datenübertragungsobjekt mit Informationen zu Umschlägen, Empfängern und Unterschriften.
    /// </summary>
    /// <param name="createEnvelopeQuery"></param>
    /// <param name="cancellationToken">Token to cancel the operation</param>
    /// <returns>HTTP-Antwort</returns>
    /// <remarks>
    /// Sample request:
    ///
    ///     POST /api/envelope
    ///     {
    ///        "title": "Vertragsdokument",
    ///        "message": "Bitte unterschreiben Sie dieses Dokument.",
    ///        "document": {
    ///            "dataAsBase64": "dGVzdC1iYXNlNjQtZGF0YQ=="  
    ///        },
    ///        "receivers": [
    ///            {
    ///                "emailAddress": "example@example.com",
    ///                "signatures": [
    ///                    {
    ///                        "x": 100,
    ///                        "y": 200,
    ///                        "page": 1
    ///                    }
    ///                ],
    ///                "name": "Max Mustermann",
    ///                "phoneNumber": "+49123456789"
    ///            }
    ///        ],
    ///        "tfaEnabled": false
    ///     }
    ///
    /// </remarks>
    /// <response code="202">Envelope-Erstellung und Sendeprozessbefehl erfolgreich</response>
    /// <response code="400">Wenn ein Fehler im HTTP-Body auftritt</response>
    /// <response code="401">Wenn kein autorisierter Token vorhanden ist</response>
    /// <response code="500">Es handelt sich um einen unerwarteten Fehler. Die Protokolle sollten überprüft werden.</response>
    [Authorize]
    [HttpPost]
    public async Task<IActionResult> CreateAsync([FromBody] CreateEnvelopeReceiverCommand createEnvelopeQuery, CancellationToken cancellationToken)
    {
        await _mediator.Send(createEnvelopeQuery, cancellationToken);
        return Accepted();
    }
}