"""
Finnhub API client with caching for market data.
"""
import os
import time
import json
from datetime import datetime, timedelta
from typing import Optional, Dict, Any
import requests

FINNHUB_API_KEY = os.environ.get("FINNHUB_API_KEY")
BASE_URL = "https://finnhub.io/api/v1"

Cache storage

_cache: Dict[str, Any] = {}
_cache_timestamps: Dict[str, float] = {}

TTL configuration (in seconds)

TTL_QUOTES = 15 * 60 # 15 minutes
TTL_NEWS = 2 * 60 * 60 # 2 hours
TTL_SENTIMENT = 24 * 60 * 60 # 24 hours
TTL_WATCHLIST = 24 * 60 * 60 # 24 hours

Last successful fetch tracking

_last_success: Dict[str, Optional[datetime]] = {
"quote": None,
"news": None,
"sentiment": None,
"watchlist": None,
}

def _get_cache_key(endpoint: str, params: str = "") -> str:
"""Generate cache key for an endpoint."""
return f"{endpoint}:{params}"

def _is_cached(key: str, ttl: int) -> bool:
"""Check if data is cached and not expired."""
if key not in _cache or key not in _cache_timestamps:
return False
age = time.time() - _cache_timestamps[key]
return age < ttl

def _get_cached(key: str) -> Any:
"""Get cached data."""
return _cache.get(key)

def _set_cache(key: str, data: Any, endpoint_type: str):
"""Cache data and update timestamp."""
_cache[key] = data
_cache_timestamps[key] = time.time()
_last_success[endpoint_type] = datetime.now()

def _is_stale(endpoint_type: str, max_age_hours: int = 2) -> bool:
"""Check if data is stale (older than max_age_hours)."""
last = _last_success.get(endpoint_type)
if last is None:
return True
age = datetime.now() - last
return age > timedelta(hours=max_age_hours)

def _log_stale_warning(endpoint_type: str):
"""Log a warning about stale data."""
last = _last_success.get(endpoint_type)
if last:
age = datetime.now() - last
print(f"⚠️ Warning: {endpoint_type} data is stale (last updated {age.total_seconds()/3600:.1f} hours ago)")
else:
print(f"⚠️ Warning: {endpoint_type} data has never been successfully fetched")

def _make_request(endpoint: str, params: Dict[str, Any] = None) -> Optional[Dict]:
"""Make a request to Finnhub API."""
if not FINNHUB_API_KEY:
print("Error: FINNHUB_API_KEY not set")
return None

url = f"{BASE_URL}{endpoint}"
default_params = {"token": FINNHUB_API_KEY}
if params:
    default_params.update(params)

try:
    response = requests.get(url, params=default_params, timeout=30)
    response.raise_for_status()
    return response.json()
except requests.RequestException as e:
    print(f"Error fetching {endpoint}: {e}")
    return None

def get_quote(symbol: str) -> Optional[Dict]:
"""Get current quote for a symbol."""
cache_key = _get_cache_key("quote", symbol)

if _is_cached(cache_key, TTL_QUOTES):
    return _get_cached(cache_key)

data = _make_request("/quote", {"symbol": symbol})
if data:
    _set_cache(cache_key, data, "quote")
    return data

# Return stale data if available, but warn
if cache_key in _cache:
    _log_stale_warning("quote")
    return _cache[cache_key]
return None

def get_company_news(symbol: str, from_date: str, to_date: str) -> list:
"""Get company news for a date range."""
cache_key = _get_cache_key("news", f"{symbol}:{from_date}:{to_date}")

if _is_cached(cache_key, TTL_NEWS):
    return _get_cached(cache_key)

data = _make_request("/company-news", {
    "symbol": symbol,
    "from": from_date,
    "to": to_date
})

if data and isinstance(data, list):
    _set_cache(cache_key, data, "news")
    return data

# Return stale data if available
if cache_key in _cache:
    _log_stale_warning("news")
    return _cache[cache_key]
return []

def get_insider_sentiment(symbol: str, from_date: str, to_date: str) -> Optional[Dict]:
"""Get insider sentiment data."""
cache_key = _get_cache_key("sentiment", f"{symbol}:{from_date}:{to_date}")

if _is_cached(cache_key, TTL_SENTIMENT):
    return _get_cached(cache_key)

# Finnhub uses a different endpoint for insider sentiment
data = _make_request("/stock/insider-sentiment", {
    "symbol": symbol,
    "from": from_date,
    "to": to_date
})

if data:
    _set_cache(cache_key, data, "sentiment")
    return data

if cache_key in _cache:
    _log_stale_warning("sentiment")
    return _cache[cache_key]
return None

def get_top_gainers_losers(exchange: str = "US") -> Dict[str, list]:
"""Get top gainers and losers."""
cache_key = _get_cache_key("gainers_losers", exchange)

if _is_cached(cache_key, TTL_WATCHLIST):
    return _get_cached(cache_key)

# Use the stock scanner endpoint for trending stocks
data = _make_request("/stock/calendar/earnings", {"from": "", "to": ""})

# Alternative: get quote for major indices to find trending
# For now, we'll use a simpler approach with high-volume stocks
trending = [
    {"symbol": "AMD", "name": "AMD"},
    {"symbol": "CRM", "name": "Salesforce"},
    {"symbol": "NFLX", "name": "Netflix"},
    {"symbol": "DIS", "name": "Disney"},
    {"symbol": "UBER", "name": "Uber"},
    {"symbol": "COIN", "name": "Coinbase"},
    {"symbol": "PLTR", "name": "Palantir"},
    {"symbol": "SNOW", "name": "Snowflake"},
    {"symbol": "ROKU", "name": "Roku"},
    {"symbol": "SQ", "name": "Block"},
    {"symbol": "ZM", "name": "Zoom"},
    {"symbol": "SHOP", "name": "Shopify"},
    {"symbol": "TWLO", "name": "Twilio"},
    {"symbol": "DDOG", "name": "Datadog"},
    {"symbol": "CRWD", "name": "CrowdStrike"},
]

result = {"trending": trending}
_set_cache(cache_key, result, "watchlist")
return result

def get_earnings_calendar(from_date: str, to_date: str) -> list:
"""Get earnings calendar for a date range."""
cache_key = _get_cache_key("earnings", f"{from_date}:{to_date}")

if _is_cached(cache_key, TTL_WATCHLIST):
    return _get_cached(cache_key)

data = _make_request("/calendar/earnings", {
    "from": from_date,
    "to": to_date
})

if data and isinstance(data, list):
    _set_cache(cache_key, data, "watchlist")
    return data
return []

def check_staleness() -> Dict[str, bool]:
"""Check which data sources are stale."""
return {
"quote": _is_stale("quote"),
"news": _is_stale("news"),
"sentiment": _is_stale("sentiment"),
"watchlist": _is_stale("watchlist"),
}

def should_skip_briefing() -> bool:
"""Check if we should skip briefing due to stale/failed data."""
# Only skip if quote data is completely unavailable
# News is optional - briefing can proceed without it
quote_keys = [k for k in _cache.keys() if k.startswith("quote")]
if not quote_keys:
return True

# Check if quote data is too old (> 2 hours)
if _is_stale("quote", max_age_hours=2):
    # Only skip if there are NO quotes in cache at all
    if not quote_keys:
        return True

return False