using FastEndpoints;
using FrameworkBLL.MessageHub.MessageHubGenerator;
using FrameworkDAL.DTO.MessageHub.MessageHubGenerator;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.DTO.Framework.ResponseStandard;
using GB5Shared.FastEndPoint;
using Microsoft.Extensions.Logging;
using System;
using System.Diagnostics;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using static GB5Shared.GB5Constant.Constant;

namespace FrameworkSL.Endpoints.MessageHubGenerator
{
    public class GenerateMessageHubEndpoint
        : BaseEndpoint<GenerateMessageHubEndpoint.GenerateMessageHubRequest, ResponseStandardDTO<object>>
    {
        private readonly IMessageHubGeneratorBLL _messageHubGeneratorBLL;
        private readonly ILogger<GenerateMessageHubEndpoint> _logger;

        public GenerateMessageHubEndpoint(
            IMessageHubGeneratorBLL messageHubGeneratorBLL,
            ILogger<GenerateMessageHubEndpoint> logger)
        {
            _messageHubGeneratorBLL = messageHubGeneratorBLL ?? throw new ArgumentNullException(nameof(messageHubGeneratorBLL));
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        }

        public override void Configure()
        {
            Post("/MessageHubGenerator/Generate");
            AllowAnonymous();
        }

        public record GenerateMessageHubRequest(
            [property: FromHeader] string Login,
            [property: FromBody] int EntityId
        );

        protected override async Task<ResponseStandardDTO<object>> ExecuteAsync(
            GenerateMessageHubRequest req,
            LoginDTO loginDTO,
            CancellationToken ct)
        {
            _logger.LogInformation("[Request] Received GenerateMessageHub | EntityId={EntityId} | Login={Login}", req.EntityId, req.Login);

            if (req.EntityId == 0)
            {
                _logger.LogWarning("[Validation] EntityId cannot be 0");
                return await GB5Shared.ResponseStandard.Response.CreateSuccessResponse(
                    new { Success = false, ErrorMessage = "EntityId cannot be 0" },
                    CacheKeyLevel.NOT_REQUIRED,
                    loginDTO);
            }

            if (string.IsNullOrWhiteSpace(req.Login) || loginDTO == null)
            {
                _logger.LogWarning("[Validation] Login header or LoginDTO is null");
                return await GB5Shared.ResponseStandard.Response.CreateSuccessResponse(
                    new { Success = false, ErrorMessage = "Login information is required" },
                    CacheKeyLevel.NOT_REQUIRED,
                    loginDTO);
            }

            var sw = Stopwatch.StartNew();

            try
            {
                _logger.LogInformation("[Step 1] Starting MessageHub generation for EntityId={EntityId}", req.EntityId);

                _logger.LogDebug("[BLL] Calling MessageHubGeneratorBLL.GenerateAsync | EntityId={EntityId}", req.EntityId);
                var result = await _messageHubGeneratorBLL.GenerateAsync(req.EntityId, loginDTO, ct);

                sw.Stop();
                _logger.LogInformation("[Step 2] MessageHub generation completed | Duration={Duration}ms", sw.ElapsedMilliseconds);

                // --------------------------
                // Detailed logging
                // --------------------------
                void LogJsonDebug(string name, object obj)
                {
                    if (obj != null)
                    {
                        try
                        {
                            var json = JsonSerializer.Serialize(obj, new JsonSerializerOptions { WriteIndented = true });
                            _logger.LogDebug("[Result] {Name}: {Json}", name, json);
                        }
                        catch (Exception ex)
                        {
                            _logger.LogError(ex, "[Result] Failed to serialize {Name}", name);
                        }
                    }
                }

                LogJsonDebug("Body", result?.Body);
                LogJsonDebug("ErrorBody", result?.ErrorBody);
                LogJsonDebug("ResponseObject", result?.ResponseObject);

                _logger.LogInformation("[Step 3] Returning response | Success={Success}", result?.Success ?? false);

                // Return direct result
                return await GB5Shared.ResponseStandard.Response.CreateSuccessResponse(result, CacheKeyLevel.NOT_REQUIRED, loginDTO);
            }
            catch (Exception ex)
            {
                sw.Stop();
                _logger.LogError(ex, "[Exception] Error generating MessageHub messages | EntityId={EntityId} | Login={Login}", req.EntityId, req.Login);
                return await GB5Shared.ResponseStandard.Response.CreateExceptionError<string>(
                    ex, CacheKeyLevel.NOT_REQUIRED, loginDTO, ex.Message, 500);
            }
        }
    }
}