# Install dependencies
# pip install requests pandas numpy matplotlib

import requests
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Assymetrix API configuration
API_BASE = "https://data.assymetrix.com/api/v1/sdk"
API_KEY = "your_api_key"  # Get yours free at data.assymetrix.com

headers = {"Authorization": f"Bearer {API_KEY}"}

def get_markets(query=None, platform=None):
    """Search markets across all indexed platforms."""
    params = {}
    if query:
        params["q"] = query
    if platform:
        params["platform"] = platform
    r = requests.get(f"{API_BASE}/markets", headers=headers, params=params)
    return r.json()

def get_pricing(market_id, interval="1h", start=None, end=None):
    """Pull OHLCV candle data for a specific market."""
    params = {"interval": interval}
    if start:
        params["start"] = start
    if end:
        params["end"] = end
    r = requests.get(
        f"{API_BASE}/markets/{market_id}/pricing",
        headers=headers,
        params=params
    )
    return pd.DataFrame(r.json()["candles"])

def get_trades(market_id, start=None, end=None):
    """Pull historical trades for a market."""
    params = {}
    if start:
        params["start"] = start
    if end:
        params["end"] = end
    r = requests.get(
        f"{API_BASE}/markets/{market_id}/trades",
        headers=headers,
        params=params
    )
    return pd.DataFrame(r.json()["trades"])

# Find Iran ceasefire markets across all platforms
markets = get_markets(query="iran ceasefire", platform=None)

for m in markets["results"][:5]:
    print(f"  {m['platform']:12s}  {m['title']}")
    print(f"               Volume: ${m['volume']:,.0f}  "
          f"Status: {m['status']}")
    print()

# Pull 15-minute candles for a high-volume resolved market
# Iran ceasefire by April 30 — Polymarket
candles = get_pricing(
    market_id="pm-iran-ceasefire-apr30",
    interval="15m",
    start="2026-03-15",
    end="2026-04-30"
)

candles["timestamp"] = pd.to_datetime(candles["timestamp"])
candles = candles.set_index("timestamp")

# Calculate intraday returns and volatility
candles["return"] = candles["close"].pct_change()
candles["vol_20"] = candles["return"].rolling(20).std()

# Detect overreaction: price moves more than 2 standard
# deviations from the 20-period rolling mean
candles["mean_20"] = candles["close"].rolling(20).mean()
candles["upper"] = candles["mean_20"] + 2 * candles["vol_20"] * candles["close"]
candles["lower"] = candles["mean_20"] - 2 * candles["vol_20"] * candles["close"]

candles["signal"] = 0
candles.loc[candles["close"] < candles["lower"], "signal"] = 1   # Buy (oversold)
candles.loc[candles["close"] > candles["upper"], "signal"] = -1  # Sell (overbought)

print(f"Total candles: {len(candles)}")
print(f"Buy signals:   {(candles['signal'] == 1).sum()}")
print(f"Sell signals:  {(candles['signal'] == -1).sum()}")

def backtest_mean_reversion(candles, hold_periods=8):
    """
    Mean reversion strategy:
    - Buy when price drops below lower band (2 std devs)
    - Sell when price rises above upper band
    - Hold for N periods (default: 8 = 2 hours at 15min candles)
    - Assume we buy/sell at the close of the signal candle
    """
    trades = []

    for i in range(len(candles) - hold_periods):
        if candles["signal"].iloc[i] == 1:  # Buy signal
            entry = candles["open"].iloc[i + 1] 
           exit_price = candles["close"].iloc[i + hold_periods + 1]
            pnl = exit_price - entry
            trades.append({
                "entry_time": candles.index[i],
                "direction": "LONG",
                "entry": entry,
                "exit": exit_price,
                "pnl": pnl,
                "return": pnl / entry
            })
        elif candles["signal"].iloc[i] == -1:  # Sell signal
           entry = candles["open"].iloc[i + 1] 
           exit_price = candles["close"].iloc[i + hold_periods + 1]
            pnl = entry - exit_price
            trades.append({
                "entry_time": candles.index[i],
                "direction": "SHORT",
                "entry": entry,
                "exit": exit_price,
                "pnl": pnl,
                "return": pnl / entry
            })

    return pd.DataFrame(trades)

results = backtest_mean_reversion(candles, hold_periods=8)
max_drawdown = (results['pnl'].cumsum()- results['pnl'].cumsum().cummax()
).min() 
print(f"Total trades:    {len(results)}")
print(f"Win rate:        {(results['pnl'] > 0).mean():.1%}")
print(f"Avg return:      {results['return'].mean():.2%}")
print(f"Total P&L:       {results['pnl'].sum():.4f}")
print(f"Max drawdown: {max_drawdown:.4f}") 
print(f"Sharpe ratio:    {results['return'].mean() / results['return'].std() * np.sqrt(252):.2f}")

# Pull hourly candles for the same event on two platforms
pm_candles = get_pricing(
    market_id="pm-fed-rate-hold-may",
    interval="1h",
    start="2026-04-01",
    end="2026-05-01"
)

kalshi_candles = get_pricing(
    market_id="kx-fed-rate-hold-may",
    interval="1h",
    start="2026-04-01",
    end="2026-05-01"
)

# Merge on timestamp
pm_candles["timestamp"] = pd.to_datetime(pm_candles["timestamp"])
kalshi_candles["timestamp"] = pd.to_datetime(kalshi_candles["timestamp"])

