from __future__ import annotations

import json
import unittest
from pathlib import Path

from dragon_branch_configs import alpha_first_glued_refined_hot_cap_config
from dragon_rc1_golden_baseline import (
    EVENTS_CORE_COLUMNS,
    MANIFEST_OUTPUT,
    TRADES_CORE_COLUMNS,
    _df_sha256,
    _load_indicator_snapshot,
    main as build_golden_baseline,
)
from dragon_shared import END_DATE, START_DATE
from dragon_strategy import DragonRuleEngine


class TestRC1GoldenRegression(unittest.TestCase):
    def setUp(self) -> None:
        self.base_dir = Path(__file__).resolve().parents[1]
        self.manifest_path = self.base_dir / MANIFEST_OUTPUT
        if not self.manifest_path.exists():
            build_golden_baseline()

    def test_rc1_core_hash_and_summary_match_manifest(self) -> None:
        manifest = json.loads(self.manifest_path.read_text(encoding="utf-8"))

        indexed, _ = _load_indicator_snapshot(self.base_dir)
        engine = DragonRuleEngine(config=alpha_first_glued_refined_hot_cap_config())
        events, trades = engine.run(indexed)

        events = events[
            (events["date"] >= START_DATE)
            & (events["date"] <= END_DATE)
        ].copy()
        trades = trades[
            (trades["buy_date"] >= START_DATE)
            & (trades["buy_date"] <= END_DATE)
            & (trades["sell_date"] >= START_DATE)
            & (trades["sell_date"] <= END_DATE)
        ].copy()

        events.sort_values(["date", "side", "layer", "reason"], inplace=True)
        trades.sort_values(["buy_date", "sell_date", "buy_reason", "sell_reason"], inplace=True)

        events_core_hash = _df_sha256(events[EVENTS_CORE_COLUMNS])
        trades_core_hash = _df_sha256(trades[TRADES_CORE_COLUMNS])

        self.assertEqual(events_core_hash, manifest["artifacts"]["events"]["core_sha256"])
        self.assertEqual(trades_core_hash, manifest["artifacts"]["trades"]["core_sha256"])

        returns = trades["return_pct"].astype(float)
        self.assertEqual(int(len(trades)), int(manifest["summary"]["trade_count"]))
        self.assertEqual(int(len(events)), int(manifest["summary"]["event_count"]))
        self.assertAlmostEqual(float((returns > 0).mean()), float(manifest["summary"]["win_rate"]), places=12)
        self.assertAlmostEqual(float(returns.mean()), float(manifest["summary"]["avg_return"]), places=12)
        self.assertAlmostEqual(float(returns.median()), float(manifest["summary"]["median_return"]), places=12)


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