using Syntriax.Engine.Core;

namespace Engine.Tests;

public class UniverseObject_Tests
{
    private static IUniverseObject CreateUniverseObject()
    {
        UniverseObject universeObject = new();
        BehaviourController behaviourController = new();

        universeObject.Assign(new StateEnable());

        behaviourController.Assign(new StateEnable());
        behaviourController.StateEnable.Assign(behaviourController);

        behaviourController.Assign(universeObject);
        universeObject.Assign(behaviourController);

        universeObject.Initialize();
        behaviourController.Initialize();

        return universeObject;
    }

    [Fact]
    public void AddChildren()
    {
        IUniverseObject parentUO = CreateUniverseObject();
        IUniverseObject childUO = CreateUniverseObject();

        parentUO.AddChild(childUO);
        Assert.NotEmpty(parentUO.Children);
        Assert.Equal(parentUO.Children[0], childUO);
        Assert.Equal(childUO.Parent, parentUO);
    }

    [Fact]
    public void RemoveChildren()
    {
        IUniverseObject parentUO = CreateUniverseObject();
        IUniverseObject childUO = CreateUniverseObject();

        parentUO.AddChild(childUO);
        Assert.NotEmpty(parentUO.Children);
        Assert.Contains(childUO, parentUO.Children);
        Assert.Equal(childUO.Parent, parentUO);

        parentUO.RemoveChild(childUO);
        Assert.Empty(parentUO.Children);
        Assert.Null(childUO.Parent);
    }

    [Fact]
    public void SetParentValue()
    {
        IUniverseObject parentUO = CreateUniverseObject();
        IUniverseObject childUO = CreateUniverseObject();

        childUO.Parent = parentUO;
        Assert.Contains(childUO, parentUO.Children);
        Assert.Equal(childUO.Parent, parentUO);
    }

    [Fact]
    public void SetParentNull()
    {
        IUniverseObject parentUO = CreateUniverseObject();
        IUniverseObject childUO = CreateUniverseObject();

        parentUO.AddChild(childUO);

        childUO.Parent = null;
        Assert.Empty(parentUO.Children);
        Assert.Null(childUO.Parent);
    }

    [Fact]
    public void AddChildrenEvents()
    {
        IUniverseObject parentUO = CreateUniverseObject();
        IUniverseObject childUO = CreateUniverseObject();

        IUniverseObject? sender = null;
        IUniverseObject.ChildrenAddedArguments? arguments = null;

        parentUO.OnChildrenAdded.AddListener((s, a) =>
        {
            sender = s;
            arguments = a;
        });

        parentUO.AddChild(childUO);
        Assert.NotNull(sender);
        Assert.NotNull(arguments);
        Assert.Equal(parentUO, sender);
        Assert.Equal(childUO, arguments.Value.ChildrenAdded);
    }

    [Fact]
    public void RemoveChildrenEvents()
    {
        IUniverseObject parentUO = CreateUniverseObject();
        IUniverseObject childUO = CreateUniverseObject();

        IUniverseObject? sender = null;
        IUniverseObject.ChildrenRemovedArguments? arguments = null;

        parentUO.AddChild(childUO);

        parentUO.OnChildrenRemoved.AddListener((s, a) =>
        {
            sender = s;
            arguments = a;
        });

        parentUO.RemoveChild(childUO);

        Assert.NotNull(sender);
        Assert.NotNull(arguments);
        Assert.Equal(parentUO, sender);
        Assert.Equal(childUO, arguments.Value.ChildrenRemoved);
    }

    [Fact]
    public void SetParentEvents()
    {
        IUniverseObject parentUO = CreateUniverseObject();
        IUniverseObject childUO = CreateUniverseObject();

        IUniverseObject? sender = null;
        IUniverseObject.ParentChangedArguments? arguments = null;

        childUO.OnParentChanged.AddListener((s, a) =>
        {
            sender = s;
            arguments = a;
        });

        childUO.Parent = parentUO;

        Assert.NotNull(sender);
        Assert.NotNull(arguments);
        Assert.Equal(childUO, sender);
        Assert.Null(arguments.Value.PreviousParent);
        Assert.Equal(parentUO, arguments.Value.CurrentParent);
    }

    [Fact]
    public void UnsetParentEvents()
    {
        IUniverseObject parentUO = CreateUniverseObject();
        IUniverseObject childUO = CreateUniverseObject();

        IUniverseObject? sender = null;
        IUniverseObject.ParentChangedArguments? arguments = null;

        childUO.Parent = parentUO;

        childUO.OnParentChanged.AddListener((s, a) =>
        {
            sender = s;
            arguments = a;
        });

        childUO.Parent = null;

        Assert.NotNull(sender);
        Assert.NotNull(arguments);
        Assert.Equal(childUO, sender);
        Assert.Equal(parentUO, arguments.Value.PreviousParent);
        Assert.Null(arguments.Value.CurrentParent);
    }

    [Fact]
    public void Active()
    {
        IUniverseObject universeObject = CreateUniverseObject();
        universeObject.StateEnable.Enabled = true;

        Assert.True(universeObject.IsActive);
    }

    [Fact]
    public void NotActiveWhenDisabled()
    {
        IUniverseObject universeObject = CreateUniverseObject();
        universeObject.StateEnable.Enabled = false;

        Assert.False(universeObject.IsActive);
    }

    [Fact]
    public void ActiveEvents()
    {
        IUniverseObject universeObject = CreateUniverseObject();
        universeObject.StateEnable.Enabled = true;

        IActive? sender = null;
        IActive.ActiveChangedArguments? arguments = null;

        universeObject.OnActiveChanged.AddListener((s, a) =>
        {
            sender = s;
            arguments = a;
        });

        universeObject.StateEnable.Enabled = false;

        Assert.NotNull(sender);
        Assert.NotNull(arguments);

        Assert.False(universeObject.IsActive);
        Assert.True(arguments.Value.PreviousState);
    }

    [Fact]
    public void NotActiveEvents()
    {
        IUniverseObject universeObject = CreateUniverseObject();
        universeObject.StateEnable.Enabled = false;

        IActive? sender = null;
        IActive.ActiveChangedArguments? arguments = null;

        universeObject.OnActiveChanged.AddListener((s, a) =>
        {
            sender = s;
            arguments = a;
        });

        universeObject.StateEnable.Enabled = true;

        Assert.NotNull(sender);
        Assert.NotNull(arguments);

        Assert.True(universeObject.IsActive);
        Assert.False(arguments.Value.PreviousState);
    }

    [Fact]
    public void SetName()
    {
        IUniverseObject universeObject = CreateUniverseObject();
        universeObject.Name = "Test";
        Assert.Equal("Test", universeObject.Name);
    }

    [Fact]
    public void SetNameEvents()
    {
        IUniverseObject universeObject = CreateUniverseObject();
        universeObject.Name = "Previous";

        INameable? sender = null;
        INameable.NameChangedArguments? arguments = null;

        universeObject.OnNameChanged.AddListener((s, a) =>
        {
            sender = s;
            arguments = a;
        });

        universeObject.Name = "Test";

        Assert.NotNull(sender);
        Assert.NotNull(arguments);

        Assert.Equal("Test", universeObject.Name);
        Assert.Equal("Previous", arguments.Value.PreviousName);
    }
}