using AutoMapper;
using DigitalData.Core.DTO;
using EnvelopeGenerator.Application.Contracts.Services;
using EnvelopeGenerator.Application.Contracts.SQLExecutor;
using EnvelopeGenerator.Application.DTOs.Receiver;
using EnvelopeGenerator.Application.EnvelopeReceivers.Commands.Create;
using EnvelopeGenerator.Application.EnvelopeReceivers.Queries.Read;
using EnvelopeGenerator.Application.Envelopes.Queries.ReceiverName;
using EnvelopeGenerator.Domain.Entities;
using MediatR;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Channels;

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;

    private readonly IMapper _mapper;

    private readonly IEnvelopeExecutor _envelopeExecutor;

    private readonly IEnvelopeReceiverExecutor _erExecutor;

    /// <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>
    /// <param name="mapper"></param>
    /// <param name="envelopeExecutor"></param>
    /// <param name="erExecutor"></param>
    public EnvelopeReceiverController(ILogger<EnvelopeReceiverController> logger, IEnvelopeReceiverService envelopeReceiverService, IMediator mediator, IMapper mapper, IEnvelopeExecutor envelopeExecutor, IEnvelopeReceiverExecutor erExecutor)
    {
        _logger = logger;
        _erService = envelopeReceiverService;
        _mediator = mediator;
        _mapper = mapper;
        _envelopeExecutor = envelopeExecutor;
        _erExecutor = erExecutor;
    }

    /// <summary>
    /// Ruft eine Liste von Umschlagempfängern basierend auf den angegebenen Abfrageparametern ab.
    /// </summary>
    /// <param name="envelopeReceiver">Die Abfrageparameter für die Filterung von Umschlagempfängern.</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="401">Wenn kein autorisierter Token vorhanden ist</response>
    /// <response code="500">Ein unerwarteter Fehler ist aufgetreten.</response>
    [Authorize]
    [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 ?? envelopeReceiver.Envelope?.Status,
                max_status:envelopeReceiver.Status?.Max ?? envelopeReceiver.Envelope?.Status,
                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 zuletzt verwendeten Empfängers basierend auf der angegebenen E-Mail-Adresse ab.
    /// </summary>
    /// <param name="receiverName">Die Abfrage, die die E-Mail-Adresse des Empfängers enthält.</param>
    /// <returns>Eine HTTP-Antwort mit dem Namen des Empfängers oder einem Fehlerstatus.</returns>
    /// <remarks>
    /// Dieser Endpunkt ermöglicht es, den Namen des zuletzt verwendeten Empfängers basierend auf der E-Mail-Adresse abzurufen.
    /// </remarks>
    /// <response code="200">Der Name des Empfängers wurde erfolgreich abgerufen.</response>
    /// <response code="401">Wenn kein autorisierter Token vorhanden ist</response>
    /// <response code="404">Kein Empfänger gefunden.</response>
    /// <response code="500">Ein unerwarteter Fehler ist aufgetreten.</response>
    [Authorize]
    [HttpGet("salute")]
    public async Task<IActionResult> GetReceiverName([FromQuery] ReadReceiverNameQuery receiverName)
    {
        try
        {
            return await _erService.ReadLastUsedReceiverNameByMail(receiverName.EmailAddress).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>
    /// Datenübertragungsobjekt mit Informationen zu Umschlägen, Empfängern und Unterschriften.
    /// </summary>
    /// <param name="request"></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 request)
    {
        try
        {
            CancellationToken cancel = default;
            int userId = User.GetId();

            var envelope = await _envelopeExecutor.CreateEnvelopeAsync(userId, request.Title, request.Message, request.TFAEnabled, cancel);

            List<EnvelopeReceiver> sentRecipients = new();
            List<ReceiverGetOrCreateCommand> unsentRecipients = new();

            foreach (var receiver in request.Receivers)
            {
                var envelopeReceiver = await _erExecutor.AddEnvelopeReceiverAsync(envelope.Uuid, receiver.EmailAddress, receiver.Salution, receiver.PhoneNumber, cancel);

                if (envelopeReceiver is null)
                    unsentRecipients.Add(receiver);
                else
                    sentRecipients.Add(envelopeReceiver);
            }

            var res = _mapper.Map<CreateEnvelopeReceiverResponse>(envelope);
            res.UnsentRecipients = unsentRecipients;
            res.SentRecipients = _mapper.Map<IEnumerable<ReceiverReadDto>>(sentRecipients);

            return Ok(res);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "{Message}", ex.Message);
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
    }
}