import json
import random
import requests
from config import settings


def searx_news(symbol: str, limit: int = 10):
    q = f"{symbol} stock news earnings guidance analyst macro risk"
    params = {"q": q, "format": "json", "language": "en"}
    try:
        r = requests.get(settings.searx_url, params=params, timeout=20)
        r.raise_for_status()
        data = r.json()
        out = []
        for it in data.get("results", [])[:limit]:
            out.append({"title": it.get("title", ""), "url": it.get("url", ""), "content": it.get("content", "")[:500]})
        return out
    except Exception:
        return []


def summarize_news_with_ollama(symbol: str, context_items: list):
    payload = {
        "model": settings.ollama_model,
        "stream": False,
        "prompt": json.dumps({
            "task": "Summarize market-moving info into a concise, neutral brief.",
            "symbol": symbol,
            "news": context_items,
            "format": {"summary": "<=140 words", "bullish_points": ["..."], "bearish_points": ["..."]}
        }),
        "format": "json",
    }
    try:
        r = requests.post(f"{settings.ollama_url}/api/generate", json=payload, timeout=45)
        r.raise_for_status()
        resp = r.json().get("response", "{}")
        parsed = json.loads(resp)
        return parsed.get("summary", "no-summary")
    except Exception:
        return "summary-unavailable"


def ollama_decide(symbol: str, context_items: list):
    prompt = {
        "task": "You are a conservative autonomous trading policy engine. Return strict JSON only.",
        "constraints": {
            "actions": ["buy", "sell", "hold"],
            "max_order_usd": settings.max_order_usd,
            "risk": "do not overtrade; prefer hold on weak signal",
        },
        "symbol": symbol,
        "news": context_items,
        "output_schema": {
            "action": "buy|sell|hold",
            "confidence": "0-1",
            "reason": "short rationale",
            "order_usd": f"<= {settings.max_order_usd}",
        },
    }
    payload = {
        "model": settings.ollama_model,
        "prompt": json.dumps(prompt),
        "stream": False,
        "format": "json",
    }
    try:
        r = requests.post(f"{settings.ollama_url}/api/generate", json=payload, timeout=45)
        r.raise_for_status()
        resp = r.json().get("response", "{}")
        d = json.loads(resp)
        action = str(d.get("action", "hold")).lower()
        if action not in {"buy", "sell", "hold"}:
            action = "hold"
        confidence = max(0.0, min(1.0, float(d.get("confidence", 0.5))))
        order_usd = min(float(d.get("order_usd", settings.max_order_usd)), settings.max_order_usd)
        reason = d.get("reason", "fallback")
        return {"action": action, "confidence": confidence, "order_usd": order_usd, "reason": reason}
    except Exception:
        return {
            "action": random.choice(["hold", "hold", "buy"]),
            "confidence": 0.3,
            "order_usd": min(1.0, settings.max_order_usd),
            "reason": "fallback-mode",
        }


def alpaca_headers():
    return {
        "APCA-API-KEY-ID": settings.alpaca_key,
        "APCA-API-SECRET-KEY": settings.alpaca_secret,
        "Content-Type": "application/json",
    }


def place_order(symbol: str, action: str, order_usd: float):
    if action not in {"buy", "sell"}:
        return None
    payload = {
        "symbol": symbol,
        "side": action,
        "type": "market",
        "time_in_force": "day",
        "notional": round(order_usd, 2),
    }
    try:
        r = requests.post(f"{settings.alpaca_base}/v2/orders", headers=alpaca_headers(), json=payload, timeout=20)
        return {"ok": r.ok, "status": r.status_code, "json": r.json() if r.text else {}}
    except Exception as e:
        return {"ok": False, "status": 0, "json": {"error": str(e)}}


def account_snapshot():
    try:
        r = requests.get(f"{settings.alpaca_base}/v2/account", headers=alpaca_headers(), timeout=20)
        r.raise_for_status()
        return r.json()
    except Exception:
        return {}


def positions_snapshot():
    try:
        r = requests.get(f"{settings.alpaca_base}/v2/positions", headers=alpaca_headers(), timeout=20)
        if r.ok:
            return r.json()
    except Exception:
        pass
    return []


def market_open():
    try:
        r = requests.get(f"{settings.alpaca_base}/v2/clock", headers=alpaca_headers(), timeout=20)
        if r.ok:
            return bool(r.json().get("is_open", False))
    except Exception:
        pass
    return False