using AyCode.Core.Enums;
using AyCode.Core.Loggers;
using AyCode.Utils.Extensions;
using FruitBank.Common;
using FruitBank.Common.Dtos;
using FruitBank.Common.Entities;
using FruitBank.Common.Interfaces;
using FruitBank.Common.Loggers;
using FruitBankHybrid.Shared.Services.SignalRs;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices.JavaScript;
// ReSharper disable CompareOfFloatsByEqualityOperator

namespace FruitBankHybrid.Shared.Tests
{
    [TestClass]
    public sealed class FruitBankClientTests
    {
        private const int CustomerIdAasdDsserverCom = 6;//aasd@dsserver.com
        private const string Fixture = "_test.temp";

        private FruitBankSignalRClient _signalRClient = null!;

        private static string GetFixtureName(string name) => $"{GetOriginalName(name)}{Fixture}";
        private static string GetOriginalName(string name) => name.Replace(Fixture, string.Empty);

        [TestInitialize]
        public void TestInit()
        {
            _signalRClient = new FruitBankSignalRClient(new List<IAcLogWriterClientBase>
            {
                //new ConsoleLogWriter(AppType.TestUnit, LogLevel.Detail, nameof(FruitBankClientTests)),
                new SignaRClientLogItemWriter(AppType.TestUnit, LogLevel.Detail, nameof(FruitBankClientTests))
            });
        }

        #region Partner

        [TestMethod]
        public async Task GetPartnersTest()
        {
            var partners = await _signalRClient.GetPartners();

            Assert.IsNotNull(partners);
            Assert.IsTrue(partners.Count != 0);
        }

        //[DataTestMethod]
        //[DataRow(1)]
        public async Task<Partner> GetPartnerByIdTest(int partnerId)
        {
            var partner = await _signalRClient.GetPartnerById(partnerId);

            Assert.IsNotNull(partner);
            Assert.IsTrue(partner.Id == partnerId);

            return partner;
        }

        [DataTestMethod]
        [DataRow(2)]
        public async Task UpdatePartnerTest(int partnerId)
        {
            var partner = await GetPartnerByIdTest(partnerId);

            var newName = GetFixtureName(partner.Name);

            partner.Name = newName;
            partner = await _signalRClient.UpdatePartner(partner);

            Assert.IsNotNull(partner);
            Assert.IsTrue(partner.Name == newName);

            partner.Name = GetOriginalName(partner.Name);
            partner = await _signalRClient.UpdatePartner(partner);
            
            Assert.IsNotNull(partner);
            Assert.IsTrue(partner.Id == partnerId);
        }
        #endregion Partner

        #region Shipping
        [TestMethod]
        public async Task GetShippingsTest()
        {
            var shippings = await _signalRClient.GetShippings();

            Assert.IsNotNull(shippings);
            Assert.IsTrue(shippings.Count != 0);
        }

        [TestMethod]
        public async Task GetNotMeasuredShippingsTest()
        {
            var shippings = await _signalRClient.GetNotMeasuredShippings();

            Assert.IsNotNull(shippings);
            var ShippingMeasuredDateAddDay = 1000; //dfd
            Assert.IsTrue(shippings.All(s => !s.IsAllMeasured || s.MeasuredDate != null || s.MeasuredDate < DateTime.Now.AddDays(ShippingMeasuredDateAddDay)));
        }

        //[TestMethod]
        //[DataRow(1)]
        public async Task<Shipping> GetShippingByIdTest(int shippingId)
        {
            var shipping = await _signalRClient.GetShippingById(shippingId);

            Assert.IsNotNull(shipping);
            Assert.IsNotNull(shipping.ShippingDocuments);

            Assert.IsTrue(shipping.Id == shippingId);
            Assert.IsTrue(shipping.ShippingDocuments.All(s => s.ShippingId == shippingId));
            Assert.IsTrue(shipping.ShippingDocuments.All(sd => sd.ShippingItems != null && sd.ShippingItems.Any(si => si.ShippingDocumentId == sd.Id)));

            return shipping;
        }

