AutoMiningScript

using System;
using System.Linq;
using VRage.Game.ModAPI.Ingame.Utilities;
using Xunit;
using P = AutoMiningScript.Program;
using Rig = AutoMiningScript.Tests.FleetStateTests.Rig;

namespace AutoMiningScript.Tests
{
    public class FleetOperatorTests
    {
        static string Text(P.Packet packet) { return packet.Body.Get("command", "Text").ToString(); }

        [Theory]
        [InlineData("init", "rescan")]
        [InlineData("rescan", "rescan")]
        [InlineData("diagnose", "diagnose")]
        [InlineData("calibrate", "calibrate")]
        [InlineData("start", "resume")]
        [InlineData("resume", "resume")]
        [InlineData("pause", "pause")]
        [InlineData("return", "return")]
        [InlineData("release", "release")]
        public void FleetCanTargetEachOriginalMinerCommand(string command, string expected)
        {
            var rig = new Rig(2, true); rig.RegisterAll(); rig.Sent.Clear();
            rig.Fleet.Command(command + " miner-1");
            var sent = Assert.Single(rig.Sent, p => p.Kind == "COMMAND");
            Assert.Equal("miner-1", sent.Target); Assert.Equal(expected, Text(sent));
        }

        [Theory]
        [InlineData("init")]
        [InlineData("rescan")]
        [InlineData("diagnose")]
        [InlineData("calibrate")]
        [InlineData("start")]
        [InlineData("resume")]
        [InlineData("pause")]
        [InlineData("return")]
        [InlineData("release")]
        public void ExplicitAllCanOperateEveryOnlineMiner(string command)
        {
            var rig = new Rig(3, true); rig.RegisterAll(); rig.Program.Now = 6;
            rig.Receive("TELEMETRY", rig.Miners[0]); rig.Receive("TELEMETRY", rig.Miners[2]); rig.Sent.Clear();
            rig.Fleet.Command(command + " all");
            Assert.Equal(new[] { "miner-0", "miner-2" }, rig.Sent.Where(p => p.Kind == "COMMAND").Select(p => p.Target).ToArray());
        }

        [Fact]
        public void TargetNamesWithSpacesAndOptionalQuotesRemainExact()
        {
            var rig = new Rig(1, true); rig.Miners[0].Id = "Deep Space Miner 1"; rig.RegisterAll();
            rig.Fleet.Command("return Deep Space Miner 1"); rig.Fleet.Command("diagnose \"Deep Space Miner 1\"");
            Assert.Equal(2, rig.Sent.Count(p => p.Kind == "COMMAND" && p.Target == "Deep Space Miner 1"));
        }

        [Fact]
        public void LocalDiagnoseKeepsItsOriginalMeaningWhileNoTargetCalibrationBroadcasts()
        {
            var rig = new Rig(2, true); rig.RegisterAll(); rig.Fleet.Command("diagnose");
            Assert.DoesNotContain(rig.Sent, p => p.Kind == "COMMAND");
            rig.Fleet.Command("calibrate"); Assert.Equal(2, rig.Sent.Count(p => p.Kind == "COMMAND" && Text(p) == "calibrate"));
        }

        [Fact]
        public void StartResumesCancellationReturnWithoutAssigningAReplacementBeforeDocking()
        {
            var rig = new Rig(1, false); rig.RegisterAll(); rig.Fleet.Command("clear-tasks");
            rig.Fleet.Command("mark 6 6 20 GPS:entry:0:0:-200: GPS:inward:0:0:-201:");
            rig.Sent.Clear(); rig.Fleet.Command("start"); rig.Tick(10);
            Assert.Contains(rig.Sent, p => p.Kind == "COMMAND" && Text(p) == "return");
            Assert.DoesNotContain(rig.Sent, p => p.Kind == "JOB"); Assert.Equal(1, rig.Fleet.CancellationCount);
            rig.Miners[0].CancelledThrough = P.Data.ReadLong(rig.Save(), "fleet", "CancelledThrough");
            rig.SetConnected(0, true); rig.Receive("TELEMETRY", rig.Miners[0]);
            Assert.Equal(0, rig.Fleet.CancellationCount);
            Assert.Contains(rig.Sent, p => p.Kind == "COMMAND" && Text(p) == "resume");
        }

