"""
test_rt_exit_manager.py — Unit and integration tests for RealTimeExitManager.

Tests cover:
  - No positions → empty result
  - SHORT TP trigger (price falls through tp_price)
  - SHORT no trigger (price above tp_price)
  - SHORT SL trigger (price rises through sl_price)
  - LONG TP and SL triggers
  - SL disabled (sl_price=0.0) — never fires
  - Max-hold trigger (time-based, no price lookup)
  - Max-hold disabled
  - Multiple positions, only one triggers
  - Register / unregister lifecycle
  - Exact fill-side convention (SHORT exit uses ask, LONG uses bid)
  - None price → no trigger (feed unavailable)
  - make_position threshold arithmetic
  - Immutability of OpenPosition / ExitSignal
"""

import sys
import time
import unittest

sys.path.insert(0, 'nautilus_dolphin')

from nautilus_dolphin.nautilus.live_price_feed import ConstantPriceFeed, NullPriceFeed
from nautilus_dolphin.nautilus.rt_exit_manager import (
    ExitSignal,
    OpenPosition,
    RealTimeExitManager,
)


# ── Helpers ───────────────────────────────────────────────────────────────────

def _make_mgr(prices: dict | None = None, tp_pct: float = 0.0095, sl_pct: float = 0.0):
    feed = ConstantPriceFeed(prices or {})
    return RealTimeExitManager(feed, tp_pct=tp_pct, sl_pct=sl_pct), feed


def _pos(
    trade_id='T1',
    asset='BTCUSDT',
    direction=-1,
    entry_price=82000.0,
    tp_price=81221.0,
    sl_price=0.0,
    entry_ns=None,
    max_hold_ns=0,
):
    return OpenPosition(
        trade_id=trade_id,
        asset=asset,
        direction=direction,
        entry_price=entry_price,
        tp_price=tp_price,
        sl_price=sl_price,
        entry_ns=entry_ns if entry_ns is not None else time.monotonic_ns(),
        max_hold_ns=max_hold_ns,
    )


# ── Basic lifecycle ───────────────────────────────────────────────────────────

class TestLifecycle(unittest.TestCase):

    def test_no_positions_returns_empty_list(self):
        mgr, _ = _make_mgr()
        result = mgr.check_all()
        self.assertIsInstance(result, list)
        self.assertEqual(result, [])

    def test_open_count_starts_zero(self):
        mgr, _ = _make_mgr()
        self.assertEqual(mgr.open_count(), 0)

    def test_register_increments_count(self):
        mgr, _ = _make_mgr({'BTCUSDT': (82000.0, 82010.0)})
        mgr.register(_pos())
        self.assertEqual(mgr.open_count(), 1)

    def test_unregister_decrements_count(self):
        mgr, _ = _make_mgr()
        mgr.register(_pos('T1'))
        mgr.unregister('T1')
        self.assertEqual(mgr.open_count(), 0)

    def test_unregister_unknown_is_noop(self):
        mgr, _ = _make_mgr()
        mgr.unregister('NONEXISTENT')   # must not raise
        self.assertEqual(mgr.open_count(), 0)

    def test_is_registered_true_after_register(self):
        mgr, _ = _make_mgr()
        mgr.register(_pos('T42'))
        self.assertTrue(mgr.is_registered('T42'))

    def test_is_registered_false_after_unregister(self):
        mgr, _ = _make_mgr()
        mgr.register(_pos('T42'))
        mgr.unregister('T42')
        self.assertFalse(mgr.is_registered('T42'))


# ── SHORT TP ──────────────────────────────────────────────────────────────────

