using ZB.MOM.WW.ScadaBridge.Commons.Types.Flattening;
using ZB.MOM.WW.ScadaBridge.TemplateEngine.Validation;

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

public class ValidationServiceTests
{
    private readonly ValidationService _sut = new();

    [Fact]
    public void Validate_ValidConfig_ReturnsSuccess()
    {
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Attributes = [new ResolvedAttribute { CanonicalName = "Temp", Value = "25", DataType = "Double" }],
            Scripts = [new ResolvedScript { CanonicalName = "Monitor", Code = "var x = 1;" }]
        };

        var result = _sut.Validate(config);
        Assert.True(result.IsValid);
    }

    [Fact]
    public void Validate_EmptyInstanceName_ReturnsError()
    {
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "",
            Attributes = [new ResolvedAttribute { CanonicalName = "Temp", DataType = "Double" }]
        };

        var result = _sut.Validate(config);
        Assert.False(result.IsValid);
        Assert.Contains(result.Errors, e => e.Category == ValidationCategory.FlatteningFailure);
    }

    [Fact]
    public void Validate_NamingCollision_ReturnsError()
    {
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Attributes =
            [
                new ResolvedAttribute { CanonicalName = "Temp", DataType = "Double" },
                new ResolvedAttribute { CanonicalName = "Temp", DataType = "Int32" } // Duplicate!
            ]
        };

        var result = _sut.Validate(config);
        Assert.False(result.IsValid);
        Assert.Contains(result.Errors, e => e.Category == ValidationCategory.NamingCollision);
    }

    [Fact]
    public void Validate_ForbiddenApi_ReturnsCompilationError()
    {
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Scripts =
            [
                new ResolvedScript
                {
                    CanonicalName = "BadScript",
                    Code = "System.IO.File.ReadAllText(\"secret.txt\");"
                }
            ]
        };

        var result = _sut.Validate(config);
        Assert.False(result.IsValid);
        Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ScriptCompilation);
    }

    [Fact]
    public void Validate_MismatchedBraces_ReturnsCompilationError()
    {
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Scripts =
            [
                new ResolvedScript { CanonicalName = "Bad", Code = "if (true) {" }
            ]
        };

        var result = _sut.Validate(config);
        Assert.False(result.IsValid);
        Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ScriptCompilation);
    }

    [Fact]
    public void Validate_AlarmReferencesMissingAttribute_ReturnsError()
    {
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Attributes = [new ResolvedAttribute { CanonicalName = "Temp", DataType = "Double" }],
            Alarms =
            [
                new ResolvedAlarm
                {
                    CanonicalName = "HighPressure",
                    TriggerType = "RangeViolation",
                    TriggerConfiguration = "{\"attributeName\":\"Pressure\"}" // Pressure doesn't exist
                }
            ]
        };

        var result = _sut.Validate(config);
        Assert.False(result.IsValid);
        Assert.Contains(result.Errors, e => e.Category == ValidationCategory.AlarmTriggerReference);
    }

    [Fact]
    public void Validate_AlarmReferencesExistingAttribute_NoError()
    {
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Attributes = [new ResolvedAttribute { CanonicalName = "Temp", DataType = "Double" }],
            Alarms =
            [
                new ResolvedAlarm
                {
                    CanonicalName = "HighTemp",
                    TriggerType = "RangeViolation",
                    TriggerConfiguration = "{\"attributeName\":\"Temp\"}"
                }
            ]
        };

        var result = _sut.Validate(config);
        // Should not have alarm trigger reference errors
        Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.AlarmTriggerReference);
    }

    [Fact]
    public void Validate_ScriptTriggerReferencesMissingAttribute_ReturnsError()
    {
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Attributes = [new ResolvedAttribute { CanonicalName = "Temp", DataType = "Double" }],
            Scripts =
            [
                new ResolvedScript
                {
                    CanonicalName = "OnChange",
                    Code = "var x = 1;",
                    TriggerConfiguration = "{\"attributeName\":\"Missing\"}"
                }
            ]
        };

        var result = _sut.Validate(config);
        Assert.False(result.IsValid);
        Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ScriptTriggerReference);
    }

    [Fact]
    public void Validate_UnboundDataSourceAttribute_DesignTime_ReturnsWarningNotError()
    {
        // M2.8 (#23): at template design time (the default, enforceConnectionBindings:false)
        // a data-sourced attribute is legitimately unbound — bindings are set later at
        // instance/deploy time. So this must stay a non-blocking WARNING and IsValid true.
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Attributes =
            [
                new ResolvedAttribute
                {
                    CanonicalName = "Temp",
                    DataType = "Double",
                    DataSourceReference = "ns=2;s=Temp",
                    BoundDataConnectionId = null // No binding!
                }
            ]
        };

        var result = _sut.Validate(config);
        Assert.Contains(result.Warnings, w => w.Category == ValidationCategory.ConnectionBinding);
        Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ConnectionBinding);
        Assert.True(result.IsValid);
    }

    [Fact]
    public void Validate_UnboundDataSourceAttribute_DeployTime_ReturnsErrorAndBlocks()
    {
        // M2.8 (#23): the deploy path opts in (enforceConnectionBindings:true). A data-sourced
        // attribute with no binding now gates the deployment as an ERROR (IsValid false).
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Attributes =
            [
                new ResolvedAttribute
                {
                    CanonicalName = "Temp",
                    DataType = "Double",
                    DataSourceReference = "ns=2;s=Temp",
                    BoundDataConnectionId = null // No binding!
                }
            ]
        };

        var result = _sut.Validate(config, enforceConnectionBindings: true);
        Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ConnectionBinding);
        Assert.False(result.IsValid);
    }

    [Fact]
    public void Validate_StaticAttributeWithoutBinding_DeployTime_NoBindingError()
    {
        // M2.8 (#23): only DATA-SOURCED attributes require a binding. A static attribute
        // (DataSourceReference == null) must remain OK even under deploy-time enforcement.
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Attributes =
            [
                new ResolvedAttribute
                {
                    CanonicalName = "Setpoint",
                    DataType = "Double",
                    Value = "42",
                    DataSourceReference = null,
                    BoundDataConnectionId = null
                }
            ]
        };

        var result = _sut.Validate(config, enforceConnectionBindings: true);
        Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ConnectionBinding);
        Assert.True(result.IsValid);
    }

    [Fact]
    public void Validate_BoundToExistingSiteConnection_DeployTime_NoBindingError()
    {
        // M2.8 (#23): a data-sourced attribute bound to a connection that exists at the
        // target site passes the binding gate.
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Attributes =
            [
                new ResolvedAttribute
                {
                    CanonicalName = "Temp",
                    DataType = "Double",
                    DataSourceReference = "ns=2;s=Temp",
                    BoundDataConnectionId = 7,
                    BoundDataConnectionName = "PlantBus"
                }
            ]
        };

        var result = _sut.Validate(
            config,
            enforceConnectionBindings: true,
            siteConnectionNames: new HashSet<string>(StringComparer.Ordinal) { "PlantBus" });

        Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ConnectionBinding);
        Assert.True(result.IsValid);
    }

    [Fact]
    public void Validate_BoundToNonExistentSiteConnection_DeployTime_ReturnsError()
    {
        // M2.8 (#23): a binding pointing at a connection that does NOT exist on the
        // target site is an ERROR that blocks deployment.
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Attributes =
            [
                new ResolvedAttribute
                {
                    CanonicalName = "Temp",
                    DataType = "Double",
                    DataSourceReference = "ns=2;s=Temp",
                    BoundDataConnectionId = 99,
                    BoundDataConnectionName = "GhostBus"
                }
            ]
        };

        var result = _sut.Validate(
            config,
            enforceConnectionBindings: true,
            siteConnectionNames: new HashSet<string>(StringComparer.Ordinal) { "PlantBus" });

        Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ConnectionBinding);
        Assert.False(result.IsValid);
    }

    [Fact]
    public void Validate_BoundAttributeWithNoSiteSet_DeployTime_ExistsAtSiteCheckIsInert()
    {
        // M2.8 (#23): when siteConnectionNames is null the "exists at site" half of the
        // binding check stays inert — a properly-bound data-sourced attribute must NOT
        // produce a ConnectionBinding error, even under deploy-time enforcement.
        // This pins the contract: passing enforce:true + siteConnectionNames:null is safe
        // (e.g. when the caller doesn't have a site connection set available yet).
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Attributes =
            [
                new ResolvedAttribute
                {
                    CanonicalName = "Temp",
                    DataType = "Double",
                    DataSourceReference = "ns=2;s=Temp",
                    BoundDataConnectionId = 7,
                    BoundDataConnectionName = "PlantBus"
                }
            ]
        };

        var result = _sut.Validate(config, enforceConnectionBindings: true, siteConnectionNames: null);

        Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ConnectionBinding);
        Assert.True(result.IsValid);
    }

    [Fact]
    public void Validate_EmptyConfig_ReturnsWarning()
    {
        var config = new FlattenedConfiguration { InstanceUniqueName = "Instance1" };

        var result = _sut.Validate(config);
        Assert.Contains(result.Warnings, w => w.Category == ValidationCategory.FlatteningFailure);
    }

    // --- M9-T28a: per-trigger AnalysisKind (Advisory default | Strict escalates) ---
    // The only currently-advisory finding in CheckExpressionTrigger is the blank/empty
    // expression (which "will never fire"). Advisory keeps it a non-blocking warning;
    // Strict promotes it to a deploy-blocking error. The kind rides the existing
    // trigger-config JSON ({"expression":"...","analysisKind":"Strict"}) — no migration.

    [Fact]
    public void Validate_ExpressionTrigger_BlankExpression_AdvisoryDefault_WarnsButPasses()
    {
        // No analysisKind in the config → Advisory (today's behavior): a blank expression
        // is a non-blocking warning, validation still passes.
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Alarms =
            [
                new ResolvedAlarm
                {
                    CanonicalName = "BlankAlarm",
                    TriggerType = "Expression",
                    TriggerConfiguration = "{\"expression\":\"\"}"
                }
            ]
        };

        var result = _sut.Validate(config);
        Assert.Contains(result.Warnings, w => w.Category == ValidationCategory.AlarmTriggerReference);
        Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.AlarmTriggerReference);
        Assert.True(result.IsValid);
    }

    [Fact]
    public void Validate_ExpressionTrigger_BlankExpression_StrictKind_FailsWithError()
    {
        // analysisKind:"Strict" promotes the blank-expression advisory to a deploy-blocking error.
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Alarms =
            [
                new ResolvedAlarm
                {
                    CanonicalName = "BlankAlarm",
                    TriggerType = "Expression",
                    TriggerConfiguration = "{\"expression\":\"\",\"analysisKind\":\"Strict\"}"
                }
            ]
        };

        var result = _sut.Validate(config);
        Assert.Contains(result.Errors, e => e.Category == ValidationCategory.AlarmTriggerReference);
        Assert.DoesNotContain(result.Warnings, w => w.Category == ValidationCategory.AlarmTriggerReference);
        Assert.False(result.IsValid);
    }

    [Fact]
    public void Validate_ScriptExpressionTrigger_BlankExpression_StrictKind_FailsWithError()
    {
        // Strict escalation also applies to script expression triggers (mirrors the alarm path).
        var config = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Scripts =
            [
                new ResolvedScript
                {
                    CanonicalName = "BlankScript",
                    Code = "var x = 1;",
                    TriggerType = "Expression",
                    TriggerConfiguration = "{\"expression\":\"   \",\"analysisKind\":\"Strict\"}"
                }
            ]
        };

        var result = _sut.Validate(config);
        Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ScriptTriggerReference);
        Assert.False(result.IsValid);
    }

    [Fact]
    public void Validate_ExpressionTrigger_ValidExpression_PassesUnderBothKinds()
    {
        // A genuinely valid expression must pass clean under Advisory AND Strict —
        // Strict only escalates the currently-advisory findings, it does not invent new ones.
        var attributes = new[]
        {
            new ResolvedAttribute { CanonicalName = "Temp", Value = "25", DataType = "Double" }
        };

        var advisory = new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Attributes = attributes,
            Alarms =
            [
                new ResolvedAlarm
                {
                    CanonicalName = "HighTemp",
                    TriggerType = "Expression",
                    TriggerConfiguration = "{\"expression\":\"(double)Attributes[\\\"Temp\\\"] > 50\"}"
                }
            ]
        };

        var strict = advisory with
        {
            Alarms =
            [
                new ResolvedAlarm
                {
                    CanonicalName = "HighTemp",
                    TriggerType = "Expression",
                    TriggerConfiguration = "{\"expression\":\"(double)Attributes[\\\"Temp\\\"] > 50\",\"analysisKind\":\"Strict\"}"
                }
            ]
        };

        var advisoryResult = _sut.Validate(advisory);
        var strictResult = _sut.Validate(strict);

        Assert.DoesNotContain(advisoryResult.Errors, e => e.Category == ValidationCategory.AlarmTriggerReference);
        Assert.DoesNotContain(advisoryResult.Warnings, w => w.Category == ValidationCategory.AlarmTriggerReference);
        Assert.DoesNotContain(strictResult.Errors, e => e.Category == ValidationCategory.AlarmTriggerReference);
        Assert.DoesNotContain(strictResult.Warnings, w => w.Category == ValidationCategory.AlarmTriggerReference);
    }

    [Fact]
    public void Validate_SkipCompilation_SkipsExpressionTriggerSyntaxCheck()
    {
        var config = ConfigWithExpressionTriggerScript("this is not C# ((");
        var gated = new ValidationService().Validate(config, validateScriptCompilation: false);
        Assert.DoesNotContain(gated.Errors, e => e.Message.Contains("failed validation"));  // FAILS today
        var full = new ValidationService().Validate(config);
        Assert.Contains(full.Errors, e => e.Message.Contains("failed validation"));         // deploy gate unchanged
    }

    [Fact]
    public void Validate_SkipCompilation_StillChecksExpressionAttributeReferences()
    {
        // expression "Attributes[\"Ghost\"] != null" referencing a missing attribute:
        // the reference scan is cheap string work and MUST survive the gate.
        var config = ConfigWithExpressionTriggerScript("Attributes[\"Ghost\"] != null");
        var gated = new ValidationService().Validate(config, validateScriptCompilation: false);
        Assert.Contains(gated.Errors, e => e.Message.Contains("Ghost"));
    }

    private static FlattenedConfiguration ConfigWithExpressionTriggerScript(string expression)
    {
        var json = System.Text.Json.JsonSerializer.Serialize(new { expression });
        return new FlattenedConfiguration
        {
            InstanceUniqueName = "Instance1",
            Attributes = [new ResolvedAttribute { CanonicalName = "Temp", Value = "25", DataType = "Double" }],
            Scripts =
            [
                new ResolvedScript
                {
                    CanonicalName = "OnExpr",
                    TriggerType = "Expression",
                    TriggerConfiguration = json
                }
            ]
        };
    }
}
