using Shouldly;
using Xunit;
using ZB.MOM.WW.LmxOpcUa.Host.Domain;

namespace ZB.MOM.WW.LmxOpcUa.Tests.Domain
{
    /// <summary>
    /// Verifies the mapping between MXAccess quality codes, bridge quality values, and OPC UA status codes.
    /// </summary>
    public class QualityMapperTests
    {
        /// <summary>
        /// Confirms that bad-family MXAccess quality values map to the expected bridge quality values.
        /// </summary>
        /// <param name="input">The raw MXAccess quality code.</param>
        /// <param name="expected">The bridge quality value expected for the code.</param>
        [Theory]
        [InlineData(0, Quality.Bad)]
        [InlineData(4, Quality.BadConfigError)]
        [InlineData(20, Quality.BadCommFailure)]
        [InlineData(32, Quality.BadWaitingForInitialData)]
        public void MapFromMxAccess_BadFamily(int input, Quality expected)
        {
            QualityMapper.MapFromMxAccessQuality(input).ShouldBe(expected);
        }

        /// <summary>
        /// Confirms that uncertain-family MXAccess quality values map to the expected bridge quality values.
        /// </summary>
        /// <param name="input">The raw MXAccess quality code.</param>
        /// <param name="expected">The bridge quality value expected for the code.</param>
        [Theory]
        [InlineData(64, Quality.Uncertain)]
        [InlineData(68, Quality.UncertainLastUsable)]
        [InlineData(88, Quality.UncertainSubNormal)]
        public void MapFromMxAccess_UncertainFamily(int input, Quality expected)
        {
            QualityMapper.MapFromMxAccessQuality(input).ShouldBe(expected);
        }

        /// <summary>
        /// Confirms that good-family MXAccess quality values map to the expected bridge quality values.
        /// </summary>
        /// <param name="input">The raw MXAccess quality code.</param>
        /// <param name="expected">The bridge quality value expected for the code.</param>
        [Theory]
        [InlineData(192, Quality.Good)]
        [InlineData(216, Quality.GoodLocalOverride)]
        public void MapFromMxAccess_GoodFamily(int input, Quality expected)
        {
            QualityMapper.MapFromMxAccessQuality(input).ShouldBe(expected);
        }

        /// <summary>
        /// Confirms that unknown bad-family values collapse to the generic bad quality bucket.
        /// </summary>
        [Fact]
        public void MapFromMxAccess_UnknownBadValue_ReturnsBad()
        {
            QualityMapper.MapFromMxAccessQuality(63).ShouldBe(Quality.Bad);
        }

        /// <summary>
        /// Confirms that unknown uncertain-family values collapse to the generic uncertain quality bucket.
        /// </summary>
        [Fact]
        public void MapFromMxAccess_UnknownUncertainValue_ReturnsUncertain()
        {
            QualityMapper.MapFromMxAccessQuality(100).ShouldBe(Quality.Uncertain);
        }

        /// <summary>
        /// Confirms that unknown good-family values collapse to the generic good quality bucket.
        /// </summary>
        [Fact]
        public void MapFromMxAccess_UnknownGoodValue_ReturnsGood()
        {
            QualityMapper.MapFromMxAccessQuality(200).ShouldBe(Quality.Good);
        }

        /// <summary>
        /// Confirms that the generic good quality maps to the OPC UA good status code.
        /// </summary>
        [Fact]
        public void MapToOpcUa_Good_Returns0()
        {
            QualityMapper.MapToOpcUaStatusCode(Quality.Good).ShouldBe(0x00000000u);
        }

        /// <summary>
        /// Confirms that the generic bad quality maps to the OPC UA bad status code.
        /// </summary>
        [Fact]
        public void MapToOpcUa_Bad_Returns80000000()
        {
            QualityMapper.MapToOpcUaStatusCode(Quality.Bad).ShouldBe(0x80000000u);
        }

        /// <summary>
        /// Confirms that communication failures map to the OPC UA bad communication-failure status code.
        /// </summary>
        [Fact]
        public void MapToOpcUa_BadCommFailure()
        {
            QualityMapper.MapToOpcUaStatusCode(Quality.BadCommFailure).ShouldBe(0x80050000u);
        }

        /// <summary>
        /// Confirms that the generic uncertain quality maps to the OPC UA uncertain status code.
        /// </summary>
        [Fact]
        public void MapToOpcUa_Uncertain()
        {
            QualityMapper.MapToOpcUaStatusCode(Quality.Uncertain).ShouldBe(0x40000000u);
        }

        /// <summary>
        /// Confirms that good quality values are classified correctly by the quality extension helpers.
        /// </summary>
        [Fact]
        public void QualityExtensions_IsGood()
        {
            Quality.Good.IsGood().ShouldBe(true);
            Quality.Good.IsBad().ShouldBe(false);
            Quality.Good.IsUncertain().ShouldBe(false);
        }

        /// <summary>
        /// Confirms that bad quality values are classified correctly by the quality extension helpers.
        /// </summary>
        [Fact]
        public void QualityExtensions_IsBad()
        {
            Quality.Bad.IsBad().ShouldBe(true);
            Quality.Bad.IsGood().ShouldBe(false);
        }

        /// <summary>
        /// Confirms that uncertain quality values are classified correctly by the quality extension helpers.
        /// </summary>
        [Fact]
        public void QualityExtensions_IsUncertain()
        {
            Quality.Uncertain.IsUncertain().ShouldBe(true);
            Quality.Uncertain.IsGood().ShouldBe(false);
            Quality.Uncertain.IsBad().ShouldBe(false);
        }
    }
}