"""
Integration tests for the analytics pipeline and production node.
"""
from live.integrator import AnalyticsPipeline


class TestAnalyticsPipeline:
    def test_empty_pipeline(self):
        p = AnalyticsPipeline()
        result = p.emit()
        assert result["signal"] == "neutral"
        assert result["mid"] == 0

    def test_book_update_sets_mid(self):
        p = AnalyticsPipeline()
        p.update_book({50000.0: 1.0, 49999.0: 2.0}, {50002.0: 1.0, 50003.0: 0.5})
        assert p.mid == 50001.0
        assert p.obi != 0
        assert p.spread_bps > 0

    def test_trade_updates_vpin(self):
        p = AnalyticsPipeline()
        p.update_book({50000.0: 5.0, 49999.0: 5.0}, {50001.0: 5.0, 50002.0: 5.0})
        for _ in range(100):
            p.update_trade(50001.0, 0.01, 50000.5)  # buys
        for _ in range(50):
            p.update_trade(50000.0, 0.005, 50000.5)  # sells
        assert p.vpin >= 0
        assert p.trade_imbalance() > 0  # more buys

    def test_emi_of(self):
        p = AnalyticsPipeline()
        p.update_book({50000.0: 1.0, 49999.0: 2.0}, {50002.0: 1.0, 50003.0: 0.5})
        assert p.ema_obi(alpha=0.5) != 0

    def test_full_emit(self):
        p = AnalyticsPipeline()
        bids = {100.0: 1.0, 99.0: 2.0}
        asks = {102.0: 1.0, 103.0: 3.0}
        p.update_book(bids, asks)
        for _ in range(20):
            p.update_trade(101.0, 0.1, 101.0)
        result = p.emit(funding_regime="neutral")
        assert "signal" in result
        assert "confidence" in result
        assert "vpin" in result
        assert "obi" in result
        assert "hft_regime" in result
        assert "breakdown" in result

    def test_hft_regime_detect(self):
        p = AnalyticsPipeline()
        bids = {100.0: 1.0}
        asks = {102.0: 1.0}
        p.update_book(bids, asks)
        regime = p.hft_regime()
        assert regime in ("trending", "ranging", "toxic", "quiet")

    def test_pipeline_per_coin_isolation(self):
        btc = AnalyticsPipeline()
        eth = AnalyticsPipeline()
        btc.update_book({50000.0: 1.0}, {50002.0: 1.0})
        eth.update_book({3000.0: 1.0}, {3002.0: 1.0})
        assert btc.mid > 40000
        assert eth.mid < 10000

    def test_trade_count_tracking(self):
        p = AnalyticsPipeline()
        p.update_book({100.0: 1.0}, {102.0: 1.0})
        for _ in range(5):
            p.update_trade(101.0, 0.1)
        assert p.emit()["trade_count"] == 5


class TestNodeV2Smoke:
    def test_node_creation(self):
        from live.node_v2 import ProductionNode
        node = ProductionNode(
            coins=["BTC"],
            testnet=True,
            mode="paper",
            max_position_per_coin=0.001,
            base_quote_size=0.0001,
        )
        assert node is not None

    def test_node_start_stop(self):
        import asyncio
        from live.node_v2 import ProductionNode

        async def _test():
            node = ProductionNode(
                coins=["BTC"],
                testnet=True,
                mode="paper",
                tick_interval_sec=0.1,
                max_position_per_coin=0.001,
                base_quote_size=0.0001,
            )
            await node.start()
            for _ in range(3):
                await node._tick_cycle()
            await node.stop()
            assert node._tick > 0

        asyncio.run(_test())

    def test_metrics_written(self):
        import asyncio, json, tempfile, os, time
        from live.node_v2 import ProductionNode

        f = tempfile.NamedTemporaryFile(delete=False, suffix=".json")
        f.close()

        async def _test():
            node = ProductionNode(
                coins=["BTC"],
                testnet=True,
                mode="paper",
                tick_interval_sec=0.1,
                max_position_per_coin=0.001,
                base_quote_size=0.0001,
                metrics_file=f.name,
            )
            await node.start()
            for _ in range(2):
                await node._tick_cycle()
            await node.stop()

            assert os.path.exists(f.name)
            data = json.load(open(f.name))
            assert "treasury" in data
            assert "analytics" in data
            assert "equity_history" in data
            assert "maker" in data

        asyncio.run(_test())
        os.unlink(f.name)


class TestCLISmoke:
    def test_cli_import(self):
        import cli
        assert cli.main is not None