class TestShortTP(unittest.TestCase):

    def test_short_tp_fires_when_ask_below_tp_price(self):
        # SHORT entry 82000, tp_pct=0.0095 → tp_price = 82000*(1-0.0095) = 81221
        mgr, feed = _make_mgr(tp_pct=0.0095, sl_pct=0.0)
        feed.update('BTCUSDT', bid=81200.0, ask=81210.0)  # ask 81210 < tp 81221 → TP
        p = RealTimeExitManager.make_position('T1', 'BTCUSDT', -1, 82000.0, tp_pct=0.0095)
        mgr.register(p)

        signals = mgr.check_all()
        self.assertEqual(len(signals), 1)
        sig = signals[0]
        self.assertEqual(sig.trade_id, 'T1')
        self.assertEqual(sig.asset, 'BTCUSDT')
        self.assertEqual(sig.reason, 'RT_TP')
        self.assertAlmostEqual(sig.exit_price, 81210.0)  # ask price used for short exit

    def test_short_tp_does_not_fire_when_ask_above_tp_price(self):
        mgr, feed = _make_mgr(tp_pct=0.0095)
        feed.update('BTCUSDT', bid=81900.0, ask=81910.0)  # ask 81910 > tp 81221 → no signal
        p = RealTimeExitManager.make_position('T1', 'BTCUSDT', -1, 82000.0, tp_pct=0.0095)
        mgr.register(p)
        self.assertEqual(mgr.check_all(), [])

    def test_short_tp_fires_at_exact_tp_price(self):
        tp_price = 82000.0 * (1.0 - 0.0095)  # = 81221.0
        mgr, feed = _make_mgr(tp_pct=0.0095)
        feed.update('BTCUSDT', bid=tp_price - 0.01, ask=tp_price)  # ask == tp_price exactly
        p = RealTimeExitManager.make_position('T1', 'BTCUSDT', -1, 82000.0, tp_pct=0.0095)
        mgr.register(p)
        signals = mgr.check_all()
        self.assertEqual(len(signals), 1)
        self.assertEqual(signals[0].reason, 'RT_TP')


# ── SHORT SL ──────────────────────────────────────────────────────────────────

class TestShortSL(unittest.TestCase):

    def test_short_sl_fires_when_ask_above_sl_price(self):
        # Entry 82000, sl_pct=0.01 → sl_price = 82000*1.01 = 82820
        mgr, feed = _make_mgr(tp_pct=0.0095, sl_pct=0.01)
        feed.update('BTCUSDT', bid=82900.0, ask=82920.0)  # ask 82920 > sl 82820 → SL
        p = RealTimeExitManager.make_position('T1', 'BTCUSDT', -1, 82000.0,
                                              tp_pct=0.0095, sl_pct=0.01)
        mgr.register(p)
        signals = mgr.check_all()
        self.assertEqual(len(signals), 1)
        self.assertEqual(signals[0].reason, 'RT_SL')
        self.assertAlmostEqual(signals[0].exit_price, 82920.0)

    def test_short_sl_disabled_at_zero(self):
        # sl_pct=0.0 → sl_price=0.0 → never fires regardless of price
        mgr, feed = _make_mgr(tp_pct=0.0095, sl_pct=0.0)
        feed.update('BTCUSDT', bid=999999.0, ask=1000000.0)  # absurd price
        p = RealTimeExitManager.make_position('T1', 'BTCUSDT', -1, 82000.0,
                                              tp_pct=0.0095, sl_pct=0.0)
        mgr.register(p)
        self.assertEqual(mgr.check_all(), [])

    def test_short_sl_does_not_fire_below_sl_price(self):
        mgr, feed = _make_mgr(tp_pct=0.0095, sl_pct=0.01)
        feed.update('BTCUSDT', bid=82700.0, ask=82710.0)  # ask 82710 < sl 82820 → no signal
        p = RealTimeExitManager.make_position('T1', 'BTCUSDT', -1, 82000.0,
                                              tp_pct=0.0095, sl_pct=0.01)
        mgr.register(p)
        self.assertEqual(mgr.check_all(), [])


# ── LONG TP / SL ──────────────────────────────────────────────────────────────

