from __future__ import annotations

import unittest
from pathlib import Path

from dragon_branch_configs import alpha_first_glued_refined_hot_cap_config
from dragon_rc1_golden_baseline import _load_indicator_snapshot
from dragon_reason_types import RuleFamily, RuleLayer
from dragon_rule_catalog import classify_aux_reason, classify_entry_reason, classify_exit_reason
from dragon_shared import END_DATE, START_DATE
from dragon_strategy import DragonRuleEngine


class TestReasonCatalogMapping(unittest.TestCase):
    def setUp(self) -> None:
        self.base_dir = Path(__file__).resolve().parents[1]

    def test_key_reason_examples(self) -> None:
        entry = classify_entry_reason("glued_buy")
        self.assertEqual(entry.layer, RuleLayer.CORE)
        self.assertEqual(entry.family, RuleFamily.GLUED)

        entry_bridge = classify_entry_reason("predictive_error_reentry_buy")
        self.assertEqual(entry_bridge.layer, RuleLayer.BRIDGE)
        self.assertEqual(entry_bridge.family, RuleFamily.PREDICTIVE_BREAK)

        exit_bridge = classify_exit_reason("predictive_b1_break_exit")
        self.assertEqual(exit_bridge.layer, RuleLayer.BRIDGE)
        self.assertEqual(exit_bridge.family, RuleFamily.PREDICTIVE_BREAK)

        aux = classify_aux_reason("bearish_signal_after_exit:ql_sell")
        self.assertEqual(aux.layer, RuleLayer.BRIDGE)
        self.assertEqual(aux.family, RuleFamily.AUXILIARY)

    def test_release_window_trade_reasons_are_mapped(self) -> None:
        indexed, _ = _load_indicator_snapshot(self.base_dir)
        engine = DragonRuleEngine(config=alpha_first_glued_refined_hot_cap_config())
        _, details = engine.run(indexed)
        details = details[
            (details["buy_date"] >= START_DATE)
            & (details["buy_date"] <= END_DATE)
            & (details["sell_date"] >= START_DATE)
            & (details["sell_date"] <= END_DATE)
        ].copy()

        buy_unknown = sorted(
            {
                reason
                for reason in details["buy_reason"].astype(str).unique()
                if classify_entry_reason(reason).layer == RuleLayer.UNKNOWN
            }
        )
        sell_unknown = sorted(
            {
                reason
                for reason in details["sell_reason"].astype(str).unique()
                if classify_exit_reason(reason).layer == RuleLayer.UNKNOWN
            }
        )

        self.assertEqual(buy_unknown, [], msg=f"Unknown entry reasons: {buy_unknown}")
        self.assertEqual(sell_unknown, [], msg=f"Unknown exit reasons: {sell_unknown}")


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