using System.Globalization;
using AyCode.Core.Extensions;
using Nop.Plugin.Misc.AuctionPlugin.Hubs.Messages;
using Newtonsoft.Json.Linq;
using Nop.Plugin.Misc.AuctionPlugin.Models;
using Nop.Plugin.Misc.AuctionPlugin.Services;
using Nop.Services.Catalog;
using Newtonsoft.Json;
using Nop.Services.Logging;
using Nop.Plugin.Misc.AuctionPlugin.Domains.Entities;
using Newtonsoft.Json.Serialization;
using Microsoft.AspNetCore.SignalR;
using Nop.Core;

namespace Nop.Plugin.Misc.AuctionPlugin.Hubs
{
    public class SignalRMessageHandler
    {
        protected readonly ILogger _logger;
        protected readonly IProductService _productService;
        protected readonly AuctionService _auctionService;
        private IHubContext<AuctionHub> _hubContext;
        private readonly IWorkContext _workContext;

        public SignalRMessageHandler(ILogger logger, IProductService productService, AuctionService auctionService, IHubContext<AuctionHub> hubContext, IWorkContext workContext)
        {
            _logger = logger;
            _productService = productService;
            _auctionService = auctionService;
            _hubContext = hubContext;
            _workContext = workContext;
        }

        public async Task HandleMessage(MessageWrapper message)
        {
            if (message?.Data == null)
            {
                _logger.Error($"SignalRMessageHandler.HandleMessage(); message?.Data == null");
                return;
            }

            //TODO: A MessageWrapper-ben kéne küldözgetni a UserId (CustomerId-t) - J.
            //if (message.UserId != (await _workContext.GetCurrentCustomerAsync()).Id)
            //{
            //    _logger.Error($"SignalRMessageHandler.HandleMessage(); message.UserId != (await _workContext.GetCurrentCustomerAsync()).Id");
            //    return;
            //}

            switch (message.MessageType)
            {
                case "BidRequestMessage":
                    await HandleBidRequest(message.Data.ToString()?.JsonTo<AuctionBidRequest>());
                    break;

                // Add other message types here
                default:
                    await _logger.ErrorAsync("SignalRMessageHandler.HandleMessage(); Unknown message type");
                    break;
            }
        }

        private async Task HandleBidRequest(AuctionBidRequest bidRequestMessage)
        {
            if (bidRequestMessage == null)
            {
                _logger.Error($"SignalRMessageHandler.HandleBidRequest(); bidRequestMessage == null");
                return;
            }

            try
            {
                await _logger.InformationAsync($"SignalRMessageHandler.HandleBidRequest(); Bid received: - Auction: {bidRequestMessage.AuctionId} Product: {bidRequestMessage.ProductId} - Bid: {bidRequestMessage.BidPrice} - Customer: {bidRequestMessage.CustomerId}");

                if (bidRequestMessage.CustomerId != (await _workContext.GetCurrentCustomerAsync()).Id)
                {
                    _logger.Error($"SignalRMessageHandler.HandleBidRequest(); bidRequestMessage.CustomerId != (await _workContext.GetCurrentCustomerAsync()).Id");
                    return;
                }

                var product = await _productService.GetProductByIdAsync(bidRequestMessage.ProductId);
                if (product == null)
                {
                    _logger.Error($"SignalRMessageHandler.HandleBidRequest(); product == null");
                    return; //ha nincs product vagy exception van, akkor ne broadcast-eljük ki az invalid Bid-et! - J.
                }

                var mapping = await _auctionService.GetProductToAuctionByAuctionIdAndProductIdAsync(bidRequestMessage.AuctionId, bidRequestMessage.ProductId);
                if (mapping == null || mapping.Count == 0)
                {
                    _logger.Error($"SignalRMessageHandler.HandleBidRequest(); mapping == null || mapping.Count == 0");
                    return; //ha nincs ProductToAuction, akkor ne broadcast-eljük ki az invalid Bid-et! - J.
                }

                var auctionBid = bidRequestMessage.CreateMainEntity();
                auctionBid.ProductAuctionMappingId = mapping.FirstOrDefault()!.Id;

                //TODO: validate the bidprice amount
                if (product.Price >= auctionBid.BidPrice)
                {
                    _logger.Warning($"SignalRMessageHandler.HandleBidRequest(); product.Price >= bidRequestMessage.BidPrice; productPrice: {product.Price}; bidRequestPrice: {auctionBid.BidPrice}");
                    return;
                }

                //save bid
                await _auctionService.InsertBidAsync(auctionBid);

                //set new price
                product.Price = bidRequestMessage.BidPrice;
                await _productService.UpdateProductAsync(product);

                // Optionally broadcast to all clients
                var bid = new MessageWrapper
                {
                    MessageType = "bidNotification",
                    Data = new BidNotificationMessage
                    {
                        ProductName = auctionBid.ProductId.ToString(),
                        BidPrice = auctionBid.BidPrice.ToString(CultureInfo.InvariantCulture),
                        NextStepAmount = "50000"
                    }
                };

                await _hubContext.Clients.All.SendAsync("send", bid.ToJson());
            }
            catch (Exception ex)
            {
                _logger.Error($"SignalRMessageHandler.HandleBidRequest(); MessageHandling error: {ex}");
            }
        }
    }
}