using Moq;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories;
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Services;
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management;
using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;
using ZB.MOM.WW.ScadaBridge.TemplateEngine.Services;

namespace ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests.Services;

public class InstanceServiceTests
{
    private readonly Mock<ITemplateEngineRepository> _repoMock = new();
    private readonly Mock<IAuditService> _auditMock = new();
    private readonly InstanceService _sut;

    /// <summary>Initializes the test with a mocked repository and audit service and the service under test.</summary>
    public InstanceServiceTests()
    {
        _sut = new InstanceService(_repoMock.Object, _auditMock.Object);
    }

    /// <summary>Verifies that creating an instance with valid input returns success.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task CreateInstance_ValidInput_ReturnsSuccess()
    {
        _repoMock.Setup(r => r.GetTemplateByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new Template("TestTemplate") { Id = 1 });
        _repoMock.Setup(r => r.GetInstanceByUniqueNameAsync("Inst1", It.IsAny<CancellationToken>()))
            .ReturnsAsync((Instance?)null);
        _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        var result = await _sut.CreateInstanceAsync("Inst1", 1, 1, null, "admin");

        Assert.True(result.IsSuccess);
        Assert.Equal("Inst1", result.Value.UniqueName);
        Assert.Equal(InstanceState.Disabled, result.Value.State); // Starts disabled
        _repoMock.Verify(r => r.AddInstanceAsync(It.IsAny<Instance>(), It.IsAny<CancellationToken>()), Times.Once);
    }

    /// <summary>Verifies that creating an instance with a duplicate name returns a failure.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task CreateInstance_DuplicateName_ReturnsFailure()
    {
        _repoMock.Setup(r => r.GetTemplateByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new Template("T") { Id = 1 });
        _repoMock.Setup(r => r.GetInstanceByUniqueNameAsync("Inst1", It.IsAny<CancellationToken>()))
            .ReturnsAsync(new Instance("Inst1") { Id = 99 });

        var result = await _sut.CreateInstanceAsync("Inst1", 1, 1, null, "admin");

        Assert.True(result.IsFailure);
        Assert.Contains("already exists", result.Error);
    }

    /// <summary>Verifies that creating an instance from a missing template returns a failure.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task CreateInstance_MissingTemplate_ReturnsFailure()
    {
        _repoMock.Setup(r => r.GetTemplateByIdAsync(999, It.IsAny<CancellationToken>()))
            .ReturnsAsync((Template?)null);

        var result = await _sut.CreateInstanceAsync("Inst1", 999, 1, null, "admin");

        Assert.True(result.IsFailure);
        Assert.Contains("not found", result.Error);
    }

    /// <summary>Verifies that overriding a locked attribute returns a failure.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task SetAttributeOverride_LockedAttribute_ReturnsFailure()
    {
        var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.GetAttributesByTemplateIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<TemplateAttribute>
            {
                new("LockedAttr") { IsLocked = true }
            });

        var result = await _sut.SetAttributeOverrideAsync(1, "LockedAttr", "new", "admin");

