using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FrameworkBLL.EIPConversation.ChannelHandler
{
    using FrameworkDAL.DTO.EIPConversation;
    using GB5Shared.DTO.Framework.Login;
    using global::FrameworkBLL.EIPConversation.EIPHandlers.ChannelHandler;
    using Microsoft.Extensions.Logging;

    namespace FrameworkBLL.EIPConversation.ChannelHandler
    {
        public class PostmanChannelHandler : IEIPChannelHandler
        {
            public string ChannelName => "POSTMAN";

            public bool CanHandle(string channel) =>
                string.Equals(channel, ChannelName, StringComparison.OrdinalIgnoreCase);

            private readonly ILogger<PostmanChannelHandler> _logger;

            public PostmanChannelHandler(ILogger<PostmanChannelHandler> logger)
            {
                _logger = logger ?? throw new ArgumentNullException(nameof(logger));
            }

            public async Task<EIPChannelResponseDTO> SendAsync(
                EIPResponseContext context,
                LoginDTO loginDTO,
                CancellationToken cancellationToken)
            {
                if (context == null)
                    throw new ArgumentNullException(nameof(context));

                if (loginDTO == null)
                    throw new ArgumentNullException(nameof(loginDTO));

                var stopwatch = System.Diagnostics.Stopwatch.StartNew();

                try
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    _logger.LogInformation(
                        "POSTMAN SEND START | Tenant={Tenant} | Channel={Channel} | Recipient={Recipient}",
                        context.TenantId,
                        context.Channel,
                        context.Recipient);

                    // --------------------------------------------------
                    // Log Full Payload (Simulation Mode)
                    // --------------------------------------------------

                    _logger.LogInformation(
                        "POSTMAN PAYLOAD | Message={Message} | MediaUrl={MediaUrl} | ButtonCount={ButtonCount}",
                        context.Message,
                        context.MediaUrl,
                        context.Buttons?.Count ?? 0);

                    // Simulate processing
                    await Task.CompletedTask;

                    stopwatch.Stop();

                    _logger.LogInformation(
                        "POSTMAN SEND SUCCESS | Tenant={Tenant} | DurationMs={Duration}",
                        context.TenantId,
                        stopwatch.ElapsedMilliseconds);

                    return new EIPChannelResponseDTO
                    {
                        IsSent = true,
                        ExternalMessageId = Guid.NewGuid().ToString(),
                        Status = "SIMULATED"
                    };
                }
                catch (OperationCanceledException)
                {
                    _logger.LogWarning(
                        "POSTMAN SEND CANCELLED | Tenant={Tenant}",
                        context?.TenantId);

                    throw;
                }
                catch (Exception ex)
                {
                    stopwatch.Stop();

                    _logger.LogError(ex,
                        "POSTMAN SEND FAILED | Tenant={Tenant} | DurationMs={Duration}",
                        context?.TenantId,
                        stopwatch.ElapsedMilliseconds);

                    return new EIPChannelResponseDTO
                    {
                        IsSent = false,
                        Status = "FAILED",
                        ErrorMessage = ex.Message
                    };
                }
            }
        }
    }
}