package com.ruoyi.device.contract;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.math.BigDecimal;
import java.time.Duration;
import java.time.Instant;
import java.time.ZoneId;
import java.util.List;
import java.util.Set;
import org.junit.jupiter.api.Test;
import com.ruoyi.device.api.DeviceAdapter;
import com.ruoyi.device.bts.BtsDevelopmentSimulator;
import com.ruoyi.device.bts.BtsDeviceAdapter;
import com.ruoyi.device.bts.BtsXmlCodec;
import com.ruoyi.device.bts.BtsTcpTransport;
import com.ruoyi.device.bts.ScriptedBtsTcpSimulator;
import com.ruoyi.device.model.DetectedChannel;
import com.ruoyi.device.model.DeviceWorkStatus;
import com.ruoyi.device.simulator.BtsSimulatorStateStore;
import com.ruoyi.device.simulator.BtsSimulatorStateStore.ChannelState;
import com.ruoyi.device.simulator.BtsSimulatorStateStore.CollectorChannelState;
import com.ruoyi.device.simulator.BtsSimulatorStateStore.CollectorHistoryFaults;
import com.ruoyi.device.simulator.BtsSimulatorStateStore.CollectorMeasurementRecord;
import com.ruoyi.device.simulator.BtsSimulatorStateStore.CollectorMetricState;
import com.ruoyi.device.simulator.BtsSimulatorStateStore.CollectorState;
import com.ruoyi.device.simulator.BtsSimulatorStateStore.DeviceState;
import com.ruoyi.device.simulator.BtsSimulatorStateStore.SimulatorState;
import com.ruoyi.device.simulator.InMemoryBtsSimulatorStateStore;

class SimulatorPublicContractTest
{
    @Test
    void collectorGeneratesIndependentRealtimeAndHistoricalMeasurements() throws Exception
    {
        Instant startedAt = Instant.parse("2026-08-29T01:00:00Z");
        try (BtsDevelopmentSimulator simulator = new BtsDevelopmentSimulator(0))
        {
            simulator.configureCollectorSampling(1, 200, CollectorHistoryFaults.none());
            simulator.configureCollectorChannel(1, "S-01", List.of(
                    new CollectorMetricState("temperature", new BigDecimal("26.5"), "℃"),
                    new CollectorMetricState("positive_potential", new BigDecimal("3.801"), "V"),
                    new CollectorMetricState("negative_potential", new BigDecimal("-0.120"), "V"),
                    new CollectorMetricState("pressure", new BigDecimal("101.2"), "kPa")));

            simulator.advanceCollectors(startedAt);
            simulator.advanceCollectors(startedAt.plusMillis(400));

            var realtime = simulator.snapshot().collectors().get(0).latestMeasurements();
            var history = simulator.collectorHistory(1, 0, 1000);
            assertEquals(13, realtime.size());
            assertTrue(realtime.stream().allMatch(item -> item.sequenceId() == 3));
            assertTrue(realtime.stream().anyMatch(item -> item.channelCode().equals("S-01")
                    && item.metricCode().equals("pressure") && item.unit().equals("kPa")));
            assertEquals(39, history.total());
            assertEquals("dev-sim", history.records().get(0).adapterCode());
            assertEquals("dev-sim-collector-1", history.records().get(0).collectorCode());
            assertEquals(startedAt, history.records().get(0).deviceTime());
            assertTrue(history.records().get(0).deviceTimeRaw().startsWith("2026-08-29 09:00:00"));
            assertEquals(startedAt, history.records().get(0).serverReceivedAt());
        }
    }

    @Test
    void collectorHistorySupportsPagingAndRepeatableFaultScenarios() throws Exception
    {
        Instant startedAt = Instant.parse("2026-08-29T02:00:00Z");
        try (BtsDevelopmentSimulator simulator = new BtsDevelopmentSimulator(0))
        {
            simulator.configureCollectorSampling(1, 100,
                    new CollectorHistoryFaults(List.of(2L), 1L, 3L, true));
            simulator.advanceCollectors(startedAt);
            simulator.advanceCollectors(startedAt.plusMillis(200));

            var first = simulator.collectorHistory(1, 0, 17);
            var second = simulator.collectorHistory(1, first.nextOffset(), 1000);
            List<com.ruoyi.device.simulator.BtsSimulatorStateStore.CollectorMeasurementRecord> records =
                    new java.util.ArrayList<>(first.records());
            records.addAll(second.records());

            assertEquals(48, first.total());
            assertTrue(first.hasMore());
            assertFalse(second.hasMore());
            assertTrue(records.stream().noneMatch(item -> item.sequenceId() == 2));
            assertEquals(24, records.stream().filter(item -> item.sequenceId() == 1).count());
            assertEquals(2, records.stream().filter(item -> item.sequenceId() == 3
                    && item.channelCode().equals("S-01") && item.metricCode().equals("temperature")).count());
            assertTrue(records.get(0).sequenceId() >= records.get(records.size() - 1).sequenceId());
        }
    }

