using AyCode.Core.Extensions;
using AyCode.Core.Helpers;
using AyCode.Core.Loggers;
using AyCode.Services.Server.SignalRs;
using AyCode.Services.SignalRs;
using DevExpress.Utils.About;
using FruitBank.Common;
using FruitBank.Common.Dtos;
using FruitBank.Common.Entities;
using FruitBank.Common.Interfaces;
using FruitBank.Common.Models;
using FruitBank.Common.SignalRs;
using FruitBankHybrid.Shared.Databases;
using FruitBankHybrid.Shared.Services.Loggers;
using Mango.Nop.Core.Dtos;
using Mango.Nop.Core.Models;
using MessagePack.Resolvers;
using Microsoft.AspNetCore.SignalR.Client;
using Nop.Core.Domain.Customers;
using System.Collections.ObjectModel;
using System.ServiceModel.Channels;
using Mango.Nop.Core.Entities;

namespace FruitBankHybrid.Shared.Services.SignalRs
{
    public class FruitBankSignalRClient : AcSignalRClientBase, IFruitBankDataControllerClient, ICustomOrderSignalREndpointClient, IStockSignalREndpointClient
    {
        public FruitBankSignalRClient( /*IServiceProvider serviceProvider, */ IEnumerable<IAcLogWriterClientBase> logWriters) : base($"{FruitBankConstClient.BaseUrl}/{FruitBankConstClient.DefaultHubName}", new LoggerClient(nameof(FruitBankSignalRClient), logWriters.ToArray()))
        {
            //var hubConnection = new HubConnectionBuilder()
            //    .WithUrl("fullHubName")
            //    .WithAutomaticReconnect()
            //    .WithStatefulReconnect()
            //    .WithKeepAliveInterval(TimeSpan.FromSeconds(60))
            //    .WithServerTimeout(TimeSpan.FromSeconds(120))

            ConstHelper.NameByValue<SignalRTags>(0);
        }

        /// <summary>
        /// MessageTag, JSON
        /// </summary>
        public event Func<int, string?, Task> OnMessageReceived = null!;

        protected override async Task MessageReceived(int messageTag, byte[] messageBytes)
        {
            var jsonMessage = messageBytes.MessagePackTo<SignalResponseJsonMessage>(ContractlessStandardResolver.Options);

            await OnMessageReceived(messageTag, jsonMessage.ResponseData);
        }

        private void SendMessageToAllClients(int messageTag, string message)
        {
            if (messageTag == SignalRTags.NotificationReceived)
            {
                Logger.Info(message);
            }
        }

        public Task<List<MeasuringModel>?> GetMeasuringModels()
            => GetAllAsync<List<MeasuringModel>>(SignalRTags.GetMeasuringModels);

        public Task<List<Partner>?> GetPartners()
            => GetAllAsync<List<Partner>>(SignalRTags.GetPartners);

        #region Partner

        public Task<Partner?> GetPartnerById(int id)
            => GetByIdAsync<Partner?>(SignalRTags.GetPartnerById, id);

        public Task<Partner?> UpdatePartner(Partner partner)
            => PostDataAsync(SignalRTags.UpdatePartner, partner);

        #endregion Partner

        #region Shipping

        public Task<List<Shipping>?> GetShippings()
            => GetAllAsync<List<Shipping>>(SignalRTags.GetShippings);

        public Task<List<Shipping>?> GetNotMeasuredShippings()
            => GetAllAsync<List<Shipping>>(SignalRTags.GetNotMeasuredShippings);

        public Task<Shipping?> GetShippingById(int id)
            => GetByIdAsync<Shipping?>(SignalRTags.GetShippingById, id);

        public Task<Shipping?> AddShipping(Shipping shipping)
            => PostDataAsync(SignalRTags.AddShipping, shipping);

        public Task<Shipping?> UpdateShipping(Shipping shipping)
            => PostDataAsync(SignalRTags.UpdateShipping, shipping);

        public Task<List<Partner>?> ProcessAndSaveFullShippingJson(string fullShippingJson, int customerId)
            => GetAllAsync<List<Partner>>(SignalRTags.ProcessAndSaveFullShippingJson, [fullShippingJson, customerId]);

        #endregion Shipping

        #region ShippingItem

        public Task<List<ShippingItem>?> GetShippingItems()
            => GetAllAsync<List<ShippingItem>>(SignalRTags.GetShippingItems);

