namespace Robust.UnitTesting.Shared.GameObjects
{
    public class ContainerTests : RobustIntegrationTest
    {
        /// <summary>
        /// Tests container states with children that do not exist on the client
        /// and tests that said children are added to the container when they do arrive on the client.
        /// </summary>
        /// <returns></returns>
        /*todo paul reenable this  [Test]
         public async Task TestContainerNonexistantItems()
         {
             var server = StartServer();
             var client = StartClient();

             await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());

             Assert.DoesNotThrow(() => client.SetConnectTarget(server));
             client.Post(() => IoCManager.Resolve<IClientNetManager>().ClientConnect(null!, 0, null!));

             for (int i = 0; i < 10; i++)
             {
                 await server.WaitRunTicks(1);
                 await client.WaitRunTicks(1);
             }

             // Setup
             var mapId = MapId.Nullspace;
             var mapPos = MapCoordinates.Nullspace;

             EntityUid entityUid = default!;
             EntityUid itemUid = default!;

             await server.WaitAssertion(() =>
             {
                 var mapMan = IoCManager.Resolve<IMapManager>();
                 var entMan = IoCManager.Resolve<IEntityManager>();
                 var playerMan = IoCManager.Resolve<IPlayerManager>();

                 mapId = mapMan.CreateMap();
                 mapPos = new MapCoordinates((0, 0), mapId);

                 var entity = entMan.SpawnEntity(null, mapPos);
                 entity.Name = "Container";
                 entityUid = entity.Uid;
                 var container = entity.EnsureContainer<Container>("dummy");

                 // Setup PVS
                 entity.AddComponent<Robust.Server.GameObjects.EyeComponent>();
                 var player = playerMan.ServerSessions.First();
                 player.AttachToEntity(entity);
                 player.JoinGame();
             });

             for (int i = 0; i < 10; i++)
             {
                 await server.WaitRunTicks(1);
                 await client.WaitRunTicks(1);
             }

             await server.WaitAssertion(() =>
             {
                 var entMan = IoCManager.Resolve<IEntityManager>();

                 var item = entMan.SpawnEntity(null, mapPos);
                 item.Name = "Item";
                 itemUid = item.Uid;
                 Assert.That(entMan.EntityExists(entityUid);
                 var container = entity!.EnsureContainer<Container>("dummy");
                 container.Insert(item);

                 // Move item out of PVS so that it doesn't get sent to the client
                 item.Transform.LocalPosition = (100000, 0);
             });

             // Needs minimum 4 to sync to client because buffer size is 3
             await server.WaitRunTicks(1);
             await client.WaitRunTicks(4);

             await client.WaitAssertion(() =>
             {
                 var entMan = IoCManager.Resolve<IEntityManager>();
                 if (!entMan.EntityExists(entityUid)
                     || !entity.TryGetComponent<ContainerManagerComponent>(out var containerManagerComp))
                 {
                     Assert.Fail();
                     return;
                 }

                 var container = containerManagerComp.GetContainer("dummy");
                 Assert.That(container.ContainedEntities.Count, Is.EqualTo(0));
                 Assert.That(container.ExpectedEntities.Count, Is.EqualTo(1));


                 var containerSystem = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<ContainerSystem>();
                 Assert.That(containerSystem.ExpectedEntities.ContainsKey(itemUid));
                 Assert.That(containerSystem.ExpectedEntities.Count, Is.EqualTo(1));
             });

             await server.WaitAssertion(() =>
             {
                 var entMan = IoCManager.Resolve<IEntityManager>();

                 // Move item into PVS so it gets sent to the client
                 entMan.GetComponent<TransformComponent>(itemUid).LocalPosition = (0, 0);
             });

             await server.WaitRunTicks(1);
             await client.WaitRunTicks(4);

             await client.WaitAssertion(() =>
             {
                 var entMan = IoCManager.Resolve<IEntityManager>();
                 if (!entMan.EntityExists(entityUid)
                     || !entity.TryGetComponent<ContainerManagerComponent>(out var containerManagerComp))
                 {
                     Assert.Fail();
                     return;
                 }

                 var container = containerManagerComp.GetContainer("dummy");
                 Assert.That(container.ContainedEntities.Count, Is.EqualTo(1));
                 Assert.That(container.ExpectedEntities.Count, Is.EqualTo(0));

                 var containerSystem = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<ContainerSystem>();
                 Assert.That(!containerSystem.ExpectedEntities.ContainsKey(itemUid));
                 Assert.That(containerSystem.ExpectedEntities.Count, Is.EqualTo(0));
             });
         }

         /// <summary>
         /// Tests container states with children that do not exist on the client
         /// and that if those children are deleted that they get properly removed from the expected entities list.
         /// </summary>
         /// <returns></returns>
         [Test]
         public async Task TestContainerExpectedEntityDeleted()
         {
             var server = StartServer();
             var client = StartClient();

             await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());

             Assert.DoesNotThrow(() => client.SetConnectTarget(server));
             client.Post(() => IoCManager.Resolve<IClientNetManager>().ClientConnect(null!, 0, null!));

             for (int i = 0; i < 10; i++)
             {
                 await server.WaitRunTicks(1);
                 await client.WaitRunTicks(1);
             }

             // Setup
             var mapId = MapId.Nullspace;
             var mapPos = MapCoordinates.Nullspace;

             EntityUid entityUid = default!;
             EntityUid itemUid = default!;

             await server.WaitAssertion(() =>
             {
                 var mapMan = IoCManager.Resolve<IMapManager>();
                 var entMan = IoCManager.Resolve<IEntityManager>();
                 var playerMan = IoCManager.Resolve<IPlayerManager>();

                 mapId = mapMan.CreateMap();
                 mapPos = new MapCoordinates((0, 0), mapId);

                 var entity = entMan.SpawnEntity(null, mapPos);
                 entity.Name = "Container";
                 entityUid = entity.Uid;
                 var container = entity.EnsureContainer<Container>("dummy");

                 // Setup PVS
                 entity.AddComponent<Robust.Server.GameObjects.EyeComponent>();
                 var player = playerMan.ServerSessions.First();
                 player.AttachToEntity(entity);
                 player.JoinGame();
             });

             for (int i = 0; i < 10; i++)
             {
                 await server.WaitRunTicks(1);
                 await client.WaitRunTicks(1);
             }

             await server.WaitAssertion(() =>
             {
                 var entMan = IoCManager.Resolve<IEntityManager>();

                 var item = entMan.SpawnEntity(null, mapPos);
                 item.Name = "Item";
                 itemUid = item.Uid;
                 Assert.That(entMan.EntityExists(entityUid);
                 var container = entity!.EnsureContainer<Container>("dummy");
                 container.Insert(item);

                 // Move item out of PVS so that it doesn't get sent to the client
                 item.Transform.LocalPosition = (100000, 0);
             });

             // Needs minimum 4 to sync to client because buffer size is 3
             await server.WaitRunTicks(1);
             await client.WaitRunTicks(4);

             await client.WaitAssertion(() =>
             {
                 var entMan = IoCManager.Resolve<IEntityManager>();
                 if (!entMan.EntityExists(entityUid)
                     || !entity.TryGetComponent<ContainerManagerComponent>(out var containerManagerComp))
                 {
                     Assert.Fail();
                     return;
                 }

                 var container = containerManagerComp.GetContainer("dummy");
                 Assert.That(container.ContainedEntities.Count, Is.EqualTo(0));
                 Assert.That(container.ExpectedEntities.Count, Is.EqualTo(1));

                 var containerSystem = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<ContainerSystem>();
                 Assert.That(containerSystem.ExpectedEntities.ContainsKey(itemUid));
                 Assert.That(containerSystem.ExpectedEntities.Count, Is.EqualTo(1));
             });

             await server.WaitAssertion(() =>
             {
                 var entMan = IoCManager.Resolve<IEntityManager>();

                 // If possible it'd be best to only have the DeleteEntity, but right now
                 // the entity deleted event is not played on the client if the entity does not exist on the client.
                 if (entMan.EntityExists(itemUid)
                     && ContainerHelpers.TryGetContainer(item, out var container))
                     container.ForceRemove(item);
                 entMan.DeleteEntity(itemUid);
             });

             await server.WaitRunTicks(1);
             await client.WaitRunTicks(4);

             await client.WaitAssertion(() =>
             {
                 var entMan = IoCManager.Resolve<IEntityManager>();
                 if (!entMan.EntityExists(entityUid)
                     || !entity.TryGetComponent<ContainerManagerComponent>(out var containerManagerComp))
                 {
                     Assert.Fail();
                     return;
                 }

                 var container = containerManagerComp.GetContainer("dummy");
                 Assert.That(container.ContainedEntities.Count, Is.EqualTo(0));
                 Assert.That(container.ExpectedEntities.Count, Is.EqualTo(0));


                 var containerSystem = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<ContainerSystem>();
                 Assert.That(!containerSystem.ExpectedEntities.ContainsKey(itemUid));
                 Assert.That(containerSystem.ExpectedEntities.Count, Is.EqualTo(0));

            });
        }*/

    }
}