"""Performance comparison: per-book series, R-multiples, and the start-date window."""

from __future__ import annotations

from datetime import date, datetime, timedelta, timezone
from types import SimpleNamespace

import pytest

from app.services import paper_trade_service as pts
from app.services.trade_policy import MANUAL_BOOK, SHADOW_BOOK


def _trade(*, book, entry=100.0, stop=95.0, close=None, shares=10.0, opened_days_ago=5):
    now = datetime.now(timezone.utc)
    return SimpleNamespace(
        ticker_id=1,
        direction="long",
        entry_price=entry,
        stop_loss=stop,
        shares=shares,
        book=book,
        status="closed" if close is not None else "open",
        close_price=close,
        opened_at=now - timedelta(days=opened_days_ago),
        closed_at=now if close is not None else None,
    )


class TestRMultiple:
    def test_winner_measured_in_units_of_initial_risk(self):
        # Entry 100, stop 95 → 5 of risk. Exit 115 → +15 → +3R.
        trade = _trade(book=SHADOW_BOOK, close=115.0)
        assert pts.trade_r_multiple(trade, None) == pytest.approx(3.0)

    def test_full_stop_is_minus_one_r(self):
        trade = _trade(book=SHADOW_BOOK, close=95.0)
        assert pts.trade_r_multiple(trade, None) == pytest.approx(-1.0)

    def test_open_trade_marks_to_the_latest_close(self):
        trade = _trade(book=SHADOW_BOOK)
        assert pts.trade_r_multiple(trade, 110.0) == pytest.approx(2.0)

    def test_no_risk_distance_has_no_r(self):
        trade = _trade(book=SHADOW_BOOK, entry=100.0, stop=100.0, close=120.0)
        assert pts.trade_r_multiple(trade, None) is None


class TestBookStats:
    def test_r_is_independent_of_position_size(self):
        """The whole point: a 10-share and a 1000-share book compare equally."""
        small = pts.book_stats([_trade(book=SHADOW_BOOK, close=115.0, shares=10)], {})
        large = pts.book_stats([_trade(book=MANUAL_BOOK, close=115.0, shares=1000)], {})
        assert small["total_r"] == large["total_r"] == pytest.approx(3.0)

    def test_counts_and_win_rate(self):
        trades = [
            _trade(book=SHADOW_BOOK, close=115.0),
            _trade(book=SHADOW_BOOK, close=95.0),
            _trade(book=SHADOW_BOOK),
        ]
        stats = pts.book_stats(trades, {1: 110.0})
        assert stats["trades"] == 3
        assert stats["closed"] == 2
        assert stats["open"] == 1
        # +3R, -1R, +2R marked → 2 of 3 positive.
        assert stats["win_rate"] == pytest.approx(66.7)
        assert stats["total_r"] == pytest.approx(4.0)


class TestStrategySizedPercent:
    """Both books and SPY share one unit — percent of equity — on the chart."""

    def test_one_r_is_risk_pct_of_equity(self):
        # Entry 100, stop 90 → 10 of risk; 1% risk → 0.001 shares per $ equity
        # (10% notional, under the 20% cap). Exit 120 = +2R = +2% of equity.
        trade = _trade(book=MANUAL_BOOK, entry=100.0, stop=90.0, close=120.0)
        assert pts.strategy_sized_fraction(trade, 1.0, 0.20) == pytest.approx(0.001)
        days = [trade.closed_at.date()]
        assert pts._cumulative_sized_pct([trade], {}, days, 1.0, 0.20) == [2.0]

    def test_notional_cap_shrinks_tight_stop_trades(self):
        # Stop 1 away would need 100% of equity in notional for 1% risk; the
        # 20% cap leaves 0.2% at risk, so +1R is only +0.2% of equity.
        trade = _trade(book=MANUAL_BOOK, entry=100.0, stop=99.0, close=101.0)
        days = [trade.closed_at.date()]
        assert pts._cumulative_sized_pct([trade], {}, days, 1.0, 0.20) == [0.2]

    def test_hand_sized_shares_do_not_matter(self):
        small = _trade(book=MANUAL_BOOK, entry=100.0, stop=90.0, close=120.0, shares=1)
        large = _trade(book=MANUAL_BOOK, entry=100.0, stop=90.0, close=120.0, shares=5000)
        days = [small.closed_at.date()]
        assert pts._cumulative_sized_pct(
            [small], {}, days, 1.0, 0.20
        ) == pts._cumulative_sized_pct([large], {}, days, 1.0, 0.20)