class TestLongTPSL(unittest.TestCase):

    def test_long_tp_fires_when_bid_above_tp_price(self):
        # LONG entry 1600, tp_pct=0.0095 → tp_price = 1600*1.0095 = 1615.2
        mgr, feed = _make_mgr(tp_pct=0.0095)
        feed.update('ETHUSDT', bid=1616.0, ask=1616.5)  # bid 1616 > tp 1615.2 → TP
        p = RealTimeExitManager.make_position('T2', 'ETHUSDT', +1, 1600.0, tp_pct=0.0095)
        mgr.register(p)
        signals = mgr.check_all()
        self.assertEqual(len(signals), 1)
        self.assertEqual(signals[0].reason, 'RT_TP')
        self.assertAlmostEqual(signals[0].exit_price, 1616.0)  # bid for LONG exit

    def test_long_tp_does_not_fire_when_bid_below_tp_price(self):
        mgr, feed = _make_mgr(tp_pct=0.0095)
        feed.update('ETHUSDT', bid=1610.0, ask=1610.5)  # bid 1610 < tp 1615.2 → no signal
        p = RealTimeExitManager.make_position('T2', 'ETHUSDT', +1, 1600.0, tp_pct=0.0095)
        mgr.register(p)
        self.assertEqual(mgr.check_all(), [])

    def test_long_sl_fires_when_bid_below_sl_price(self):
        # LONG entry 1600, sl_pct=0.01 → sl_price = 1600*0.99 = 1584
        mgr, feed = _make_mgr(tp_pct=0.0095, sl_pct=0.01)
        feed.update('ETHUSDT', bid=1583.0, ask=1583.5)  # bid 1583 < sl 1584 → SL
        p = RealTimeExitManager.make_position('T2', 'ETHUSDT', +1, 1600.0,
                                              tp_pct=0.0095, sl_pct=0.01)
        mgr.register(p)
        signals = mgr.check_all()
        self.assertEqual(len(signals), 1)
        self.assertEqual(signals[0].reason, 'RT_SL')


# ── Max-hold ──────────────────────────────────────────────────────────────────

class TestMaxHold(unittest.TestCase):

    def test_max_hold_fires_when_elapsed(self):
        mgr, feed = _make_mgr()
        # entry_ns far in the past — hold limit already exceeded
        old_ns = time.monotonic_ns() - int(300 * 1e9)  # 5 minutes ago
        pos = OpenPosition(
            trade_id='T_MAXHOLD',
            asset='BTCUSDT',
            direction=-1,
            entry_price=82000.0,
            tp_price=81000.0,   # price not crossed
            sl_price=0.0,
            entry_ns=old_ns,
            max_hold_ns=int(60 * 1e9),  # 60s limit — clearly exceeded
        )
        feed.update('BTCUSDT', bid=81900.0, ask=81910.0)  # price not at TP
        mgr.register(pos)
        signals = mgr.check_all()
        self.assertEqual(len(signals), 1)
        self.assertEqual(signals[0].reason, 'RT_MAX_HOLD')

    def test_max_hold_not_fired_before_limit(self):
        mgr, feed = _make_mgr()
        pos = OpenPosition(
            trade_id='T_FRESH',
            asset='BTCUSDT',
            direction=-1,
            entry_price=82000.0,
            tp_price=81000.0,
            sl_price=0.0,
            entry_ns=time.monotonic_ns(),  # just now
            max_hold_ns=int(3600 * 1e9),   # 1 hour limit
        )
        feed.update('BTCUSDT', bid=81900.0, ask=81910.0)
        mgr.register(pos)
        self.assertEqual(mgr.check_all(), [])

    def test_max_hold_disabled_at_zero(self):
        mgr, feed = _make_mgr()
        old_ns = time.monotonic_ns() - int(86400 * 1e9)  # 1 day ago
        pos = OpenPosition(
            trade_id='T_NOLIMIT',
            asset='BTCUSDT',
            direction=-1,
            entry_price=82000.0,
            tp_price=81000.0,
            sl_price=0.0,
            entry_ns=old_ns,
            max_hold_ns=0,  # disabled
        )
        feed.update('BTCUSDT', bid=81900.0, ask=81910.0)
        mgr.register(pos)
        self.assertEqual(mgr.check_all(), [])  # no TP cross, no max_hold → silent

    def test_max_hold_uses_live_price_when_available(self):
        mgr, feed = _make_mgr()
        old_ns = time.monotonic_ns() - int(300 * 1e9)
        pos = OpenPosition(
            trade_id='T_MH_PX',
            asset='BTCUSDT',
            direction=-1,
            entry_price=82000.0,
            tp_price=80000.0,
            sl_price=0.0,
            entry_ns=old_ns,
            max_hold_ns=int(60 * 1e9),
        )
        feed.update('BTCUSDT', bid=81500.0, ask=81510.0)
        mgr.register(pos)
        signals = mgr.check_all()
        self.assertEqual(signals[0].reason, 'RT_MAX_HOLD')
        # SHORT max-hold uses ask price
        self.assertAlmostEqual(signals[0].exit_price, 81510.0)

    def test_max_hold_fallback_to_entry_price_when_no_quote(self):
        mgr, _ = _make_mgr(prices={})  # no prices
        old_ns = time.monotonic_ns() - int(300 * 1e9)
        pos = OpenPosition(
            trade_id='T_MH_NOPX',
            asset='BTCUSDT',
            direction=-1,
            entry_price=82000.0,
            tp_price=80000.0,
            sl_price=0.0,
            entry_ns=old_ns,
            max_hold_ns=int(60 * 1e9),
        )
        mgr.register(pos)
        signals = mgr.check_all()
        self.assertEqual(signals[0].reason, 'RT_MAX_HOLD')
        self.assertAlmostEqual(signals[0].exit_price, 82000.0)  # fallback to entry