    @Test
    void collectorStopsWhileOfflineAndResumesFromPersistedSequence() throws Exception
    {
        InMemoryBtsSimulatorStateStore store = new InMemoryBtsSimulatorStateStore();
        Instant now = Instant.now();
        try (BtsDevelopmentSimulator simulator = new BtsDevelopmentSimulator(0, store))
        {
            simulator.advanceCollectors(now);
            simulator.updateCollector(1, "127.0.1.2", 4, false);
            simulator.advanceCollectors(now.plusSeconds(10));
            assertEquals(1, simulator.snapshot().collectors().get(0).latestMeasurements().get(0).sequenceId());
        }

        try (BtsDevelopmentSimulator restored = new BtsDevelopmentSimulator(0, store))
        {
            restored.updateCollector(1, "127.0.1.2", 4, true);
            restored.advanceCollectors(Instant.now().plusSeconds(2));
            assertTrue(restored.snapshot().collectors().get(0).latestMeasurements().get(0).sequenceId() >= 2);
            assertEquals(List.of("S-01", "S-02", "S-03", "S-04"),
                    restored.snapshot().collectors().get(0).channels().stream()
                            .map(channel -> channel.channelCode()).toList());
        }
    }

    @Test
    void collectorKeepsAppendOnlyHistoryBeyondPreviousDisplayLimit() throws Exception
    {
        Instant startedAt = Instant.parse("2026-08-29T03:00:00Z");
        try (BtsDevelopmentSimulator simulator = new BtsDevelopmentSimulator(0))
        {
            simulator.configureCollectorSampling(1, 100, CollectorHistoryFaults.none());
            simulator.advanceCollectors(startedAt);
            for (int batch = 1; batch <= 5; batch++)
                simulator.advanceCollectors(startedAt.plusMillis(batch * 100_000L));

            assertEquals(60_012, simulator.collectorHistory(1, 0, 1).total());
            assertEquals(1, simulator.collectorHistory(1, 0, 1).records().get(0).sequenceId());
        }
    }

    @Test
    void collectorRealtimeDropsMeasurementsRemovedFromCurrentConfiguration() throws Exception
    {
        Instant startedAt = Instant.parse("2026-08-29T04:00:00Z");
        InMemoryBtsSimulatorStateStore store = new InMemoryBtsSimulatorStateStore();
        try (BtsDevelopmentSimulator simulator = new BtsDevelopmentSimulator(0, store))
        {
            simulator.advanceCollectors(startedAt);
            assertEquals(12, simulator.snapshot().collectors().get(0).latestMeasurements().size());

            simulator.configureCollectorChannel(1, "S-01", List.of(
                    new CollectorMetricState("temperature", new BigDecimal("27.0"), "℃")));
            simulator.updateCollector(1, "127.0.1.2", 2, true);

            var snapshot = simulator.snapshot().collectors().get(0);
            assertEquals(4, snapshot.latestMeasurements().size());
            assertTrue(snapshot.latestMeasurements().stream()
                    .noneMatch(item -> item.channelCode().equals("S-03")
                            || item.channelCode().equals("S-04")
                            || item.channelCode().equals("S-01")
                                    && item.metricCode().equals("positive_potential")));
            assertEquals(12, simulator.collectorHistory(1, 0, 100).total());
        }

        try (BtsDevelopmentSimulator restored = new BtsDevelopmentSimulator(0, store))
        {
            assertEquals(4, restored.snapshot().collectors().get(0).latestMeasurements().size());
            assertEquals(12, restored.collectorHistory(1, 0, 100).total());
        }
    }

    @Test
    void simulatorIsReusableOutsideTheBtsPackage() throws Exception
    {
        try (ScriptedBtsTcpSimulator simulator = new ScriptedBtsTcpSimulator();
             BtsTcpTransport transport = new BtsTcpTransport("127.0.0.1", simulator.port(),
                     Duration.ofSeconds(1), Duration.ofSeconds(1)))
        {
            simulator.enqueue("<bts><cmd>getdevinfo_resp</cmd><middle count=\"0\"/></bts>");

            assertEquals("<bts><cmd>getdevinfo_resp</cmd><middle count=\"0\"/></bts>",
                    transport.exchange("<bts><cmd>getdevinfo</cmd></bts>"));
            assertEquals(1, simulator.requests().size());
        }
    }

