ThreatSourceLibaray/ThreatSource.Tests/src/Indicator/LaserDesignatorCodeTests.cs

using Xunit;
using ThreatSource.Indicator;
using ThreatSource.Simulation;
using ThreatSource.Utils;
using ThreatSource.Simulation.Testing;
using ThreatSource.Target;

namespace ThreatSource.Tests.Indicator
{
    public class LaserDesignatorCodeTests
    {
        private readonly SimulationManager _simulationManager;
        private readonly TestSimulationAdapter _testAdapter;
        private readonly LaserDesignator _laserDesignator;
        private readonly LaserDesignatorConfig _config;
        private readonly Tank _tank;

        public LaserDesignatorCodeTests()
        {
            _simulationManager = new SimulationManager();
            _testAdapter = new TestSimulationAdapter(_simulationManager);
            _simulationManager.SetSimulationAdapter(_testAdapter);
            
            _config = new LaserDesignatorConfig
            {
                Id = "laser1",
                InitialPosition = new Vector3D(0, 0, 0),
                LaserPower = 1000,
                LaserDivergenceAngle = 0.001
            };

            _tank = new Tank("target1", new Vector3D(100, 0, 0), 0, _simulationManager);
            _simulationManager.RegisterEntity("target1", _tank);

            _laserDesignator = new LaserDesignator(
                "laser1", 
                "target1", 
                "missile1",
                10,
                _config, 
                _simulationManager
            );
            _simulationManager.RegisterEntity("laser1", _laserDesignator);
        }

        [Fact]
        public void SetLaserCode_SetsCodeCorrectly()
        {
            // Arrange
            _laserDesignator.Activate();

            // Act
            _laserDesignator.SetLaserCode(LaserCodeType.PRF, 1234);
            _laserDesignator.Update(0.1);

            // Assert
            var events = _testAdapter.GetPublishedEvents<LaserIlluminationUpdateEvent>();
            Assert.NotEmpty(events);
            
            var lastEvent = events[events.Count - 1];
            Assert.True(lastEvent.IsCodeEnabled);
            Assert.NotNull(lastEvent.LaserCode);
            Assert.Equal(LaserCodeType.PRF, lastEvent.LaserCode.CodeType);
            Assert.Equal(1234, lastEvent.LaserCode.CodeValue);
        }

        [Fact]
        public void AddCodeParameter_AddsParameterCorrectly()
        {
            // Arrange
            _laserDesignator.Activate();
            _laserDesignator.SetLaserCode(LaserCodeType.PPM, 5678);

            // Act
            _laserDesignator.AddCodeParameter("PulseWidth", 0.001);
            _laserDesignator.Update(0.1);

            // Assert
            var events = _testAdapter.GetPublishedEvents<LaserIlluminationUpdateEvent>();
            Assert.NotEmpty(events);
            
            var lastEvent = events[events.Count - 1];
            Assert.True(lastEvent.IsCodeEnabled);
            Assert.NotNull(lastEvent.LaserCode);
            Assert.Equal(LaserCodeType.PPM, lastEvent.LaserCode.CodeType);
            Assert.Equal(5678, lastEvent.LaserCode.CodeValue);
            Assert.True(lastEvent.LaserCode.Parameters.ContainsKey("PulseWidth"));
            Assert.Equal(0.001, lastEvent.LaserCode.Parameters["PulseWidth"]);
        }

        [Fact]
        public void EnableCode_EnablesAndDisablesCodeCorrectly()
        {
            // Arrange
            _laserDesignator.Activate();
            _laserDesignator.SetLaserCode(LaserCodeType.PRF, 1234);
            
            // Act - Disable code
            _laserDesignator.EnableCode(false);
            _laserDesignator.Update(0.1);
            
            // Assert - Code should be disabled
            var eventsAfterDisable = _testAdapter.GetPublishedEvents<LaserIlluminationUpdateEvent>();
            Assert.NotEmpty(eventsAfterDisable);
            var lastEventAfterDisable = eventsAfterDisable[eventsAfterDisable.Count - 1];
            Assert.False(lastEventAfterDisable.IsCodeEnabled);
            
            // Act - Enable code again
            _laserDesignator.EnableCode(true);
            _laserDesignator.Update(0.1);
            
            // Assert - Code should be enabled
            var eventsAfterEnable = _testAdapter.GetPublishedEvents<LaserIlluminationUpdateEvent>();
            Assert.NotEmpty(eventsAfterEnable);
            var lastEventAfterEnable = eventsAfterEnable[eventsAfterEnable.Count - 1];
            Assert.True(lastEventAfterEnable.IsCodeEnabled);
        }

        [Fact]
        public void LaserIlluminationEvents_IncludeCodeInformation()
        {
            // Arrange
            _laserDesignator.SetLaserCode(LaserCodeType.PRF, 1234);
            
            // Act - Start illumination
            _laserDesignator.Activate();
            
            // Assert - Start event should include code
            var startEvents = _testAdapter.GetPublishedEvents<LaserIlluminationStartEvent>();
            Assert.NotEmpty(startEvents);
            var startEvent = startEvents[startEvents.Count - 1];
            Assert.True(startEvent.IsCodeEnabled);
            Assert.NotNull(startEvent.LaserCode);
            Assert.Equal(LaserCodeType.PRF, startEvent.LaserCode.CodeType);
            Assert.Equal(1234, startEvent.LaserCode.CodeValue);
            
            // Act - Update illumination
            _laserDesignator.Update(0.1);
            
            // Assert - Update event should include code
            var updateEvents = _testAdapter.GetPublishedEvents<LaserIlluminationUpdateEvent>();
            Assert.NotEmpty(updateEvents);
            var updateEvent = updateEvents[updateEvents.Count - 1];
            Assert.True(updateEvent.IsCodeEnabled);
            Assert.NotNull(updateEvent.LaserCode);
            Assert.Equal(LaserCodeType.PRF, updateEvent.LaserCode.CodeType);
            Assert.Equal(1234, updateEvent.LaserCode.CodeValue);
        }
    }
}