        Assert.True(result.IsFailure);
        Assert.Contains("locked", result.Error, StringComparison.OrdinalIgnoreCase);
    }

    /// <summary>Verifies that overriding a non-existent attribute returns a failure.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task SetAttributeOverride_NonExistentAttribute_ReturnsFailure()
    {
        var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.GetAttributesByTemplateIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<TemplateAttribute>());

        var result = await _sut.SetAttributeOverrideAsync(1, "Missing", "value", "admin");

        Assert.True(result.IsFailure);
        Assert.Contains("does not exist", result.Error);
    }

    /// <summary>Verifies that overriding an unlocked attribute returns success.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task SetAttributeOverride_UnlockedAttribute_ReturnsSuccess()
    {
        var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.GetAttributesByTemplateIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<TemplateAttribute>
            {
                new("Threshold") { IsLocked = false }
            });
        _repoMock.Setup(r => r.GetOverridesByInstanceIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<InstanceAttributeOverride>());
        _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        var result = await _sut.SetAttributeOverrideAsync(1, "Threshold", "99", "admin");

        Assert.True(result.IsSuccess);
        Assert.Equal("Threshold", result.Value.AttributeName);
        Assert.Equal("99", result.Value.OverrideValue);
    }

    /// <summary>
    /// ScadaBridge#105, end to end for the single-attribute path the Central UI uses
    /// (<see cref="InstanceService.SetAttributeOverrideAsync"/>): whatever it stores must be
    /// applied by the real flattener. The exact-case row is the positive control; a name
    /// differing from the member only by case is refused with a hint and nothing is stored.
    /// </summary>
    /// <param name="requestedName">The override name the caller sends.</param>
    /// <param name="accepted">Whether the write is expected to succeed.</param>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Theory]
    [InlineData("Threshold", true)]
    [InlineData("threshold", false)]
    [InlineData("THRESHOLD", false)]
    public async Task SetAttributeOverride_EveryStoredOverride_IsAppliedByTheFlattener(string requestedName, bool accepted)
    {
        var template = new Template("Base") { Id = 1 };
        template.Attributes.Add(new TemplateAttribute("Threshold") { TemplateId = 1, DataType = DataType.Double, Value = "50.0" });
        var instance = new Instance("Inst1") { Id = 1, TemplateId = 1, SiteId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>())).ReturnsAsync(instance);
        _repoMock.Setup(r => r.GetAttributesByTemplateIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(template.Attributes.ToList());
        _repoMock.Setup(r => r.GetOverridesByInstanceIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<InstanceAttributeOverride>());
        _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>())).ReturnsAsync(1);
        var stored = new List<InstanceAttributeOverride>();
        _repoMock.Setup(r => r.AddInstanceAttributeOverrideAsync(It.IsAny<InstanceAttributeOverride>(), It.IsAny<CancellationToken>()))
            .Callback<InstanceAttributeOverride, CancellationToken>((o, _) => stored.Add(o))
            .Returns(Task.CompletedTask);

        var result = await _sut.SetAttributeOverrideAsync(1, requestedName, "75.0", "admin");

        foreach (var o in stored) instance.AttributeOverrides.Add(o);
        var flattened = new ZB.MOM.WW.ScadaBridge.TemplateEngine.Flattening.FlatteningService().Flatten(
            instance, [template],
            new Dictionary<int, IReadOnlyList<TemplateComposition>>(),
            new Dictionary<int, IReadOnlyList<Template>>(),
            new Dictionary<int, ZB.MOM.WW.ScadaBridge.Commons.Entities.Sites.DataConnection>());
        Assert.True(flattened.IsSuccess);
        foreach (var o in stored)
            Assert.True(
                flattened.Value.Attributes.Any(a => a.CanonicalName == o.AttributeName && a.Source == "Override"),
                $"Override '{o.AttributeName}' was stored but the flattener dropped it as unresolved.");

        var threshold = Assert.Single(flattened.Value.Attributes, a => a.CanonicalName == "Threshold");
        if (accepted)
        {
            Assert.True(result.IsSuccess);
            Assert.Equal("75.0", threshold.Value);
            Assert.Equal("Override", threshold.Source);
        }
        else
        {
            Assert.True(result.IsFailure);
            Assert.Contains("did you mean 'Threshold'", result.Error);
            Assert.Empty(stored);
            Assert.Equal("50.0", threshold.Value);
        }
    }

    /// <summary>ScadaBridge#105: an ambiguous case-insensitive match (two candidates differing only by case) gets no hint.</summary>
    [Fact]
    public void CaseMismatchHint_NamesOnlyAnUnambiguousMatch()
    {
        Assert.Contains("did you mean 'Setpoint'", OverrideNameMatching.CaseMismatchHint("setpoint", ["Setpoint", "Other"]));
        Assert.Equal(string.Empty, OverrideNameMatching.CaseMismatchHint("setpoint", ["Setpoint", "SETPOINT"]));
        Assert.Equal(string.Empty, OverrideNameMatching.CaseMismatchHint("missing", ["Setpoint"]));
    }

    // --- SetAlarmOverrideAsync validation regression ---

    private static Template TemplateWithAlarms(int id, params TemplateAlarm[] alarms)
    {
        var t = new Template($"T{id}") { Id = id };
        foreach (var a in alarms)
        {
            a.TemplateId = id;
            t.Alarms.Add(a);
        }
        return t;
    }

    /// <summary>Verifies that overriding a non-existent alarm returns a failure.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task SetAlarmOverride_NonExistentAlarm_ReturnsFailure()
    {
        var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.GetAllTemplatesForAnalysisAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<Template>
            {
                TemplateWithAlarms(1, new TemplateAlarm("HighTemp") { Id = 10 })
            });

        var result = await _sut.SetAlarmOverrideAsync(1, "Missing", "{}", null, "admin");

        Assert.True(result.IsFailure);
        Assert.Contains("does not exist", result.Error);
        _repoMock.Verify(r => r.AddInstanceAlarmOverrideAsync(
            It.IsAny<InstanceAlarmOverride>(), It.IsAny<CancellationToken>()), Times.Never);
        // Review 2026-10-21 04/P6 + 08/P1: resolving one alarm name needs names and lock
        // flags only — never the tracked, script-bodies-included full template graph.
        _repoMock.Verify(r => r.GetAllTemplatesAsync(It.IsAny<CancellationToken>()), Times.Never);
    }

    /// <summary>Verifies that overriding a locked alarm on a composed template returns a failure.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task SetAlarmOverride_ComposedLockedAlarm_ReturnsFailure()
    {
        // The locked alarm lives in a composed module, so it is NOT a direct
        // alarm of the instance's template — the old code skipped the lock check.
        var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);

        var module = TemplateWithAlarms(2, new TemplateAlarm("Fault") { Id = 20, IsLocked = true });
        var host = new Template("Host") { Id = 1 };
        host.Compositions.Add(new TemplateComposition("Pump") { Id = 1, ComposedTemplateId = 2 });

        _repoMock.Setup(r => r.GetAllTemplatesForAnalysisAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<Template> { host, module });

        var result = await _sut.SetAlarmOverrideAsync(1, "Pump.Fault", "{}", null, "admin");

        Assert.True(result.IsFailure);
        Assert.Contains("locked", result.Error, StringComparison.OrdinalIgnoreCase);
        _repoMock.Verify(r => r.AddInstanceAlarmOverrideAsync(
            It.IsAny<InstanceAlarmOverride>(), It.IsAny<CancellationToken>()), Times.Never);
    }

    /// <summary>Verifies that overriding an unlocked alarm on a composed template returns success.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task SetAlarmOverride_ComposedUnlockedAlarm_ReturnsSuccess()
    {
        var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);

        var module = TemplateWithAlarms(2, new TemplateAlarm("Fault") { Id = 20, IsLocked = false });
        var host = new Template("Host") { Id = 1 };
        host.Compositions.Add(new TemplateComposition("Pump") { Id = 1, ComposedTemplateId = 2 });

        _repoMock.Setup(r => r.GetAllTemplatesForAnalysisAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<Template> { host, module });
        _repoMock.Setup(r => r.GetAlarmOverrideAsync(1, "Pump.Fault", It.IsAny<CancellationToken>()))
            .ReturnsAsync((InstanceAlarmOverride?)null);
        _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        var result = await _sut.SetAlarmOverrideAsync(1, "Pump.Fault", "{}", 2, "admin");

        Assert.True(result.IsSuccess);
        _repoMock.Verify(r => r.AddInstanceAlarmOverrideAsync(
            It.IsAny<InstanceAlarmOverride>(), It.IsAny<CancellationToken>()), Times.Once);
    }

    /// <summary>Verifies that overriding a locked alarm declared directly on the template returns a failure.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task SetAlarmOverride_DirectLockedAlarm_ReturnsFailure()
    {
        var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.GetAllTemplatesForAnalysisAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<Template>
            {
                TemplateWithAlarms(1, new TemplateAlarm("HighTemp") { Id = 10, IsLocked = true })
            });

        var result = await _sut.SetAlarmOverrideAsync(1, "HighTemp", "{}", null, "admin");

        Assert.True(result.IsFailure);
        Assert.Contains("locked", result.Error, StringComparison.OrdinalIgnoreCase);
    }

    /// <summary>Verifies that setting an alarm override stores the MES-reportable override.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task SetAlarmOverrideAsync_StoresIsMesReportableOverride()
    {
        var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.GetAllTemplatesForAnalysisAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<Template>
            {
                TemplateWithAlarms(1, new TemplateAlarm("HighTemp") { Id = 10, IsLocked = false })
            });
        _repoMock.Setup(r => r.GetAlarmOverrideAsync(1, "HighTemp", It.IsAny<CancellationToken>()))
            .ReturnsAsync((InstanceAlarmOverride?)null);
        _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        InstanceAlarmOverride? added = null;
        _repoMock.Setup(r => r.AddInstanceAlarmOverrideAsync(
                It.IsAny<InstanceAlarmOverride>(), It.IsAny<CancellationToken>()))
            .Callback<InstanceAlarmOverride, CancellationToken>((o, _) => added = o);

        var result = await _sut.SetAlarmOverrideAsync(
            1, "HighTemp", "{}", null, "admin", isMesReportableOverride: true);

        Assert.True(result.IsSuccess);
        Assert.NotNull(added);
        Assert.True(added!.IsMesReportableOverride);
        Assert.True(result.Value.IsMesReportableOverride);
    }

    /// <summary>Verifies that a null MES-reportable override clears the existing override.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task SetAlarmOverrideAsync_NullIsMesReportableOverride_ClearsExistingOverride()
    {
        var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.GetAllTemplatesForAnalysisAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<Template>
            {
                TemplateWithAlarms(1, new TemplateAlarm("HighTemp") { Id = 10, IsLocked = false })
            });

        var existingOverride = new InstanceAlarmOverride("HighTemp")
        {
            Id = 5,
            InstanceId = 1,
            IsMesReportableOverride = true
        };
        _repoMock.Setup(r => r.GetAlarmOverrideAsync(1, "HighTemp", It.IsAny<CancellationToken>()))
            .ReturnsAsync(existingOverride);
        _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        var result = await _sut.SetAlarmOverrideAsync(
            1, "HighTemp", "{}", null, "admin", isMesReportableOverride: null);

        Assert.True(result.IsSuccess);
        Assert.Null(existingOverride.IsMesReportableOverride);
        Assert.Null(result.Value.IsMesReportableOverride);
        _repoMock.Verify(r => r.UpdateInstanceAlarmOverrideAsync(
            It.Is<InstanceAlarmOverride>(o => o.IsMesReportableOverride == null),
            It.IsAny<CancellationToken>()), Times.Once);
    }

    /// <summary>Verifies that setting an alarm override updates the MES-reportable override on an existing override.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task SetAlarmOverrideAsync_UpdatesIsMesReportableOverrideOnExisting()
    {
        var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.GetAllTemplatesForAnalysisAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<Template>
            {
                TemplateWithAlarms(1, new TemplateAlarm("HighTemp") { Id = 10, IsLocked = false })
            });

        var existingOverride = new InstanceAlarmOverride("HighTemp")
        {
            Id = 5,
            InstanceId = 1,
            IsMesReportableOverride = null
        };
        _repoMock.Setup(r => r.GetAlarmOverrideAsync(1, "HighTemp", It.IsAny<CancellationToken>()))
            .ReturnsAsync(existingOverride);
        _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        var result = await _sut.SetAlarmOverrideAsync(
            1, "HighTemp", "{}", 3, "admin", isMesReportableOverride: false);

        Assert.True(result.IsSuccess);
        Assert.False(existingOverride.IsMesReportableOverride);
        Assert.Equal(3, existingOverride.PriorityLevelOverride);
    }

    /// <summary>Verifies that enabling an existing instance sets its state to enabled.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task Enable_ExistingInstance_SetsEnabled()
    {
        var instance = new Instance("Inst1") { Id = 1, State = InstanceState.Disabled };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        var result = await _sut.EnableAsync(1, "admin");

        Assert.True(result.IsSuccess);
        Assert.Equal(InstanceState.Enabled, result.Value.State);
    }

    /// <summary>Verifies that disabling an existing instance sets its state to disabled.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task Disable_ExistingInstance_SetsDisabled()
    {
        var instance = new Instance("Inst1") { Id = 1, State = InstanceState.Enabled };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        var result = await _sut.DisableAsync(1, "admin");

        Assert.True(result.IsSuccess);
        Assert.Equal(InstanceState.Disabled, result.Value.State);
    }

    /// <summary>Verifies that a bulk connection-binding assignment succeeds.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task SetConnectionBindings_BulkAssignment_Success()
    {
        var instance = new Instance("Inst1") { Id = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.GetBindingsByInstanceIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<InstanceConnectionBinding>());
        _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        var bindings = new List<ConnectionBinding> { new("Temp", 100), new("Pressure", 200) };
        var result = await _sut.SetConnectionBindingsAsync(1, bindings, "admin");

        Assert.True(result.IsSuccess);
        Assert.Equal(2, result.Value.Count);
        _repoMock.Verify(r => r.AddInstanceConnectionBindingAsync(It.IsAny<InstanceConnectionBinding>(), It.IsAny<CancellationToken>()), Times.Exactly(2));
    }

    // --- ElementDataType stamping on SetAttributeOverrideAsync ---

    /// <summary>Verifies that creating an override for a list attribute stamps the element data type.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task SetAttributeOverride_CreatePath_ListAttribute_StampsElementDataType()
    {
        var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.GetAttributesByTemplateIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<TemplateAttribute>
            {
                new("Tags")
                {
                    IsLocked = false,
                    DataType = DataType.List,
                    ElementDataType = DataType.String
                }
            });
        _repoMock.Setup(r => r.GetOverridesByInstanceIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<InstanceAttributeOverride>()); // no existing override → create path
        _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        InstanceAttributeOverride? captured = null;
        _repoMock.Setup(r => r.AddInstanceAttributeOverrideAsync(It.IsAny<InstanceAttributeOverride>(), It.IsAny<CancellationToken>()))
            .Callback<InstanceAttributeOverride, CancellationToken>((o, _) => captured = o);

        var result = await _sut.SetAttributeOverrideAsync(1, "Tags", "[\"a\"]", "admin");

        Assert.True(result.IsSuccess);
        Assert.NotNull(captured);
        Assert.Equal(DataType.String, captured.ElementDataType);
    }

    /// <summary>Verifies that updating an override for a list attribute stamps the element data type.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task SetAttributeOverride_UpdatePath_ListAttribute_StampsElementDataType()
    {
        var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.GetAttributesByTemplateIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<TemplateAttribute>
            {
                new("Tags")
                {
                    IsLocked = false,
                    DataType = DataType.List,
                    ElementDataType = DataType.String
                }
            });

        var existingOverride = new InstanceAttributeOverride("Tags") { Id = 42, InstanceId = 1, OverrideValue = "[\"old\"]" };
        _repoMock.Setup(r => r.GetOverridesByInstanceIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<InstanceAttributeOverride> { existingOverride }); // pre-existing → update path
        _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        InstanceAttributeOverride? captured = null;
        _repoMock.Setup(r => r.UpdateInstanceAttributeOverrideAsync(It.IsAny<InstanceAttributeOverride>(), It.IsAny<CancellationToken>()))
            .Callback<InstanceAttributeOverride, CancellationToken>((o, _) => captured = o);

        var result = await _sut.SetAttributeOverrideAsync(1, "Tags", "[\"new\"]", "admin");

        Assert.True(result.IsSuccess);
        Assert.NotNull(captured);
        Assert.Equal(DataType.String, captured.ElementDataType);
    }

    /// <summary>Verifies that creating an override for a scalar attribute leaves the element data type null.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task SetAttributeOverride_CreatePath_ScalarAttribute_ElementDataTypeIsNull()
    {
        var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.GetAttributesByTemplateIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<TemplateAttribute>
            {
                new("Threshold")
                {
                    IsLocked = false,
                    DataType = DataType.Float,
                    ElementDataType = null
                }
            });
        _repoMock.Setup(r => r.GetOverridesByInstanceIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<InstanceAttributeOverride>());
        _repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        InstanceAttributeOverride? captured = null;
        _repoMock.Setup(r => r.AddInstanceAttributeOverrideAsync(It.IsAny<InstanceAttributeOverride>(), It.IsAny<CancellationToken>()))
            .Callback<InstanceAttributeOverride, CancellationToken>((o, _) => captured = o);

        var result = await _sut.SetAttributeOverrideAsync(1, "Threshold", "3.14", "admin");

        Assert.True(result.IsSuccess);
        Assert.NotNull(captured);
        Assert.Null(captured.ElementDataType);
    }

    /// <summary>Verifies that assigning an instance to an area in a different site returns a failure.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    [Fact]
    public async Task AssignToArea_AreaInDifferentSite_ReturnsFailure()
    {
        var instance = new Instance("Inst1") { Id = 1, SiteId = 1 };
        _repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
            .ReturnsAsync(instance);
        _repoMock.Setup(r => r.GetAreaByIdAsync(5, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new Area("WrongSiteArea") { Id = 5, SiteId = 99 });

        var result = await _sut.AssignToAreaAsync(1, 5, "admin");

        Assert.True(result.IsFailure);
        Assert.Contains("does not belong", result.Error);
    }
}