    @Test
    void simulatorPreservesRequestEndingWithDelimiterPrefix() throws Exception
    {
        try (ScriptedBtsTcpSimulator simulator = new ScriptedBtsTcpSimulator();
             BtsTcpTransport transport = new BtsTcpTransport("127.0.0.1", simulator.port(),
                     Duration.ofSeconds(1), Duration.ofSeconds(1)))
        {
            simulator.enqueue("ok");

            assertEquals("ok", transport.exchange("payload#"));
            assertEquals("payload#", simulator.requests().get(0));
        }
    }

    @Test
    void developmentSimulatorSupportsRepeatedDiscoveryAndObservation() throws Exception
    {
        try (BtsDevelopmentSimulator simulator = new BtsDevelopmentSimulator(0);
             BtsTcpTransport transport = new BtsTcpTransport("127.0.0.1", simulator.port(),
                     Duration.ofSeconds(1), Duration.ofSeconds(1));
             DeviceAdapter adapter = new BtsDeviceAdapter("development-bts", transport,
                     new BtsXmlCodec("development-bts", ZoneId.of("Asia/Hong_Kong"))))
        {
            var firstDiscovery = adapter.discoverChannels();
            var secondDiscovery = adapter.discoverChannels();

            assertEquals(4, firstDiscovery.size());
            assertEquals(firstDiscovery, secondDiscovery);
            assertEquals("开发模拟器", firstDiscovery.get(0).deviceMetadata().manufacturer());
            assertEquals("BTS Virtual Cabinet", firstDiscovery.get(0).deviceMetadata().model());
            assertEquals(1, firstDiscovery.stream().map(channel -> channel.identity().devid()).distinct().count());
            assertEquals(4, firstDiscovery.stream().filter(channel -> channel.available()).count());

            Set<com.ruoyi.device.model.ChannelIdentity> channels = firstDiscovery.stream()
                    .map(channel -> channel.identity())
                    .collect(java.util.stream.Collectors.toSet());
            var firstObservation = adapter.inquire(channels);
            var secondObservation = adapter.inquire(channels);

            assertEquals(4, firstObservation.size());
            assertEquals(DeviceWorkStatus.STOPPED, firstObservation.values().iterator().next().workStatus());
            assertEquals(firstObservation.keySet(), secondObservation.keySet());
        }
    }

    @Test
    void developmentSimulatorPublishesOperatorControlledChannelFacts() throws Exception
    {
        try (BtsDevelopmentSimulator simulator = new BtsDevelopmentSimulator(0);
             BtsTcpTransport transport = new BtsTcpTransport("127.0.0.1", simulator.port(),
                     Duration.ofSeconds(1), Duration.ofSeconds(1));
             DeviceAdapter adapter = new BtsDeviceAdapter("dev-sim", transport,
                     new BtsXmlCodec("dev-sim", ZoneId.of("Asia/Hong_Kong"))))
        {
            simulator.updateChannel(1, 1, true, DeviceWorkStatus.WORKING);
            simulator.updateChannel(1, 2, false, DeviceWorkStatus.PAUSED);

            var discovered = adapter.discoverChannels();
            Set<com.ruoyi.device.model.ChannelIdentity> available = discovered.stream()
                    .filter(channel -> channel.available())
                    .map(channel -> channel.identity())
                    .collect(java.util.stream.Collectors.toSet());
            var observed = adapter.inquire(available);

            assertEquals(4, discovered.size());
            assertEquals(3, available.size());
            assertEquals(DeviceWorkStatus.WORKING, observed.entrySet().stream()
                    .filter(entry -> entry.getKey().chlid() == 1)
                    .findFirst().orElseThrow().getValue().workStatus());

            simulator.updateDevice(1, "127.0.0.2", 4, false);
            assertEquals(0, adapter.discoverChannels().stream().filter(channel -> channel.available()).count());
            assertEquals(4, simulator.snapshot().devices().get(0).channels().size());
            assertEquals(3, simulator.snapshot().recentRequests().size());
        }
    }