        public Task<List<ShippingItem>?> GetShippingItemsByDocumentId(int shippingDocumentId)
            => GetAllAsync<List<ShippingItem>>(SignalRTags.GetShippingItemsByDocumentId, [shippingDocumentId]);

        public Task<List<ShippingItem>?> GetShippingItemsByShippingId(int shippingId)
            => GetAllAsync<List<ShippingItem>>(SignalRTags.GetShippingItemsByShippingId, [shippingId]);

        public Task<List<ShippingItem>?> GetShippingItemsByPartnerId(int partnerId)
            => GetAllAsync<List<ShippingItem>>(SignalRTags.GetShippingItemsByPartnerId, [partnerId]);

        public Task<ShippingItem?> GetShippingItemById(int id)
            => GetByIdAsync<ShippingItem?>(SignalRTags.GetShippingItemById, id);

        public Task<ShippingItem?> AddShippingItem(ShippingItem shippingItem)
            => PostDataAsync(SignalRTags.AddShippingItem, shippingItem);

        public Task<ShippingItem?> UpdateShippingItem(ShippingItem shippingItem)
            => PostDataAsync(SignalRTags.UpdateShippingItem, shippingItem);

        public Task<ShippingItem?> UpdateMeasuredShippingItem(ShippingItem shippingItem)
            => PostDataAsync(SignalRTags.UpdateMeasuredShippingItem, shippingItem);

        #endregion ShippingItem

        #region ShippingItemPallet

        public Task<List<ShippingItemPallet>?> GetShippingItemPallets()
            => GetAllAsync<List<ShippingItemPallet>>(SignalRTags.GetShippingItemPallets);

        public Task<ShippingItemPallet?> AddShippingItemPallet(ShippingItemPallet shippingItemPallet)
            => PostDataAsync(SignalRTags.AddShippingItemPallet, shippingItemPallet);

        public Task<ShippingItemPallet?> UpdateShippingItemPallet(ShippingItemPallet shippingItemPallet)
            => PostDataAsync(SignalRTags.UpdateShippingItemPallet, shippingItemPallet);

        public Task<ShippingItemPallet?> AddOrUpdateMeasuredShippingItemPallet(ShippingItemPallet shippingItemPallet)
            => PostDataAsync(SignalRTags.AddOrUpdateMeasuredShippingItemPallet, shippingItemPallet);

        public Task<ShippingItem?> AddOrUpdateMeasuredShippingItemPallets(List<ShippingItemPallet> shippingItemPallets)
            => PostDataAsync<List<ShippingItemPallet>, ShippingItem>(SignalRTags.AddOrUpdateMeasuredShippingItemPallets, shippingItemPallets);

        #endregion ShippingItemPallet

        #region ShippingDocument

        public Task<List<ShippingDocument>?> GetShippingDocuments()
            => GetAllAsync<List<ShippingDocument>>(SignalRTags.GetShippingDocuments);

        public Task<ShippingDocument?> GetShippingDocumentById(int id)
            => GetByIdAsync<ShippingDocument?>(SignalRTags.GetShippingDocumentById, id);

        public Task<List<ShippingDocument>?> GetShippingDocumentsByShippingId(int shippingId)
            => GetAllAsync<List<ShippingDocument>>(SignalRTags.GetShippingDocumentsByShippingId, [shippingId]);

        public Task<List<ShippingDocument>?> GetShippingDocumentsByProductId(int productId)
            => GetAllAsync<List<ShippingDocument>>(SignalRTags.GetShippingDocumentsByShippingId, [productId]);

        public Task<List<ShippingDocument>?> GetShippingDocumentsByPartnerId(int partnerId)
            => GetAllAsync<List<ShippingDocument>>(SignalRTags.GetShippingDocumentsByShippingId, [partnerId]);

        public Task<ShippingDocument?> AddShippingDocument(ShippingDocument shippingDocument)
            => PostDataAsync(SignalRTags.AddShippingDocument, shippingDocument);

        public Task<ShippingDocument?> UpdateShippingDocument(ShippingDocument shippingDocument)
            => PostDataAsync(SignalRTags.UpdateShippingDocument, shippingDocument);
        #endregion ShippingDocument

        #region Customer

        public Task<List<CustomerDto>?> GetMeasuringUsers()
            => GetAllAsync<List<CustomerDto>>(SignalRTags.GetMeasuringUsers);

