Mango.Nop.Plugins/Nop.Plugin.Misc.AuctionPlugin/Hubs/SignalRMessageHandler.cs

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;
using Nop.Plugin.Misc.AuctionPlugin.Domains.Enums;
using Nop.Services.Customers;

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;
            //}

            //TODO: lock-olni! - J.
            switch (message.MessageType)
            {
                case "BidRequestMessage":
                    await HandleBidRequest(message.SenderId, message.Data.JsonTo<AuctionBidRequest>());
                    break;

                case "OpenItemRequestMessage":
                    await HandleProductToAuctionStatusChangedRequest(message.SenderId, message.Data.JsonTo<AuctionProductStatusRequest>());
                    break;

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

        private async Task HandleProductToAuctionStatusChangedRequest(int senderId, AuctionProductStatusRequest auctionProductStatusRequest)
        {
            if (auctionProductStatusRequest == null) 
            {
                _logger.Error($"SignalRMessageHandler.HandleProductToAuctionStatusChangedRequest(); auctionProductStatusRequest == null");
                return;
            }

            try
            {
                await _logger.InformationAsync($"SignalRMessageHandler.HandleProductToAuctionStatusChangedRequest(); ProductToAuctionMappingId: {auctionProductStatusRequest.ProductToAuctionId}; Status: {auctionProductStatusRequest.AuctionStatus}({(int)auctionProductStatusRequest.AuctionStatus})");
                
                //TODO: if IsAdmin.. - J.
                //TODO: if nincs aktív item.. - J.

                var auction = await _auctionService.GetAuctionDtoByProductToAuctionIdAsync(auctionProductStatusRequest.ProductToAuctionId);
                if (auction == null || auction.Closed)
                {
                    _logger.Error($"SignalRMessageHandler.HandleProductToAuctionStatusChangedRequest(); auction == null || auction.Closed");
                    return;
                }

                var productToAuction = await _auctionService.GetProductToAuctionMappingByIdAsync(auctionProductStatusRequest.ProductToAuctionId);
                if (productToAuction == null)
                {
                    _logger.Error($"SignalRMessageHandler.HandleProductToAuctionStatusChangedRequest(); productToAuction == null");
                    return;
                }

                switch (auctionProductStatusRequest.AuctionStatus)
                {
                    case AuctionStatus.FirstWarning:
                        productToAuction.AuctionStatus = AuctionStatus.Active | AuctionStatus.FirstWarning;
                        break;
                    case AuctionStatus.SecondWarning:
                        productToAuction.AuctionStatus = AuctionStatus.Active | AuctionStatus.SecondWarning;
                        break;
                    case AuctionStatus.None:
                    case AuctionStatus.Active:
                    case AuctionStatus.SoldOut:
                    case AuctionStatus.NotSold:
                    default:
                        auctionProductStatusRequest.AuctionStatus = auctionProductStatusRequest.AuctionStatus;
                        break;
                }

                await _auctionService.UpdateProductToAuctionMappingAsync(productToAuction);
            }
            catch (Exception ex) 
            { 
                _logger.Error($"Error {ex.Message}");
            }
            
        }

        private async Task HandleBidRequest(int senderId, 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}");

                //CustomerService a = new CustomerService()a.IsGuestAsync()
                var customer = await _workContext.GetCurrentCustomerAsync();
                if (customer == null || bidRequestMessage.CustomerId != customer.Id) //|| !customer.Active) //TODO: ??? - J.
                {
                    _logger.Error($"SignalRMessageHandler.HandleBidRequest(); customer == null || bidRequestMessage.CustomerId != customer.Id");
                    return;
                }

                var auction = await _auctionService.GetAuctionDtoByIdAsync(bidRequestMessage.AuctionId);
                if (auction.Closed)
                {
                    _logger.Warning($"SignalRMessageHandler.HandleBidRequest(); auction.Closed");
                    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 activeProductAuction = (await _auctionService.GetProductToAuctionByAuctionIdAndProductIdAsync(bidRequestMessage.AuctionId, bidRequestMessage.ProductId, true)).FirstOrDefault();
                if (activeProductAuction == null) //|| productAuction.WinnerCustomerId == customer.Id) 
                {
                    _logger.Warning($"SignalRMessageHandler.HandleBidRequest(); activeProductAuction == null");
                    return; //TODO: - J.
                }

                var auctionBid = bidRequestMessage.CreateMainEntity();
                auctionBid.ProductAuctionMappingId = activeProductAuction.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);

                activeProductAuction.StartingPrice = product.OldPrice;
                activeProductAuction.BidPrice = product.Price;
                await _auctionService.UpdateProductToAuctionMappingAsync(activeProductAuction);

                // Optionally broadcast to all clients
                var bid = new MessageWrapper
                {
                    MessageType = "bidNotification",
                    SenderId = senderId,
                    Data = new BidNotificationMessage(await _auctionService.GetAuctionDtoWithProductByIdAsync(auction.Id, activeProductAuction.ProductId, true))
                    {
                        ProductName = auctionBid.ProductId.ToString(),
                        BidPrice = auctionBid.BidPrice.ToString(CultureInfo.InvariantCulture),
                        NextStepAmount = "50000"
                    }.ToJson()
                };

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