#!/usr/bin/env python3
"""
Fetch ALL markets ending soon from both Polymarket and Kalshi
"""

import requests
import json
from datetime import datetime, timedelta
import os
from dotenv import load_dotenv

load_dotenv()

def fetch_polymarket_markets_ending_soon(hours=48):
    """Fetch Polymarket markets ending in next X hours"""
    url = "https://gamma-api.polymarket.com/markets"
    
    now = datetime.now()
    cutoff = now + timedelta(hours=hours)
    
    all_markets = []
    offset = 0
    limit = 100
    
    while True:
        params = {
            "closed": "false",
            "active": "true",
            "limit": limit,
            "offset": offset,
            "_sort": "endDate",
            "_order": "asc"
        }
        
        response = requests.get(url, params=params)
        response.raise_for_status()
        markets = response.json()
        
        if not markets:
            break
            
        for market in markets:
            try:
                end_date = datetime.fromisoformat(market.get("endDate", "").replace('Z', '+00:00'))
                if end_date <= cutoff:
                    all_markets.append(market)
                elif end_date > cutoff:
                    return all_markets  # Stop when we hit markets too far out
            except:
                continue
        
        offset += limit
        if len(markets) < limit:
            break
    
    return all_markets

def fetch_kalshi_markets_ending_soon(hours=48):
    """Fetch Kalshi markets ending in next X hours"""
    api_key = os.getenv("KALSHI_API_KEY")
    if not api_key:
        return []
    
    url = "https://api.elections.kalshi.com/trade-api/v2/markets"
    headers = {"Authorization": f"Bearer {api_key}"}
    
    now = datetime.now()
    cutoff = now + timedelta(hours=hours)
    
    all_markets = []
    cursor = None
    
    while True:
        params = {
            "limit": 200,
            "status": "open"
        }
        if cursor:
            params["cursor"] = cursor
        
        try:
            response = requests.get(url, headers=headers, params=params)
            response.raise_for_status()
            data = response.json()
            markets = data.get("markets", [])
            
            for market in markets:
                try:
                    close_time = datetime.fromisoformat(market.get("close_time", "").replace('Z', '+00:00'))
                    if close_time <= cutoff:
                        all_markets.append(market)
                except:
                    continue
            
            cursor = data.get("cursor")
            if not cursor or not markets:
                break
                
        except Exception as e:
            print(f"Error fetching Kalshi: {e}")
            break
    
    return all_markets

def prepare_dashboard_data(poly_markets, kalshi_markets):
    """Prepare data for dashboard"""
    
    poly_data = []
    for pm in poly_markets:
        try:
            end_date = datetime.fromisoformat(pm.get("endDate", "").replace('Z', '+00:00'))
            hours_left = (end_date - datetime.now()).total_seconds() / 3600
            
            prices = json.loads(pm.get("outcomePrices", "[0, 0]"))
            yes_price = float(prices[0]) if len(prices) > 0 else 0
            
            poly_data.append({
                "question": pm.get("question", ""),
                "slug": pm.get("slug", ""),
                "yes_price": yes_price,
                "volume": pm.get("volumeNum", 0),
                "liquidity": pm.get("liquidityNum", 0),
                "end_date": pm.get("endDate", ""),
                "hours_left": hours_left,
                "url": f"https://polymarket.com/event/{pm.get('slug', '')}"
            })
        except:
            continue
    
    kalshi_data = []
    for km in kalshi_markets:
        try:
            close_time = datetime.fromisoformat(km.get("close_time", "").replace('Z', '+00:00'))
            hours_left = (close_time - datetime.now()).total_seconds() / 3600
            
            kalshi_data.append({
                "title": km.get("title", ""),
                "ticker": km.get("ticker", ""),
                "yes_bid": km.get("yes_bid", 0) / 100,
                "yes_ask": km.get("yes_ask", 0) / 100,
                "volume": km.get("volume", 0),
                "open_interest": km.get("open_interest", 0),
                "close_time": km.get("close_time", ""),
                "hours_left": hours_left,
                "url": f"https://kalshi.com/markets/{km.get('ticker', '')}"
            })
        except:
            continue
    
    # Sort by hours left
    poly_data.sort(key=lambda x: x["hours_left"])
    kalshi_data.sort(key=lambda x: x["hours_left"])
    
    return {
        "polymarket": poly_data,
        "kalshi": kalshi_data,
        "generated_at": datetime.now().isoformat()
    }

def main():
    hours = 48
    
    print(f"Fetching Polymarket markets ending in next {hours} hours...")
    poly_markets = fetch_polymarket_markets_ending_soon(hours)
    print(f"Found {len(poly_markets)} Polymarket markets")
    
    print(f"\nFetching Kalshi markets ending in next {hours} hours...")
    kalshi_markets = fetch_kalshi_markets_ending_soon(hours)
    print(f"Found {len(kalshi_markets)} Kalshi markets")
    
    print("\nPreparing dashboard data...")
    dashboard_data = prepare_dashboard_data(poly_markets, kalshi_markets)
    
    with open("all_markets_data.json", "w") as f:
        json.dump(dashboard_data, f, indent=2)
    
    print(f"\n✓ Saved {len(dashboard_data['polymarket'])} Polymarket + {len(dashboard_data['kalshi'])} Kalshi markets")
    print(f"Total: {len(dashboard_data['polymarket']) + len(dashboard_data['kalshi'])} markets ending soon")

if __name__ == "__main__":
    main()