from datetime import datetime, timedelta, timezone
from pathlib import Path
import json
import os
import sys

from sqlalchemy.exc import SQLAlchemyError

ROOT = Path(__file__).resolve().parents[1]
os.environ.setdefault("DATABASE_URL", "postgresql+psycopg://user:pass@localhost:5432/ai_ict_test")
if str(ROOT) not in sys.path:
    sys.path.insert(0, str(ROOT))

from scripts.run_execution import build_account_risk_state_from_env
from src.services.market_state import (
    DEFAULT_MAX_CANDLE_AGE_SECONDS,
    MarketStateService,
    get_market_truth_supervisor,
)
from src.services.risk import RiskContext, RiskGovernorService


def main(env=None) -> int:
    env = os.environ if env is None else env
    output_json = _get_bool(env, "RISK_GOVERNOR_OUTPUT_JSON", False)
    instrument_id = _get_int(env, "RISK_INSTRUMENT_ID", 1)
    timeframe = str(env.get("RISK_TIMEFRAME") or "1m")
    execution_mode = str(env.get("RISK_EXECUTION_MODE") or "paper")
    service = MarketStateService(market_truth_supervisor=get_market_truth_supervisor())
    try:
        market_state = service.build_market_state(
            instrument_id=instrument_id,
            timeframe=timeframe,
            max_candle_age_seconds=_get_int(
                env,
                "MARKET_STATE_MAX_CANDLE_AGE_SECONDS",
                DEFAULT_MAX_CANDLE_AGE_SECONDS,
            ),
            news_windows=build_news_windows_from_env(env),
            opening_volatility_minutes=_get_int(env, "OPENING_VOLATILITY_GUARD_MINUTES", 0),
        )
        quality_gate = service.repository.fetch_latest_backtest_quality_gate(instrument_id=instrument_id)
    except SQLAlchemyError as exc:
        payload = {
            "passed": False,
            "error_type": exc.__class__.__name__,
            "error": str(exc),
        }
        if output_json:
            print(json.dumps(payload, default=str, ensure_ascii=False, sort_keys=True))
        else:
            print(f"Database unavailable for risk governor sample: {exc.__class__.__name__}")
        return 2

    context = RiskContext.from_account_state(
        build_account_risk_state_from_env(env=env),
        market_state=market_state,
        backtest_quality_gate=quality_gate,
        block_opening_volatility=_get_bool(env, "BLOCK_OPENING_VOLATILITY", False),
    )
    decision = RiskGovernorService().evaluate(
        context=context,
        execution_mode=execution_mode,
        new_position=True,
    )
    payload = {
        "passed": True,
        "instrument_id": instrument_id,
        "timeframe": timeframe,
        "execution_mode": execution_mode,
        "decision": decision.to_dict(),
    }
    if output_json:
        print(json.dumps(payload, default=str, ensure_ascii=False, sort_keys=True))
    else:
        print(f"Risk governor allowed: {decision.allowed}; reject_codes: {decision.reject_codes}")
    return 0


def build_news_windows_from_env(env=None) -> list[dict]:
    env = os.environ if env is None else env
    if not _get_bool(env, "NEWS_WINDOW_ACTIVE", False):
        return []
    now = datetime.now(timezone.utc)
    return [
        {
            "id": str(env.get("NEWS_WINDOW_ID") or "env_news_window"),
            "start_ts": now - timedelta(minutes=_get_int(env, "NEWS_WINDOW_MINUTES_BEFORE", 5)),
            "end_ts": now + timedelta(minutes=_get_int(env, "NEWS_WINDOW_MINUTES_AFTER", 5)),
        }
    ]


def _get_int(env, key: str, default: int) -> int:
    value = env.get(key)
    if value is None or value == "":
        return default
    return int(value)


def _get_bool(env, key: str, default: bool) -> bool:
    value = env.get(key)
    if value is None or value == "":
        return default
    return str(value).strip().lower() in {"1", "true", "yes", "on"}


if __name__ == "__main__":
    raise SystemExit(main())