        public Task<List<CustomerRole>?> GetCustomerRolesByCustomerId(int customerId)
            => GetAllAsync<List<CustomerRole>>(SignalRTags.GetCustomerRolesByCustomerId, [customerId]);
        #endregion Customer

        #region Product

        public Task<List<ProductDtoTableItem>?> GetProductDtoTableItems()
            => GetAllAsync<List<ProductDtoTableItem>>(SignalRTags.GetProductDtos);

        public Task<List<ProductDto>?> GetProductDtos()
            => GetAllAsync<List<ProductDto>>(SignalRTags.GetProductDtos);

        //public Task<List<MeasuringProductDto>?> GetAllMeasuringProductDtos()
        //    => GetAllAsync<List<MeasuringProductDto>>(SignalRTags.GetAllMeasuringProductDtos);

        public Task<ProductDto?> GetProductDtoById(int productId)
        => GetByIdAsync<ProductDto?>(SignalRTags.GetMeasuringProductDtoById, productId);

        #endregion Product

        #region Authenticate
        public Task<MgLoginModelResponse?> LoginMeasuringUser(string customerEmail, string customerPassword)
            => LoginMeasuringUser(new MgLoginModelRequest(customerEmail, customerPassword));

        public Task<MgLoginModelResponse?> LoginMeasuringUser(MgLoginModelRequest loginModelRequest)
            => PostDataAsync<MgLoginModelRequest, MgLoginModelResponse>(SignalRTags.AuthenticateUser, loginModelRequest);
        #endregion Authenticate

        #region Orders
        public Task<List<OrderDtoTableItem>?> GetAllOrderDtoTableItems()
            => GetAllAsync<List<OrderDtoTableItem>>(SignalRTags.GetAllOrderDtos);

        public Task<List<OrderDto>?> GetAllOrderDtos()
            => GetAllAsync<List<OrderDto>>(SignalRTags.GetAllOrderDtos);

        public Task<OrderDto?> GetOrderDtoById(int orderId)
            => GetByIdAsync<OrderDto?>(SignalRTags.GetOrderDtoById, orderId);

        public Task<List<OrderDto>?> GetPendingOrderDtos()
            => GetAllAsync<List<OrderDto>>(SignalRTags.GetPendingOrderDtos);

        public Task<List<OrderDto>?> GetPendingOrderDtosForMeasuring(int lastDaysCount)
            => GetAllAsync<List<OrderDto>>(SignalRTags.GetPendingOrderDtosForMeasuring, [lastDaysCount]);

        public Task<List<OrderDto>?> GetAllOrderDtoByIds(int[] orderIds)
            => GetAllAsync<List<OrderDto>>(SignalRTags.GetAllOrderDtoByIds, [orderIds]);

        public Task<List<OrderItemDto>?> GetAllOrderItemDtos()
            => GetAllAsync<List<OrderItemDto>>(SignalRTags.GetAllOrderItemDtos);

        public Task<OrderItemPallet?> AddOrUpdateMeasuredOrderItemPallet(OrderItemPallet orderItemPallet)
            => PostDataAsync(SignalRTags.AddOrUpdateMeasuredOrderItemPallet, orderItemPallet);

        public Task<OrderDto?> StartMeasuring(int orderId, int userId)
            => GetByIdAsync<OrderDto>(SignalRTags.StartMeasuring, [orderId, userId]);

        public Task<OrderDto?> SetOrderStatusToComplete(int orderId, int revisorId)
            => GetByIdAsync<OrderDto>(SignalRTags.SetOrderStatusToComplete, [orderId, revisorId]);

        public Task<List<OrderDto>?> GetAllOrderDtoByProductId(int productId)
            => GetAllAsync<List<OrderDto>>(SignalRTags.GetAllOrderDtoByProductId, [productId]);

        public Task<OrderItemDto?> GetOrderItemDtoById(int orderItemId)
            => GetByIdAsync<OrderItemDto>(SignalRTags.GetOrderItemDtoById, [orderItemId]);

        public Task<List<OrderItemDto>?> GetAllOrderItemDtoByOrderId(int orderId)
            => GetAllAsync<List<OrderItemDto>>(SignalRTags.GetAllOrderItemDtoByOrderId, [orderId]);

        public Task<List<OrderItemDto>?> GetAllOrderItemDtoByProductId(int productId)
            => GetAllAsync<List<OrderItemDto>>(SignalRTags.GetAllOrderItemDtoByProductId, [productId]);