# ── None price (feed unavailable) ─────────────────────────────────────────────

class TestNullFeed(unittest.TestCase):

    def test_null_feed_no_signal_for_price_based_exits(self):
        feed = NullPriceFeed()
        mgr  = RealTimeExitManager(feed, tp_pct=0.0095, sl_pct=0.01)
        pos  = RealTimeExitManager.make_position('T1', 'BTCUSDT', -1, 82000.0,
                                                 tp_pct=0.0095, sl_pct=0.01)
        mgr.register(pos)
        self.assertEqual(mgr.check_all(), [])


# ── Multiple positions ────────────────────────────────────────────────────────

class TestMultiplePositions(unittest.TestCase):

    def test_only_triggered_position_in_result(self):
        mgr, feed = _make_mgr(tp_pct=0.0095)
        # BTC: price crossed TP — entry 82000, tp=81221, ask=81210 (< tp) → fires
        feed.update('BTCUSDT', bid=81200.0, ask=81210.0)
        # ETH: price NOT at TP — entry 1620, tp=1604.61, ask=1610 (> tp) → no fire
        feed.update('ETHUSDT', bid=1609.0, ask=1610.0)

        p_btc = RealTimeExitManager.make_position('T_BTC', 'BTCUSDT', -1, 82000.0, tp_pct=0.0095)
        p_eth = RealTimeExitManager.make_position('T_ETH', 'ETHUSDT', -1, 1620.0, tp_pct=0.0095)
        mgr.register(p_btc)
        mgr.register(p_eth)

        signals = mgr.check_all()
        self.assertEqual(len(signals), 1)
        self.assertEqual(signals[0].trade_id, 'T_BTC')

    def test_both_trigger_returns_two_signals(self):
        mgr, feed = _make_mgr(tp_pct=0.0095)
        feed.update('BTCUSDT', bid=81200.0, ask=81210.0)
        feed.update('ETHUSDT', bid=1595.0,  ask=1595.5)   # below tp(1604.6)

        p_btc = RealTimeExitManager.make_position('T_BTC', 'BTCUSDT', -1, 82000.0, tp_pct=0.0095)
        p_eth = RealTimeExitManager.make_position('T_ETH', 'ETHUSDT', -1, 1620.0, tp_pct=0.0095)
        mgr.register(p_btc)
        mgr.register(p_eth)

        signals = mgr.check_all()
        self.assertEqual(len(signals), 2)

    def test_check_all_does_not_auto_unregister(self):
        """Caller is responsible for unregistering — check_all is read-only."""
        mgr, feed = _make_mgr(tp_pct=0.0095)
        feed.update('BTCUSDT', bid=81200.0, ask=81210.0)
        p = RealTimeExitManager.make_position('T1', 'BTCUSDT', -1, 82000.0, tp_pct=0.0095)
        mgr.register(p)
        _ = mgr.check_all()
        # Position still registered — caller must unregister
        self.assertTrue(mgr.is_registered('T1'))

    def test_unregister_after_signal_stops_repeat_firing(self):
        mgr, feed = _make_mgr(tp_pct=0.0095)
        feed.update('BTCUSDT', bid=81200.0, ask=81210.0)
        p = RealTimeExitManager.make_position('T1', 'BTCUSDT', -1, 82000.0, tp_pct=0.0095)
        mgr.register(p)
        signals = mgr.check_all()
        self.assertEqual(len(signals), 1)
        mgr.unregister('T1')
        self.assertEqual(mgr.check_all(), [])