        [DataTestMethod]
        [DataRow(1)]
        public async Task UpdateShippingTest(int shippingId)
        {
            var shipping = await GetShippingByIdTest(shippingId);
            var newLicencePlate = GetFixtureName(shipping.LicencePlate);

            shipping.LicencePlate = newLicencePlate;
            await _signalRClient.UpdateShipping(shipping);

            shipping = await GetShippingByIdTest(shippingId);
            
            Assert.IsTrue(shipping.Id == shippingId);
            Assert.IsTrue(shipping.LicencePlate == newLicencePlate);

            shipping.LicencePlate = GetOriginalName(shipping.LicencePlate);
            await _signalRClient.UpdateShipping(shipping);

            Assert.IsTrue(shipping.Id == shippingId);
        }

        #endregion Shipping

        #region ShippingItem

        [TestMethod]
        public async Task GetShippingItemsTest()
        {
            var shippingItems = await _signalRClient.GetShippingItems();

            Assert.IsNotNull(shippingItems);
            Assert.IsTrue(shippingItems.Count != 0);

            Assert.IsTrue(shippingItems.All(si=>si.Product?.Id == si.ProductId), "shippingItem.Product == null");
        }

        [TestMethod]
        [DataRow(1, true)]
        [DataRow(2, true)]
        [DataRow(3, false)]
        [DataRow(4, false)]
        public async Task GetShippingItemByIdTest(int shippingItemId, bool shippingDocumentFileExcepted)
        {
            var shippingItem = await GetShippingItemByIdAsync(shippingItemId);

            if (shippingDocumentFileExcepted) Assert.IsTrue(shippingItem.ShippingDocument?.ShippingDocumentToFiles?.FirstOrDefault()?.ShippingDocumentFile?.Id == 1);
            else
            {
                Assert.IsNotNull(shippingItem.ShippingDocument);
                Assert.IsTrue(shippingItem.ShippingDocument.ShippingDocumentToFiles?.Count == 0);
            }
        }

        [return: NotNull]
        public async Task<ShippingItem> GetShippingItemByIdAsync(int shippingItemId)
        {
            var shippingItem = await _signalRClient.GetShippingItemById(shippingItemId);

            Assert.IsNotNull(shippingItem);
            Assert.IsNotNull(shippingItem.Product, $"shippingItem.Product == null; shippingItem.Id: {shippingItem.ProductId}");
            Assert.IsTrue(shippingItem.Id == shippingItemId);

            Assert.IsTrue(shippingItem.QuantityOnDocument > 0, "QuantityOnDocument == 0");
            Assert.IsTrue(shippingItem.NetWeightOnDocument > 0, "NetWeightOnDocument == 0");
            Assert.IsTrue(shippingItem.GrossWeightOnDocument > 0, "GrossWeightOnDocument == 0");

            return shippingItem;
        }

