using Grpc.Core;
using Grpc.Core.Interceptors;
using Microsoft.Extensions.Logging;
using System.Text.Json;
using System.Threading.Tasks;

namespace server.Utilierias
{

    /// <summary>
    /// Interceptor de gRPC encargado de registrar (loggear) automáticamente todas las llamadas entrantes y salientes.
    /// </summary>
    public class LoggingInterceptor : Interceptor
    {
        private readonly ILogger<LoggingInterceptor> _logger;

        /// <summary>
        /// Inicializa una nueva instancia de la clase <see cref="LoggingInterceptor"/>.
        /// </summary>
        /// <param name="logger">El servicio de registro de eventos inyectado por DI.</param>
        public LoggingInterceptor(ILogger<LoggingInterceptor> logger)
        {
            _logger = logger;
        }

        /// <summary>
        /// Intercepta llamadas gRPC unarias (de un solo mensaje de ida y vuelta).
        /// </summary>
        /// <remarks>
        /// Lógica de ejecución: Serializa el objeto <paramref name="request"/> entrante a formato JSON y lo registra en los logs junto con el nombre del método gRPC invocado. Luego, delega el control al siguiente paso en el pipeline mediante <paramref name="continuation"/>. Una vez que el método real termina de procesarse, registra un mensaje confirmando que la respuesta ha sido enviada.
        /// </remarks>
        /// <param name="request">El mensaje de petición recibido del cliente.</param>
        /// <param name="context">El contexto de la llamada del servidor (headers, metadatos, estado).</param>
        /// <param name="continuation">El delegado que invoca el siguiente interceptor o el manejador real del servicio.</param>
        /// <returns>La respuesta generada por el manejador del servicio, que será devuelta al cliente.</returns>
        public override async Task<TResponse> UnaryServerHandler<TRequest, TResponse>(
            TRequest request,
            ServerCallContext context,
            UnaryServerMethod<TRequest, TResponse> continuation)
        {
            // Log del método y los parámetros del request en formato JSON
            var requestJson = JsonSerializer.Serialize(request);
            _logger.LogInformation("Received request for {Method} \nParameters:\n{Request}", context.Method, requestJson);

            // Continuación del manejo del request
            var response = await continuation(request, context);

            // Log después de enviar la respuesta
            _logger.LogInformation("Sent response for {Method}", context.Method);

            return response;
        }
    }
    
}