using RobotNet10.ScriptEngine;
using RobotNet10.ScriptEngine.Models;
using RobotNet10.ScriptEngine.Shared;

namespace RobotNet10.ScriptEngine.Test;

[TestFixture]
public class VariableManagerTests
{
    private VariableManager _variableManager = null!;

    [SetUp]
    public void SetUp()
    {
        _variableManager = new VariableManager();
    }

    [Test]
    public void Load_WithValidVariables_ShouldLoadSuccessfully()
    {
        // Arrange
        var variables = new[]
        {
            new ScriptVariableModel("TestInt", typeof(int), 42, true, true),
            new ScriptVariableModel("TestString", typeof(string), "Hello", true, false)
        };

        // Act
        _variableManager.Load(variables);

        // Assert
        Assert.That(_variableManager.HasVariable("TestInt"), Is.True);
        Assert.That(_variableManager.HasVariable("TestString"), Is.True);
        Assert.That(_variableManager.GetVariable<int>("TestInt"), Is.EqualTo(42));
        Assert.That(_variableManager.GetVariable<string>("TestString"), Is.EqualTo("Hello"));
    }

    [Test]
    public void Load_WithNullVariables_ShouldThrowArgumentNullException()
    {
        // Act & Assert
        Assert.Throws<ArgumentNullException>(() => _variableManager.Load(null!));
    }

    [Test]
    public void GetVariable_WithExistingVariable_ShouldReturnValue()
    {
        // Arrange
        var variables = new[]
        {
            new ScriptVariableModel("TestInt", typeof(int), 100, true, true)
        };
        _variableManager.Load(variables);

        // Act
        var value = _variableManager.GetVariable<int>("TestInt");

        // Assert
        Assert.That(value, Is.EqualTo(100));
    }

    [Test]
    public void GetVariable_WithNonExistingVariable_ShouldReturnNull()
    {
        // Act
        var value = _variableManager.GetVariable("NonExisting");

        // Assert
        Assert.That(value, Is.Null);
    }

    [Test]
    public void SetVariable_WithPublicWriteVariable_ShouldSetSuccessfully()
    {
        // Arrange
        var variables = new[]
        {
            new ScriptVariableModel("TestInt", typeof(int), 0, true, true)
        };
        _variableManager.Load(variables);

        // Act
        var result = _variableManager.SetVariable("TestInt", 50);

        // Assert
        Assert.That(result, Is.True);
        Assert.That(_variableManager.GetVariable<int>("TestInt"), Is.EqualTo(50));
    }

    [Test]
    public void SetVariable_WithNonPublicWriteVariable_ShouldFail()
    {
        // Arrange
        var variables = new[]
        {
            new ScriptVariableModel("TestInt", typeof(int), 0, true, false)
        };
        _variableManager.Load(variables);

        // Act
        var result = _variableManager.SetVariable("TestInt", 50);

        // Assert
        Assert.That(result, Is.False);
        Assert.That(_variableManager.GetVariable<int>("TestInt"), Is.EqualTo(0));
    }

    [Test]
    public void SetValue_WithStringValue_ShouldConvertAndSet()
    {
        // Arrange
        var variables = new[]
        {
            new ScriptVariableModel("TestInt", typeof(int), 0, true, true)
        };
        _variableManager.Load(variables);

        // Act
        var result = _variableManager.SetValue("TestInt", "123");

        // Assert
        Assert.That(result.IsSuccess, Is.True);
        Assert.That(_variableManager.GetVariable<int>("TestInt"), Is.EqualTo(123));
    }

    [Test]
    public void SetValue_WithNonWritableVariable_ShouldFail()
    {
        // Arrange
        var variables = new[]
        {
            new ScriptVariableModel("TestInt", typeof(int), 0, true, false)
        };
        _variableManager.Load(variables);

        // Act
        var result = _variableManager.SetValue("TestInt", "123");

        // Assert
        Assert.That(result.IsSuccess, Is.False);
    }

    [Test]
    public void GetVariables_ShouldReturnPublicReadableVariables()
    {
        // Arrange
        var variables = new[]
        {
            new ScriptVariableModel("PublicVar", typeof(int), 1, true, true),
            new ScriptVariableModel("PrivateVar", typeof(int), 2, false, false)
        };
        _variableManager.Load(variables);

        // Act
        var result = _variableManager.GetVariables().ToArray();

        // Assert
        Assert.That(result.Length, Is.EqualTo(1));
        Assert.That(result[0].Name, Is.EqualTo("PublicVar"));
    }

    [Test]
    public void Reset_ShouldClearAllVariables()
    {
        // Arrange
        var variables = new[]
        {
            new ScriptVariableModel("TestInt", typeof(int), 42, true, true)
        };
        _variableManager.Load(variables);
        Assert.That(_variableManager.HasVariable("TestInt"), Is.True);

        // Act
        _variableManager.Reset();

        // Assert
        Assert.That(_variableManager.HasVariable("TestInt"), Is.False);
    }
}