# ── Fill-side convention ──────────────────────────────────────────────────────

class TestFillSide(unittest.TestCase):
    """Exit price must be ask for SHORT (cost to close) and bid for LONG (proceeds)."""

    def test_short_exit_price_is_ask(self):
        mgr, feed = _make_mgr(tp_pct=0.0095)
        feed.update('BTCUSDT', bid=81210.0, ask=81220.0)  # ask(81220) <= tp(81221)
        p = RealTimeExitManager.make_position('T1', 'BTCUSDT', -1, 82000.0, tp_pct=0.0095)
        mgr.register(p)
        signals = mgr.check_all()
        self.assertEqual(len(signals), 1)
        self.assertAlmostEqual(signals[0].exit_price, 81220.0)   # ask, not bid

    def test_long_exit_price_is_bid(self):
        mgr, feed = _make_mgr(tp_pct=0.0095)
        feed.update('ETHUSDT', bid=1616.0, ask=1616.5)  # bid(1616) >= tp(1615.2)
        p = RealTimeExitManager.make_position('T2', 'ETHUSDT', +1, 1600.0, tp_pct=0.0095)
        mgr.register(p)
        signals = mgr.check_all()
        self.assertEqual(len(signals), 1)
        self.assertAlmostEqual(signals[0].exit_price, 1616.0)    # bid, not ask


# ── make_position factory ─────────────────────────────────────────────────────

class TestMakePosition(unittest.TestCase):

    def test_short_tp_price_is_below_entry(self):
        pos = RealTimeExitManager.make_position('T', 'BTC', -1, 82000.0, tp_pct=0.0095)
        expected_tp = 82000.0 * (1.0 - 0.0095)
        self.assertAlmostEqual(pos.tp_price, expected_tp, places=4)

    def test_short_tp_price_less_than_entry(self):
        pos = RealTimeExitManager.make_position('T', 'BTC', -1, 82000.0, tp_pct=0.0095)
        self.assertLess(pos.tp_price, pos.entry_price)

    def test_long_tp_price_is_above_entry(self):
        pos = RealTimeExitManager.make_position('T', 'ETH', +1, 1600.0, tp_pct=0.0095)
        expected_tp = 1600.0 * (1.0 + 0.0095)
        self.assertAlmostEqual(pos.tp_price, expected_tp, places=4)

    def test_long_tp_price_greater_than_entry(self):
        pos = RealTimeExitManager.make_position('T', 'ETH', +1, 1600.0, tp_pct=0.0095)
        self.assertGreater(pos.tp_price, pos.entry_price)

    def test_short_sl_price_is_above_entry(self):
        pos = RealTimeExitManager.make_position('T', 'BTC', -1, 82000.0,
                                                tp_pct=0.0095, sl_pct=0.01)
        expected_sl = 82000.0 * 1.01
        self.assertAlmostEqual(pos.sl_price, expected_sl, places=4)

    def test_long_sl_price_is_below_entry(self):
        pos = RealTimeExitManager.make_position('T', 'ETH', +1, 1600.0,
                                                tp_pct=0.0095, sl_pct=0.01)
        expected_sl = 1600.0 * 0.99
        self.assertAlmostEqual(pos.sl_price, expected_sl, places=4)

    def test_sl_disabled_when_sl_pct_zero(self):
        pos = RealTimeExitManager.make_position('T', 'BTC', -1, 82000.0,
                                                tp_pct=0.0095, sl_pct=0.0)
        self.assertAlmostEqual(pos.sl_price, 0.0)

    def test_max_hold_ns_computed_correctly(self):
        pos = RealTimeExitManager.make_position('T', 'BTC', -1, 82000.0,
                                                tp_pct=0.0095,
                                                max_hold_bars=250,
                                                bar_seconds=60)
        expected_ns = 250 * 60 * 1_000_000_000
        self.assertEqual(pos.max_hold_ns, expected_ns)

    def test_max_hold_disabled_when_zero_bars(self):
        pos = RealTimeExitManager.make_position('T', 'BTC', -1, 82000.0,
                                                tp_pct=0.0095, max_hold_bars=0)
        self.assertEqual(pos.max_hold_ns, 0)

    def test_open_position_is_frozen(self):
        pos = RealTimeExitManager.make_position('T', 'BTC', -1, 82000.0, tp_pct=0.0095)
        with self.assertRaises((AttributeError, TypeError)):
            pos.trade_id = 'MUTATED'   # type: ignore

    def test_exit_signal_is_frozen(self):
        sig = ExitSignal('T', 'BTC', 'RT_TP', 81200.0, 123456)
        with self.assertRaises((AttributeError, TypeError)):
            sig.reason = 'MUTATED'     # type: ignore