merged = pd.merge(
    pm_candles[["timestamp", "close"]].rename(columns={"close": "pm_price"}),
    kalshi_candles[["timestamp", "close"]].rename(columns={"close": "kx_price"}),
    on="timestamp",
    how="inner"
)

# Calculate spread
merged["spread"] = merged["pm_price"] - merged["kx_price"]
merged["spread_ma"] = merged["spread"].rolling(24).mean()
merged["spread_std"] = merged["spread"].rolling(24).std()

print(f"Mean spread:     {merged['spread'].mean():.4f} ({merged['spread'].mean():.1%})")
print(f"Max spread:      {merged['spread'].max():.4f} ({merged['spread'].max():.1%})")
print(f"Min spread:      {merged['spread'].min():.4f} ({merged['spread'].min():.1%})")
print(f"Std deviation:   {merged['spread'].std():.4f}")

def backtest_convergence(merged, entry_threshold=2.0, exit_threshold=0.5,
                          hold_limit=48):
    """
    Cross-venue convergence strategy:
    - Enter when spread exceeds N standard deviations from mean
    - Exit when spread returns to within M standard deviations
    - Hard stop at hold_limit periods
    - Long the cheaper platform, short the expensive one
    """
    trades = []
    position = None

    for i in range(24, len(merged)):
        spread = merged["spread"].iloc[i]
        mean = merged["spread_ma"].iloc[i]
        std = merged["spread_std"].iloc[i]

        if std == 0:
            continue

        z_score = (spread - mean) / std

        # Entry
        if position is None and abs(z_score) > entry_threshold:
            position = {
                "entry_idx": i,
                "entry_spread": spread,
                "direction": "SHORT_SPREAD" if z_score > 0 else "LONG_SPREAD",
                "entry_z": z_score
            }

        # Exit
        elif position is not None:
            periods_held = i - position["entry_idx"]
            exit_z = (spread - mean) / std

            if abs(exit_z) < exit_threshold or periods_held >= hold_limit:
sign = -1 if position["direction"] == "SHORT_SPREAD" else 1
pnl = sign * (spread - position["entry_spread"]) 

                trades.append({
                    "entry_time": merged["timestamp"].iloc[position["entry_idx"]],
                    "exit_time": merged["timestamp"].iloc[i],
                    "direction": position["direction"],
                    "entry_spread": position["entry_spread"],
                    "exit_spread": spread,
                    "periods_held": periods_held,
                    "pnl": pnl
                })
                position = None

    return pd.DataFrame(trades)

convergence_results = backtest_convergence(merged)

print(f"Total trades:    {len(convergence_results)}")
print(f"Win rate:        {(convergence_results['pnl'] > 0).mean():.1%}")
print(f"Avg P&L:         {convergence_results['pnl'].mean():.4f}")
print(f"Total P&L:       {convergence_results['pnl'].sum():.4f}")
print(f"Avg hold (hrs):  {convergence_results['periods_held'].mean():.1f}")

# Pull 15-minute candles with volume
candles = get_pricing(
    market_id="pm-2028-president-vance",
    interval="15m",
    start="2026-04-01",
    end="2026-04-30"
)

candles["timestamp"] = pd.to_datetime(candles["timestamp"])
candles = candles.set_index("timestamp")

# Price momentum: 4-hour (16 candles) rate of change
candles["momentum"] = candles["close"].pct_change(16)

# Volume confirmation: is current volume above 2x the 20-period average?
candles["vol_avg"] = candles["volume"].rolling(20).mean()
candles["vol_confirmed"] = candles["volume"] > (2 * candles["vol_avg"])

# Pull trade data for on-chain confirmation
trades = get_trades(
    market_id="pm-2028-president-vance",
    start="2026-04-01",
    end="2026-04-30"
)

trades["timestamp"] = pd.to_datetime(trades["timestamp"])

# Count unique wallets per hour as a proxy for "new participants"
trades["hour"] = trades["timestamp"].dt.floor("h")
wallet_counts = trades.groupby("hour")["wallet"].nunique().reset_index()
wallet_counts.columns = ["hour", "unique_wallets"]
wallet_counts["wallet_avg"] = wallet_counts["unique_wallets"].rolling(24).mean()
wallet_counts["new_participants"] = (
    wallet_counts["unique_wallets"] > 1.5 * wallet_counts["wallet_avg"]
)

# Combine signals
candles["hour"] = candles.index.floor("h")
candles = candles.merge(
    wallet_counts[["hour", "new_participants"]],
    on="hour",
    how="left"
)
candles["new_participants"] = candles["new_participants"].fillna(False)

# Triple confirmation signal
candles["signal"] = 0
candles.loc[
    (candles["momentum"] > 0.03) &        # 3%+ move in 4 hours
    (candles["vol_confirmed"]) &            # Volume above 2x average
    (candles["new_participants"]),           # New wallets entering
    "signal"
] = 1  # Buy

candles.loc[
    (candles["momentum"] < -0.03) &
    (candles["vol_confirmed"]) &
    (candles["new_participants"]),
    "signal"
] = -1  # Sell

print(f"Triple-confirmed buy signals:  {(candles['signal'] == 1).sum()}")
print(f"Triple-confirmed sell signals: {(candles['signal'] == -1).sum()}")