        [DataTestMethod]
        [DataRow(1, -1, -2.137563300001, -3.75238200001)]
        [DataRow(2, -1, -2.137563300001, 3.75238200001)]
        [DataRow(3, 1, 2.137563300001, -3.75238200001)]
        [DataRow(4, -1, 2.137563300001, 3.75238200001)]
        [DataRow(5, 1, 2.137563300001, 3.75238200001)]
        public async Task UpdateShippingItemTest(int shippingItemId, int incQuantity, double incNetWeight, double incGrossWeight)
        {
            var originalShippingItem = await GetShippingItemByIdAsync(shippingItemId);
            var originalMeasuringProductDto = await GetMeasuringProductDtoByIdAsync(originalShippingItem.ProductId!.Value, originalShippingItem.IsMeasurable);

            Assert.IsTrue(originalShippingItem.IsMeasurable == originalMeasuringProductDto.IsMeasurable);

            var shippingItem = await GetShippingItemByIdAsync(shippingItemId);

            shippingItem.MeasuredQuantity += incQuantity;
            shippingItem.MeasuredNetWeight += incNetWeight;
            shippingItem.MeasuredGrossWeight += incGrossWeight;

            shippingItem = await _signalRClient.UpdateShippingItem(shippingItem);

            Assert.IsNotNull(shippingItem);
            Assert.IsNotNull(shippingItem.Product);

            //incNetWeight = double.Round(incNetWeight, 1);
            //incGrossWeight = double.Round(incGrossWeight, 1);

            Assert.IsTrue(shippingItem.IsMeasured);
            Assert.IsTrue(shippingItem.Product.StockQuantity == originalShippingItem.Product!.StockQuantity + incQuantity);

            Assert.IsTrue(shippingItem.IsMeasurable == originalMeasuringProductDto.IsMeasurable);
            Assert.IsTrue(shippingItem.MeasuredQuantity == originalShippingItem.MeasuredQuantity + incQuantity);


            var measuringProductDto = await GetMeasuringProductDtoByIdAsync(originalShippingItem.ProductId!.Value, shippingItem.IsMeasurable);

            Assert.IsTrue(measuringProductDto.StockQuantity == originalMeasuringProductDto.StockQuantity + incQuantity);

            Assert.IsTrue(shippingItem.MeasuredNetWeight == double.Round(originalShippingItem.MeasuredNetWeight + (shippingItem.IsMeasurable ? incNetWeight : 0), 1));
            Assert.IsTrue(shippingItem.MeasuredGrossWeight == double.Round(originalShippingItem.MeasuredGrossWeight + (shippingItem.IsMeasurable ? incGrossWeight : 0), 1));

            Assert.IsTrue(measuringProductDto.NetWeight == double.Round(originalMeasuringProductDto.NetWeight + (shippingItem.IsMeasurable ? incNetWeight : 0), 1));
            Assert.IsTrue(measuringProductDto.GrossWeight == double.Round(originalMeasuringProductDto.GrossWeight + (shippingItem.IsMeasurable ? incGrossWeight : 0), 1));
        }

        #endregion ShippingItem

        #region ShippingDocument

        [TestMethod]
        public async Task GetShippingDocumentsTest()
        {
            var shippingDocuments = await _signalRClient.GetShippingDocuments();

            Assert.IsNotNull(shippingDocuments);
            Assert.IsTrue(shippingDocuments.Count != 0);
            Assert.IsTrue(shippingDocuments.Any(x => x.ShippingDocumentToFiles?.Count > 0));
        }

        [TestMethod]
        [DataRow(2, true)]
        [DataRow(3, false)]
        [DataRow(4, false)]
        public async Task GetShippingDocumentByIdTest(int shippingDocumentId, bool shippingDocumentFileExcepted)
        {
            var shippingDocument = await GetShippingDocumentByIdAsync(shippingDocumentId);

            if (shippingDocumentFileExcepted) Assert.IsTrue(shippingDocument.ShippingDocumentToFiles?.FirstOrDefault()?.ShippingDocumentFile?.Id == 1);
            else
            {
                Assert.IsTrue(shippingDocument.ShippingDocumentToFiles?.Count == 0);
            }
        }

        [return: NotNull]
        public async Task<ShippingDocument> GetShippingDocumentByIdAsync(int shippingDocumentId)
        {
            var shippingDocument = await _signalRClient.GetShippingDocumentById(shippingDocumentId);

            Assert.IsNotNull(shippingDocument);
            Assert.IsTrue(shippingDocument.Id == shippingDocumentId);

            return shippingDocument;
        }

        [DataTestMethod]
        [DataRow(2)]
        public async Task UpdateShippingDocumentTest(int shippingDocumentId)
        {
            var shippingDocument = await GetShippingDocumentByIdAsync(shippingDocumentId);
            var newCountry = GetFixtureName(shippingDocument.Country);

            shippingDocument.Country = newCountry;
            await _signalRClient.UpdateShippingDocument(shippingDocument);

            shippingDocument = await GetShippingDocumentByIdAsync(shippingDocumentId);
            
            Assert.IsTrue(shippingDocument.Country == newCountry);
            Assert.IsTrue(shippingDocument!.ShippingDocumentToFiles?.FirstOrDefault()?.ShippingDocumentFile?.Id == 1);

            shippingDocument.Country = GetOriginalName(shippingDocument.Country);
            await _signalRClient.UpdateShippingDocument(shippingDocument);
        }

        #endregion ShippingDocument

        #region Customer