# ── E2E: full lifecycle ───────────────────────────────────────────────────────

class TestEndToEnd(unittest.TestCase):
    """Simulate a full trade cycle: entry → mid-trade price movement → RT exit."""

    def test_short_trade_full_cycle(self):
        """
        Entry SHORT BTCUSDT @ 82000.
        TP = 81221 (0.95% below entry).
        Price moves down to 81100 (below TP) → RT_TP fires.
        Unregister → subsequent check returns empty.
        """
        feed = ConstantPriceFeed({'BTCUSDT': (82000.0, 82010.0)})
        mgr  = RealTimeExitManager(feed, tp_pct=0.0095)

        pos = RealTimeExitManager.make_position(
            'T_CYCLE', 'BTCUSDT', direction=-1,
            entry_price=82000.0, tp_pct=0.0095,
        )
        mgr.register(pos)

        # Price not yet at TP
        self.assertEqual(mgr.check_all(), [])
        self.assertEqual(mgr.open_count(), 1)

        # Price moves to TP
        feed.update('BTCUSDT', bid=81100.0, ask=81110.0)
        signals = mgr.check_all()
        self.assertEqual(len(signals), 1)
        self.assertEqual(signals[0].reason, 'RT_TP')
        self.assertAlmostEqual(signals[0].exit_price, 81110.0)

        # Caller unregisters after handling signal
        mgr.unregister('T_CYCLE')
        self.assertEqual(mgr.open_count(), 0)
        self.assertEqual(mgr.check_all(), [])

    def test_multiple_symbols_independent_lifecycle(self):
        feed = ConstantPriceFeed({
            'BTCUSDT': (82000.0, 82010.0),
            'ETHUSDT': (1600.0, 1600.5),
            'SOLUSDT': (120.0,  120.05),
        })
        mgr = RealTimeExitManager(feed, tp_pct=0.0095)

        for tid, sym, ep in [
            ('T1', 'BTCUSDT', 82000.0),
            ('T2', 'ETHUSDT', 1600.0),
            ('T3', 'SOLUSDT', 120.0),
        ]:
            mgr.register(RealTimeExitManager.make_position(tid, sym, -1, ep, tp_pct=0.0095))

        self.assertEqual(mgr.open_count(), 3)
        self.assertEqual(mgr.check_all(), [])  # no TP crossed yet

        # BTC hits TP
        feed.update('BTCUSDT', bid=81100.0, ask=81110.0)
        signals = mgr.check_all()
        self.assertEqual(len(signals), 1)
        self.assertEqual(signals[0].trade_id, 'T1')

        mgr.unregister('T1')
        self.assertEqual(mgr.open_count(), 2)

        # ETH hits TP
        feed.update('ETHUSDT', bid=1582.0, ask=1582.5)
        signals = mgr.check_all()
        self.assertEqual(len(signals), 1)
        self.assertEqual(signals[0].trade_id, 'T2')


if __name__ == '__main__':
    unittest.main()