        [Fact]
        public void TargetedPauseSurvivesCheckpointAndCancellationConfirmationWithoutAutoResume()
        {
            var before = new Rig(2, false); before.RegisterAll(); before.Fleet.Command("clear-tasks");
            before.Fleet.Command("start"); before.Fleet.Command("pause miner-0");
            var after = new Rig(2, true); after.Restore(before.Checkpoint());
            long watermark = P.Data.ReadLong(after.Save(), "fleet", "CancelledThrough");
            after.Miners[0].CancelledThrough = watermark; after.Miners[1].CancelledThrough = watermark;
            after.RegisterAll();
            Assert.DoesNotContain(after.Sent, p => p.Kind == "COMMAND" && p.Target == "miner-0" && Text(p) == "resume");
            Assert.Contains(after.Sent, p => p.Kind == "COMMAND" && p.Target == "miner-1" && Text(p) == "resume");
        }

        [Theory]
        [InlineData("pause")]
        [InlineData("return")]
        [InlineData("release")]
        public void TargetedStopPreventsNewJobsDespiteStaleServicingTelemetry(string command)
        {
            var rig = new Rig(2, true); rig.RegisterAll(); rig.Fleet.Command("start"); rig.Fleet.Command(command + " miner-0");
            rig.Fleet.Command("mark 30 6 20 GPS:entry:0:0:-200: GPS:inward:0:0:-201:"); rig.Tick(20);
            Assert.DoesNotContain(rig.Fleet.GetJobs(), j => j.Owner == "miner-0");
            Assert.Contains(rig.Fleet.GetJobs(), j => j.Owner == "miner-1");
            rig.Fleet.Command("resume miner-0"); rig.Tick(20);
            Assert.Contains(rig.Fleet.GetJobs(), j => j.Owner == "miner-0");
        }

        [Fact]
        public void TargetedStartDoesNotStartOtherShipsInAPausedFleet()
        {
            var rig = new Rig(2, true); rig.RegisterAll(); rig.Fleet.Command("mark 30 6 20 GPS:entry:0:0:-200: GPS:inward:0:0:-201:");
            rig.Fleet.Command("start miner-1"); rig.Tick(20);
            Assert.Single(rig.Fleet.GetJobs(), j => j.Owner.Length > 0); Assert.Contains(rig.Fleet.GetJobs(), j => j.Owner == "miner-1");
            Assert.DoesNotContain(rig.Sent, p => p.Kind == "COMMAND" && p.Target == "miner-0");
        }

        [Fact]
        public void UnknownTargetDoesNotChangeTheFleetRunningSwitch()
        {
            var rig = new Rig(0, true); Assert.Throws<ArgumentException>(() => rig.Fleet.Command("start absent miner"));
            Assert.False(rig.Save().Get("fleet", "Running").ToBoolean());
        }

        [Fact]
        public void RemoteDiagnosticsRequiresTheRegisteredPhysicalSender()
        {
            var rig = new Rig(1, true); rig.RegisterAll(); var body = new MyIni(); body.Set("diagnostics", "Text", "flight clearance zero");
            rig.Fleet.Receive(new P.Packet { Kind = "DIAGNOSTICS", From = "miner-0", Source = 55, Body = body });
            Assert.DoesNotContain("flight clearance zero", rig.Fleet.Diagnostics);
            rig.Fleet.Receive(new P.Packet { Kind = "DIAGNOSTICS", From = "miner-0", Source = 5000, Body = body });
            Assert.Contains("miner-0\nflight clearance zero", rig.Fleet.Diagnostics);
        }

        [Fact]
        public void ClearingOfflineStoppedMinersDoesNotLeaveStaleOperatorFlags()
        {
            var rig = new Rig(1, false); rig.RegisterAll(); rig.Fleet.Command("pause miner-0");
            rig.Checkpoint(); rig.Program.Now = 6; rig.Fleet.Command("clear-offline");
            var restored = new Rig(1, false); restored.Restore(rig.Program.Storage);
            Assert.Equal(0, P.Data.ReadLong(restored.Save(), "fleet", "OperatorStopCount"));
        }
    }
}