class TestPerformanceSummaryPercent:
    @pytest.fixture
    async def session(self):
        from tests.conftest import _test_session_factory

        async with _test_session_factory() as session:
            yield session

    @pytest.mark.asyncio
    async def test_shadow_percent_is_measured_on_equity_at_window_start(self, session):
        """A pinned start date moves the base: P&L realized before it is equity."""
        from app.models.benchmark_price import BenchmarkPrice
        from app.models.ohlcv import OHLCVRecord
        from app.models.paper_trade import PaperTrade
        from app.models.ticker import Ticker
        from app.models.user import User

        today = datetime.now(timezone.utc).date()

        def at(d):
            return datetime(d.year, d.month, d.day, 20, tzinfo=timezone.utc)

        session.add(User(id=1, username="u", password_hash="x", role="user", has_access=True))
        ticker = Ticker(symbol="AAA")
        session.add(ticker)
        await session.flush()
        session.add(
            OHLCVRecord(ticker_id=ticker.id, date=today, open=110, high=110, low=110,
                        close=110, volume=1)
        )
        for offset, close in ((10, 390.0), (3, 400.0), (0, 412.0)):
            session.add(BenchmarkPrice(symbol="SPY", date=today - timedelta(days=offset),
                                       close=close))
        common = dict(user_id=1, ticker_id=ticker.id, direction="long", entry_price=100.0,
                      stop_loss=90.0, target=150.0, fill_mode="near_close")
        # Before the window: +$5,000 realized, so the window's base is $105k.
        session.add(PaperTrade(**common, book=SHADOW_BOOK, shares=100, status="closed",
                               close_price=150.0, opened_at=at(today - timedelta(days=10)),
                               closed_at=at(today - timedelta(days=8))))
        # In the window: +$1,050 on 105 shares = +1.0% of $105k.
        session.add(PaperTrade(**common, book=SHADOW_BOOK, shares=105, status="open",
                               opened_at=at(today - timedelta(days=3))))
        # Hand-sized manual trade, +1R → +1.0% at strategy sizing whatever its shares.
        session.add(PaperTrade(**common, book=MANUAL_BOOK, shares=7, status="open",
                               opened_at=at(today - timedelta(days=3))))
        await session.commit()
        await pts.settings_store.upsert_setting(
            session, pts.KEY_PERFORMANCE_START, (today - timedelta(days=5)).isoformat()
        )

        summary = await pts.performance_summary(session, user_id=1)

        assert summary["equity_base"] == pytest.approx(105_000.0)
        assert summary["risk_pct"] == pytest.approx(1.0)
        last = summary["series"][-1]
        assert last["shadow_pnl"] == pytest.approx(1050.0)
        assert last["shadow_pct"] == pytest.approx(1.0)
        assert last["manual_pct"] == pytest.approx(1.0)
        assert last["spy_pct"] == pytest.approx(3.0)
        assert summary["stats"]["shadow"]["pct"] == pytest.approx(1.0)
        assert summary["stats"]["manual"]["pct"] == pytest.approx(1.0)
        assert summary["stats"]["shadow"]["spy_pct"] == pytest.approx(3.0)

    @pytest.mark.asyncio
    async def test_strategy_vs_spy_starts_at_the_first_shadow_trade(self, session):
        """Manual trades opening first must not charge the strategy for SPY's run-up."""
        from app.models.benchmark_price import BenchmarkPrice
        from app.models.paper_trade import PaperTrade
        from app.models.ticker import Ticker
        from app.models.user import User

        today = datetime.now(timezone.utc).date()

        def at(d):
            return datetime(d.year, d.month, d.day, 20, tzinfo=timezone.utc)

        session.add(User(id=1, username="u", password_hash="x", role="user", has_access=True))
        ticker = Ticker(symbol="AAA")
        session.add(ticker)
        await session.flush()
        for offset, close in ((6, 400.0), (2, 420.0), (0, 441.0)):
            session.add(BenchmarkPrice(symbol="SPY", date=today - timedelta(days=offset),
                                       close=close))
        common = dict(user_id=1, ticker_id=ticker.id, direction="long", entry_price=100.0,
                      stop_loss=90.0, target=150.0, fill_mode="near_close", shares=10,
                      status="open")
        session.add(PaperTrade(**common, book=MANUAL_BOOK, opened_at=at(today - timedelta(days=6))))
        session.add(PaperTrade(**common, book=SHADOW_BOOK, opened_at=at(today - timedelta(days=2))))
        await session.commit()

        summary = await pts.performance_summary(session, user_id=1)

        # Full window 400 → 441 = +10.25%; the strategy's own window 420 → 441 = +5%.
        assert summary["stats"]["spy"]["pct"] == pytest.approx(10.25)
        assert summary["stats"]["shadow"]["spy_pct"] == pytest.approx(5.0)
        assert summary["stats"]["shadow"]["since"] == (today - timedelta(days=2)).isoformat()


class TestPerformanceStartDate:
    @pytest.fixture
    async def session(self):
        from tests.conftest import _test_session_factory

        async with _test_session_factory() as session:
            yield session

    @pytest.mark.asyncio
    async def test_unset_means_all_history(self, session):
        assert await pts.get_performance_start(session) is None

    @pytest.mark.asyncio
    async def test_reads_an_iso_date(self, session):
        await pts.settings_store.upsert_setting(
            session, pts.KEY_PERFORMANCE_START, "2026-07-20"
        )
        assert await pts.get_performance_start(session) == date(2026, 7, 20)

    @pytest.mark.asyncio
    async def test_garbage_falls_back_to_all_history(self, session):
        """A bad setting must not blank the whole performance card."""
        await pts.settings_store.upsert_setting(
            session, pts.KEY_PERFORMANCE_START, "not-a-date"
        )
        assert await pts.get_performance_start(session) is None

    @pytest.mark.asyncio
    async def test_empty_string_means_all_history(self, session):
        await pts.settings_store.upsert_setting(session, pts.KEY_PERFORMANCE_START, "")
        assert await pts.get_performance_start(session) is None