from __future__ import annotations

from datetime import datetime, timezone
from pathlib import Path
from typing import Any
import hashlib
import json

SAFE_DEFAULT_TARGET = Path("/home/agent/jarvis_runtime/finance-system/crypto_trader/trader_desk_latest.json")


def _stable_id(*parts: Any) -> str:
    raw = "|".join(str(part) for part in parts)
    return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:20]


def _write_json(path: Path, payload: dict[str, Any]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    tmp = path.with_suffix(path.suffix + ".tmp")
    tmp.write_text(json.dumps(payload, indent=2, sort_keys=True, default=str), encoding="utf-8")
    tmp.replace(path)


def _write_markdown(path: Path, payload: dict[str, Any]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    summary = payload.get("summary") or {}
    lines = [
        "# JARVIS Trader Desk",
        "",
        f"Generated: {payload.get('generated_at')}",
        "",
        "## Safety",
        "",
        "```text",
        "execution_allowed=false",
        f"live_order_allowed={str(payload.get('live_order_allowed')).lower()}",
        f"mainnet_signed_action={str(payload.get('mainnet_signed_action')).lower()}",
        "dashboard_executes_orders=false",
        "```",
        "",
        "## Summary",
        "",
        f"- Tiny candidates: {summary.get('tiny_live_candidates', 0)}",
        f"- Shadow/watch: {summary.get('watch_shadow', 0)}",
        f"- Blocked: {summary.get('blocked', 0)}",
        f"- Next step: {summary.get('next_step', '-')}",
        "",
        "## Trade intents",
        "",
    ]
    for intent in payload.get("trade_intents", []):
        lines.extend([
            f"### {intent.get('coin')} — {intent.get('signal')}",
            "",
            f"- Intent ID: `{intent.get('intent_id')}`",
            f"- Mode: `{intent.get('mode')}`",
            f"- Side: `{intent.get('side')}`",
            f"- Score: `{intent.get('confidence_score')}`",
            f"- Status: `{intent.get('status')}`",
            f"- Entry: `{intent.get('entry_zone')}`",
            f"- Stop: `{intent.get('stop_loss')}`",
            f"- TP: `{intent.get('take_profit')}`",
            f"- Blockers: `{intent.get('blockers') or []}`",
            "",
        ])
    path.write_text("\n".join(lines), encoding="utf-8")


def trader_desk_to_finance_snapshot(trader_desk_payload: dict[str, Any]) -> dict[str, Any]:
    report = trader_desk_payload.get("report") or trader_desk_payload
    plans = report.get("plans") or []
    timestamp = str(report.get("timestamp") or datetime.now(timezone.utc).isoformat())
    trade_intents: list[dict[str, Any]] = []
    for plan in plans:
        coin = str(plan.get("coin") or "UNKNOWN").upper()
        action = str(plan.get("action") or "no_trade")
        side = str(plan.get("direction") or "none")
        intent_id = _stable_id(timestamp, "trader_desk.v1", coin, action, side, plan.get("score"), plan.get("setup"))
        mode = "approval" if action == "tiny_live_candidate" else "research" if action == "watch_shadow" else "live-blocked"
        trade_intents.append({
            "intent_id": intent_id,
            "portfolio_id": "hyperliquid-usdc-derivatives",
            "source_engine": "jarvis_trader_desk_v1",
            "strategy_id": "trader_desk_multi_signal_v1",
            "coin": coin,
            "asset": coin,
            "side": side,
            "signal": action,
            "mode": mode,
            "status": "awaiting_final_preflight" if action == "tiny_live_candidate" else action,
            "confidence_score": str(plan.get("score") or "0.00"),
            "setup": plan.get("setup"),
            "entry_zone": plan.get("entry_zone") or {},
            "stop_loss": plan.get("stop_loss"),
            "take_profit": plan.get("take_profit") or {},
            "risk_reward": plan.get("risk_reward"),
            "notional_cap_usdc": plan.get("notional_cap_usdc"),
            "evidence": plan.get("evidence") or {},
            "reasons": plan.get("reasons") or [],
            "blockers": plan.get("blockers") or [],
            "requires_preflight": bool(plan.get("requires_preflight", True)),
            "execution_allowed": False,
            "dashboard_executes_orders": False,
            "live_order_allowed": False,
            "mainnet_signed_action": False,
            "intent_created_at": timestamp,
            "expires_after_seconds": 900,
        })
    return {
        "schema_version": "finance_crypto_trader_desk_bridge.v1",
        "generated_at": datetime.now(timezone.utc).isoformat(),
        "source_report_timestamp": timestamp,
        "portfolio": {
            "portfolio_id": "hyperliquid-usdc-derivatives",
            "venue": "Hyperliquid",
            "base_currency": "USDC",
            "portfolio_type": "derivatives_margin_trading",
        },
        "safety_boundary": {
            "dashboard_executes_orders": False,
            "approval_is_audit_only": True,
            "trader_must_recheck_gates": True,
            "execution_allowed": False,
            "live_order_allowed": False,
            "mainnet_signed_action": False,
        },
        "summary": report.get("summary") or {},
        "market_regime": report.get("market_regime"),
        "trade_intents": trade_intents,
        "live_order_allowed": False,
        "mainnet_signed_action": False,
    }


def export_finance_snapshot(trader_desk_payload: dict[str, Any], *, target: str | Path = SAFE_DEFAULT_TARGET, markdown_target: str | Path | None = None) -> dict[str, Any]:
    target_path = Path(target).expanduser()
    snapshot = trader_desk_to_finance_snapshot(trader_desk_payload)
    _write_json(target_path, snapshot)
    md_path = Path(markdown_target).expanduser() if markdown_target else target_path.with_suffix(".md")
    _write_markdown(md_path, snapshot)
    return {
        "status": "ok",
        "target": str(target_path),
        "markdown_target": str(md_path),
        "intent_count": len(snapshot["trade_intents"]),
        "execution_allowed": False,
        "live_order_allowed": False,
        "mainnet_signed_action": False,
        "snapshot": snapshot,
    }