        [TestMethod]
        public async Task GetMeasuringUsersTest()
        {
            var users = await _signalRClient.GetMeasuringUsers();

            Assert.IsNotNull(users);
            Assert.IsTrue(users.Count != 0);
            Assert.IsTrue(users.All(x => !x.Email.IsNullOrEmpty() && !x.Deleted));
        }

        [TestMethod]
        [DataRow(CustomerIdAasdDsserverCom)]
        public async Task GetCustomerRolesByCustomerIdTest(int customerId)
        {
            var customerRoles = await _signalRClient.GetCustomerRolesByCustomerId(customerId);

            Assert.IsNotNull(customerRoles);
            Assert.IsTrue(customerRoles.Count > 0);
            Assert.IsTrue(customerRoles.Any(cr => cr.SystemName == "Measuring"));
        }

        #endregion Customer

        #region Product

        [TestMethod]
        public async Task GetProductDtosTest()
        {
            var productDto = await _signalRClient.GetProductDtos();

            Assert.IsNotNull(productDto);
            Assert.IsTrue(productDto.Count != 0);
            Assert.IsTrue(productDto.All(x => !x.Name.IsNullOrEmpty() && !x.Deleted));
        }

        [TestMethod]
        public async Task GetAllMeasuringProductDtosTest()
        {
            var measuringProductDtos = await _signalRClient.GetAllMeasuringProductDtos();

            Assert.IsNotNull(measuringProductDtos);
            Assert.IsTrue(measuringProductDtos.Count != 0);

            Assert.IsTrue(measuringProductDtos.All(x => !x.Name.IsNullOrEmpty() && !x.Deleted));
            Assert.IsTrue(measuringProductDtos.All(x => !x.IsMeasurable || x.HasMeasuringValues()));
        }

        [TestMethod]
        [DataRow(1, true)]
        [DataRow(5, true)]
        [DataRow(6, false)]
        [DataRow(33, true)]
        public async Task GetMeasuringProductDtoByIdTest(int productId, bool isMeasurableExcepted)
        {
            await GetMeasuringProductDtoByIdAsync(productId, isMeasurableExcepted);
        }

        public async Task<MeasuringProductDto> GetMeasuringProductDtoByIdAsync(int productId, bool isMeasurableExcepted)
        {
            var measuringProductDto = await _signalRClient.GetMeasuringProductDtoById(productId);

            Assert.IsNotNull(measuringProductDto);

            if (isMeasurableExcepted) Assert.IsTrue(measuringProductDto.HasMeasuringValues(), $"{measuringProductDto.IsMeasurable}, {measuringProductDto.NetWeight}, {measuringProductDto.GrossWeight}");
            else
            {
                Assert.IsTrue(measuringProductDto.Id > 0);
                Assert.IsTrue(measuringProductDto.StockQuantity > 0);
                Assert.IsTrue(measuringProductDto.NetWeight == 0);
                Assert.IsTrue(measuringProductDto.GrossWeight == 0);

                Assert.IsFalse(measuringProductDto.IsMeasurable);
            }

            return measuringProductDto;
        }

        #endregion Product

        #region Login
        [TestMethod]
        [DataRow("aasd@dsserver.com", "Asdasd123456")]
        public async Task LoginMeasuringUserTest_TrueIfHasCustomerDto(string email, string password)
        {
            var loginModelResponse = await _signalRClient.LoginMeasuringUser(email, password);

            Assert.IsNotNull(loginModelResponse);
            Assert.IsNotNull(loginModelResponse.CustomerDto, loginModelResponse.ErrorMessage);

            Assert.IsTrue(loginModelResponse.CustomerDto.Email == email, loginModelResponse.ErrorMessage);
        }

        [TestMethod]
        [DataRow("adam.g@aycode.com", "123")]
        public async Task LoginMeasuringUserTest_TrueIfHasNotCustomerDto(string email, string password)
        {
            var loginModelResponse = await _signalRClient.LoginMeasuringUser(email, password);

            Assert.IsNotNull(loginModelResponse);
            Assert.IsNull(loginModelResponse.CustomerDto);

            Assert.IsFalse(loginModelResponse.ErrorMessage.IsNullOrWhiteSpace());
            Console.WriteLine($"Succes: {loginModelResponse.ErrorMessage}");
        }
        #endregion Login
    }
}