    @Test
    void developmentSimulatorSupportsMultipleConfigurableDevices() throws Exception
    {
        try (BtsDevelopmentSimulator simulator = new BtsDevelopmentSimulator(0);
             BtsTcpTransport transport = new BtsTcpTransport("127.0.0.1", simulator.port(),
                     Duration.ofSeconds(1), Duration.ofSeconds(1));
             DeviceAdapter adapter = new BtsDeviceAdapter("dev-sim", transport,
                     new BtsXmlCodec("dev-sim", ZoneId.of("Asia/Hong_Kong"))))
        {
            int secondDeviceId = simulator.addDevice("127.0.0.3", 2);
            simulator.updateDevice(1, "127.0.0.2", 4, true);

            var discovered = adapter.discoverChannels();

            assertEquals(6, discovered.size());
            assertEquals(2, discovered.stream().map(channel -> channel.identity().devid()).distinct().count());
            assertEquals(4, discovered.stream().filter(channel -> channel.serverIp().equals("127.0.0.2")).count());
            assertEquals(2, discovered.stream().filter(channel -> channel.serverIp().equals("127.0.0.3")).count());

            simulator.deleteDevice(secondDeviceId);
            for (int index = 0; index < 3; index++)
            {
                var withTombstone = adapter.discoverChannels();
                assertEquals(6, withTombstone.size());
                assertEquals(4, withTombstone.stream().filter(DetectedChannel::available).count());
            }
            assertEquals(4, adapter.discoverChannels().size());
        }
    }

    @Test
    void developmentCollectorsNeverEnterBtsCabinetDiscovery() throws Exception
    {
        try (BtsDevelopmentSimulator simulator = new BtsDevelopmentSimulator(0);
             BtsTcpTransport transport = new BtsTcpTransport("127.0.0.1", simulator.port(),
                     Duration.ofSeconds(1), Duration.ofSeconds(1));
             DeviceAdapter adapter = new BtsDeviceAdapter("dev-sim", transport,
                     new BtsXmlCodec("dev-sim", ZoneId.of("Asia/Hong_Kong"))))
        {
            assertEquals(4, adapter.discoverChannels().size());

            simulator.addCollector("127.0.1.8", 12);

            assertEquals(4, adapter.discoverChannels().size());
            assertEquals(2, simulator.snapshot().collectors().size());
        }
    }

    @Test
    void developmentSimulatorRestoresConfigurationNumberingAndStatus() throws Exception
    {
        InMemoryBtsSimulatorStateStore store = new InMemoryBtsSimulatorStateStore();
        try (BtsDevelopmentSimulator first = new BtsDevelopmentSimulator(0, store))
        {
            first.updateDevice(1, "127.0.0.9", 2, false);
            first.addDevice("127.0.0.10", 3);
            first.updateCollector(1, "127.0.1.9", 7, false);
        }

        try (BtsDevelopmentSimulator restored = new BtsDevelopmentSimulator(0, store))
        {
            assertEquals(2, restored.snapshot().devices().size());
            assertEquals("127.0.0.9", restored.snapshot().devices().get(0).ip());
            assertEquals(false, restored.snapshot().devices().get(0).online());
            assertEquals(7, restored.snapshot().collectors().get(0).channelCount());
            assertEquals(3, restored.addDevice("127.0.0.11", 1));
        }
    }

    @Test
    void developmentSimulatorDoesNotExposeWriteThroughFailureInMemory() throws Exception
    {
        InMemoryBtsSimulatorStateStore delegate = new InMemoryBtsSimulatorStateStore();
        BtsSimulatorStateStore failing = new BtsSimulatorStateStore()
        {
            @Override public SimulatorState loadOrInitialize(SimulatorState value)
            { return delegate.loadOrInitialize(value); }
            @Override public void save(SimulatorState value) { throw new IllegalStateException("redis unavailable"); }
            @Override public java.util.List<RecentRequest> loadRecentRequests()
            { return delegate.loadRecentRequests(); }
            @Override public void saveRecentRequests(java.util.List<RecentRequest> requests)
            { delegate.saveRecentRequests(requests); }
            @Override public void reset(SimulatorState value) { delegate.reset(value); }
        };

        try (BtsDevelopmentSimulator simulator = new BtsDevelopmentSimulator(0, failing))
        {
            assertThrows(IllegalStateException.class, () -> simulator.addDevice("127.0.0.3", 2));
            assertEquals(1, simulator.snapshot().devices().size());
        }
    }