        public Task<List<OrderItemPallet>?> GetAllOrderItemPallets()
            => GetAllAsync<List<OrderItemPallet>>(SignalRTags.GetAllOrderItemPallets);

        public Task<OrderItemPallet?> GetOrderItemPalletById(int orderItemPalletId)
            => GetByIdAsync<OrderItemPallet>(SignalRTags.GetOrderItemPalletById, [orderItemPalletId]);

        public Task<List<OrderItemPallet>?> GetAllOrderItemPalletByOrderItemId(int orderItemId)
            => GetAllAsync<List<OrderItemPallet>>(SignalRTags.GetAllOrderItemPalletByOrderItemId, [orderItemId]);

        public Task<List<OrderItemPallet>?> GetAllOrderItemPalletByOrderId(int orderId)
            => GetAllAsync<List<OrderItemPallet>>(SignalRTags.GetAllOrderItemPalletByOrderId, [orderId]);

        public Task<List<OrderItemPallet>?> GetAllOrderItemPalletByProductId(int productId)
            => GetAllAsync<List<OrderItemPallet>>(SignalRTags.GetAllOrderItemPalletByProductId, [productId]);

        public Task<List<StockQuantityHistoryDto>?> GetStockQuantityHistoryDtos()
            => GetAllAsync<List<StockQuantityHistoryDto>>(SignalRTags.GetStockQuantityHistoryDtos);

        public Task<List<StockQuantityHistoryDto>?> GetStockQuantityHistoryDtosByProductId(int productId)
            => GetAllAsync<List<StockQuantityHistoryDto>>(SignalRTags.GetStockQuantityHistoryDtosByProductId, [productId]);

        #endregion Orders

        public async Task<List<GenericAttributeDto>?> GetGenericAttributeDtosByEntityIdAndKeyGroup(int productId, string keyGroup, int storeId)
        {
            throw new NotImplementedException();
        }

        public async Task<GenericAttributeDto?> AddGenericAttributeDto(GenericAttributeDto genericAttributeDto)
        {
            throw new NotImplementedException();
        }

        public async Task<GenericAttributeDto?> UpdateGenericAttributeDto(GenericAttributeDto genericAttributeDto)
        {
            throw new NotImplementedException();
        }


        public Task<List<StockTaking>?> GetStockTakings() => GetAllAsync<List<StockTaking>>(SignalRTags.GetStockTakings);

        public async Task<List<StockTaking>?> GetStockTakingsByProductId(int productId)
        {
            throw new NotImplementedException();
        }

        public Task<StockTaking?> AddStockTaking(StockTaking stockTaking) => PostDataAsync(SignalRTags.AddStockTaking, stockTaking);

        public async Task<StockTaking?> UpdateStockTaking(StockTaking stockTaking)
        {
            throw new NotImplementedException();
        }

        public Task<List<StockTakingItem>?> GetStockTakingItems() => GetAllAsync<List<StockTakingItem>>(SignalRTags.GetStockTakingItems);

        public Task<StockTakingItem?> GetStockTakingItemsById(int stockTakingItemId)
            => GetByIdAsync<StockTakingItem>(SignalRTags.GetStockTakingItemsById, [stockTakingItemId]);

        public async Task<List<StockTakingItem>?> GetStockTakingItemsByProductId(int productId)
        {
            throw new NotImplementedException();
        }

        public async Task<List<StockTakingItem>?> GetStockTakingItemsByStockTakingId(int stockTakingId)
        {
            throw new NotImplementedException();
        }

        public async Task<StockTakingItem?> AddStockTakingItem(StockTakingItem stockTakingItem)
        {
            throw new NotImplementedException();
        }

        public async Task<StockTakingItem?> UpdateStockTakingItem(StockTakingItem stockTakingItem)
        {
            throw new NotImplementedException();
        }

        public async Task<List<StockTakingItemPallet>?> GetStockTakingItemPallets()
        {
            throw new NotImplementedException();
        }

        public async Task<List<StockTakingItemPallet>?> GetStockTakingItemPalletsByProductId(int productId)
        {
            throw new NotImplementedException();
        }

        public async Task<StockTakingItemPallet?> AddStockTakingItemPallet(StockTakingItemPallet stockTakingItemPallet)
        {
            throw new NotImplementedException();
        }

        public async Task<StockTakingItemPallet?> UpdateStockTakingItemPallet(StockTakingItemPallet stockTakingItemPallet)
        {
            throw new NotImplementedException();
        }
    }
}