using DocumentFormat.OpenXml.Wordprocessing;
using Strata.ContinuousImprovement.Biz.ClientWarehouses;
using Strata.ContinuousImprovement.Biz.DbContexts;
using Strata.ContinuousImprovement.Biz.Test.Unit.Utilities;
using System.Diagnostics.CodeAnalysis;

namespace Strata.ContinuousImprovement.Biz.Test.Integration.ContinuousImprovementServiceTests.ClientWarehouses
{
    [ExcludeFromCodeCoverage]
    [TestFixture, Category("Integration"), Category("CCI")]
    public class TestClientWarehouseService : IntegrationTestBase
    {
        private IClientWarehouseService _clientWarehouseService;
        private List<ClientWarehouse> _clientWarehouses;
        private ClientWarehouse _clientWarehouse = new ClientWarehouse
        {
            DatabaseGuid = Guid.NewGuid(),
            ClientName = "client",
            WarehouseSize = WarehouseSize.S
        };

        [OneTimeSetUp]
        public async Task SetupServices()
        {
            _clientWarehouseService = new ClientWarehouseService((CentralDbContext)CentralDbContext);
            _clientWarehouses = new List<ClientWarehouse>();
            for (var i = 1; i <= 10; i++)
            {
                var warehouse = new ClientWarehouse
                {
                    DatabaseGuid = Guid.NewGuid(),
                    ClientName = $"client_{i}",
                    WarehouseSize = WarehouseSize.S
                };
                warehouse.ClientWarehouseId = await _clientWarehouseService.Add(warehouse, CancellationToken.None);
                _clientWarehouses.Add(warehouse);
            }
        }

        [Test]
        public async Task TestAdd()
        {
            var id = await _clientWarehouseService.Add(_clientWarehouse, CancellationToken.None);
            var warehousesExists = await _clientWarehouseService.Exists(_clientWarehouse.DatabaseGuid, CancellationToken.None);
            Assert.That(warehousesExists, Is.True);
        }

        [Test]
        public async Task TestGetByDatabaseGuid()
        {
            var warehouseClient = new ClientWarehouse
            {
                DatabaseGuid = Guid.NewGuid(),
                ClientName = "client",
                WarehouseSize = WarehouseSize.S
            };
            var id = await _clientWarehouseService.Add(warehouseClient, CancellationToken.None);
            var warehouse = await _clientWarehouseService.GetByDatabaseGuid(warehouseClient.DatabaseGuid, CancellationToken.None);
            Assert.That(warehouse, Is.Not.Null.And.InstanceOf<ClientWarehouse>()
                .And.Property(nameof(ClientWarehouse.ClientName)).EqualTo(warehouseClient.ClientName));
        }

        [Test]
        public async Task TestGetAll()
        {
            var testName = TestContext.CurrentContext.TestName();
            var warehouses = await _clientWarehouseService.GetAll(CancellationToken.None);
            var intersect = _clientWarehouses.Intersect(warehouses);
            Assert.That(intersect, Is.Not.Null.And.Not.Empty);
        }

        [Test]
        public async Task TestDelete()
        {
            var testName = TestContext.CurrentContext.TestName();
            var warehouse = new ClientWarehouse
            {
                DatabaseGuid = Guid.NewGuid(),
                ClientName = "client",
                WarehouseSize = WarehouseSize.S
            };
            var id = await _clientWarehouseService.Add(warehouse, CancellationToken.None);
            var warehousesExists = await _clientWarehouseService.Exists(warehouse.DatabaseGuid, CancellationToken.None);
            Assert.That(warehousesExists, Is.True);
            var warehouseDeleted = await _clientWarehouseService.Delete(warehouse.DatabaseGuid, CancellationToken.None);
            warehousesExists = await _clientWarehouseService.Exists(warehouse.DatabaseGuid, CancellationToken.None);
            Assert.That(!warehousesExists, Is.EqualTo(warehouseDeleted));
        }

    }
}