    @Test
    void developmentSimulatorRestoresUnfinishedTombstones() throws Exception
    {
        InMemoryBtsSimulatorStateStore store = new InMemoryBtsSimulatorStateStore();
        try (BtsDevelopmentSimulator first = new BtsDevelopmentSimulator(0, store);
             BtsTcpTransport transport = new BtsTcpTransport("127.0.0.1", first.port(),
                     Duration.ofSeconds(1), Duration.ofSeconds(1));
             DeviceAdapter adapter = new BtsDeviceAdapter("dev-sim", transport,
                     new BtsXmlCodec("dev-sim", ZoneId.of("Asia/Hong_Kong"))))
        {
            first.deleteDevice(1);
            assertEquals(4, adapter.discoverChannels().size());
        }

        try (BtsDevelopmentSimulator restored = new BtsDevelopmentSimulator(0, store);
             BtsTcpTransport transport = new BtsTcpTransport("127.0.0.1", restored.port(),
                     Duration.ofSeconds(1), Duration.ofSeconds(1));
             DeviceAdapter adapter = new BtsDeviceAdapter("dev-sim", transport,
                     new BtsXmlCodec("dev-sim", ZoneId.of("Asia/Hong_Kong"))))
        {
            assertEquals(4, adapter.discoverChannels().size());
            assertEquals(4, adapter.discoverChannels().size());
            assertEquals(0, adapter.discoverChannels().size());
        }
    }

    @Test
    void developmentSimulatorRejectsNonContiguousRestoredChannelTopology()
    {
        SimulatorState damaged = new SimulatorState(BtsSimulatorStateStore.CURRENT_VERSION,
                java.util.List.of(new DeviceState(1, "127.0.0.2", true,
                        java.util.List.of(new ChannelState(2, true, DeviceWorkStatus.STOPPED)))),
                java.util.List.of(), 2, 1, java.util.List.of());

        assertThrows(IllegalStateException.class,
                () -> new BtsDevelopmentSimulator(0, new InMemoryBtsSimulatorStateStore(damaged)));
    }

    @Test
    void developmentSimulatorRejectsDamagedCollectorHistoryIdentity()
    {
        Instant observedAt = Instant.parse("2026-08-29T05:00:00Z");
        List<CollectorChannelState> channels = List.of(new CollectorChannelState("S-01", List.of(
                new CollectorMetricState("temperature", new BigDecimal("25.0"), "℃"))));
        CollectorState collector = new CollectorState(1, "dev-sim-collector-1", "127.0.1.2",
                "02:43:00:00:00:01", "模拟采集器", "开发模拟器", "Virtual Collector", 1, true,
                1000, 2L, observedAt, channels, List.of(), List.of(new CollectorMeasurementRecord(
                        "dev-sim", "wrong-collector", "S-01", 1L, observedAt,
                        "2026-08-29 13:00:00.000", observedAt, "temperature",
                        new BigDecimal("25.0"), "℃")), CollectorHistoryFaults.none());
        SimulatorState damaged = new SimulatorState(BtsSimulatorStateStore.CURRENT_VERSION,
                List.of(), List.of(collector), 1, 2, List.of());

        assertThrows(IllegalStateException.class,
                () -> new BtsDevelopmentSimulator(0, new InMemoryBtsSimulatorStateStore(damaged)));
    }

    @Test
    void developmentSimulatorRejectsCollectorSequenceBehindPersistedHistory()
    {
        Instant observedAt = Instant.parse("2026-08-29T06:00:00Z");
        List<CollectorChannelState> channels = List.of(new CollectorChannelState("S-01", List.of(
                new CollectorMetricState("temperature", new BigDecimal("25.0"), "℃"))));
        CollectorState collector = new CollectorState(1, "dev-sim-collector-1", "127.0.1.2",
                "02:43:00:00:00:01", "模拟采集器", "开发模拟器", "Virtual Collector", 1, true,
                1000, 1L, observedAt, channels, List.of(), List.of(new CollectorMeasurementRecord(
                        "dev-sim", "dev-sim-collector-1", "S-01", 1L, observedAt,
                        "2026-08-29 14:00:00.000", observedAt, "temperature",
                        new BigDecimal("25.0"), "℃")), CollectorHistoryFaults.none());
        SimulatorState damaged = new SimulatorState(BtsSimulatorStateStore.CURRENT_VERSION,
                List.of(), List.of(collector), 1, 2, List.of());

        assertThrows(IllegalStateException.class,
                () -> new BtsDevelopmentSimulator(0, new InMemoryBtsSimulatorStateStore(damaged)));
    }
}