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 src.services.trading_plans import TradingPlanService


DEFAULT_TRADING_PLAN_SYMBOLS = ("BTC-USDT", "ETH-USDT")


def build_trading_plan_symbols_from_env(env=None) -> tuple[str, ...]:
    env = os.environ if env is None else env
    raw_value = str(env.get("TRADING_PLAN_SYMBOLS") or ",".join(DEFAULT_TRADING_PLAN_SYMBOLS))
    symbols = tuple(item.strip() for item in raw_value.split(",") if item.strip())
    return symbols or DEFAULT_TRADING_PLAN_SYMBOLS


def build_trading_plan_timeframe_set_from_env(env=None) -> dict:
    env = os.environ if env is None else env
    bias_tf = str(env.get("AI_ICT_BIAS_TIMEFRAME") or env.get("TRADING_PLAN_BIAS_TIMEFRAME") or "1m")
    setup_tf = str(env.get("AI_ICT_SETUP_TIMEFRAME") or env.get("TRADING_PLAN_SETUP_TIMEFRAME") or bias_tf)
    trigger_tf = str(env.get("AI_ICT_TRIGGER_TIMEFRAME") or env.get("TRADING_PLAN_TRIGGER_TIMEFRAME") or setup_tf)
    return {
        "bias_tf": bias_tf,
        "setup_tf": setup_tf,
        "trigger_tf": trigger_tf,
    }


def main(env=None) -> int:
    env = os.environ if env is None else env
    output_json = _get_bool(env, "TRADING_PLANS_OUTPUT_JSON", False)
    symbols = build_trading_plan_symbols_from_env(env=env)
    timeframe_set = build_trading_plan_timeframe_set_from_env(env=env)
    service = TradingPlanService()
    plans = []

    try:
        for symbol in symbols:
            instrument = service.repository.fetch_instrument_by_symbol(symbol)
            if not instrument:
                plans.append(
                    {
                        "symbol": symbol,
                        "passed": False,
                        "error": "instrument_not_found",
                    }
                )
                continue
            candidate = service.build_plan(
                instrument_id=int(instrument["id"]),
                bias_tf=timeframe_set["bias_tf"],
                setup_tf=timeframe_set["setup_tf"],
                trigger_tf=timeframe_set["trigger_tf"],
            )
            plan_id = service.persist_plan(candidate)
            plans.append(
                {
                    "symbol": symbol,
                    "instrument_id": int(instrument["id"]),
                    "passed": True,
                    "plan_id": plan_id,
                    "status": candidate.status,
                    "bias": candidate.bias,
                    "has_draw": bool(candidate.primary_draw),
                    "has_invalidation": bool(candidate.invalidations),
                    "no_trade_conditions": candidate.no_trade_conditions,
                }
            )
    except SQLAlchemyError as exc:
        payload = {
            "passed": False,
            "symbols": list(symbols),
            "timeframe_set": timeframe_set,
            "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 trading plan sample: {exc.__class__.__name__}")
        return 2

    payload = {
        "passed": all(plan.get("passed") for plan in plans),
        "symbols": list(symbols),
        "timeframe_set": timeframe_set,
        "plans": plans,
    }
    if output_json:
        print(json.dumps(payload, default=str, ensure_ascii=False, sort_keys=True))
    else:
        for plan in plans:
            print(json.dumps(plan, default=str, ensure_ascii=False, sort_keys=True))
    return 0 if payload["passed"] else 2


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())