def get_request_headers() -> dict:
    api_key = os.getenv("EM_API_KEY")
    if not api_key:
        raise ValueError("Please set EM_API_KEY in your environment.")
    r = requests.post(
        f"{API_HOST}/v1/token",
        data={"api_key": api_key},
        headers={"Content-Type": "application/x-www-form-urlencoded"},
        timeout=15,
    )
    r.raise_for_status()
    token = r.json()["access_token"]
    return {"Authorization": f"Bearer {token}"}


request_headers = get_request_headers()


def get_me() -> dict:
    r = requests.get(f"{API_HOST}/v1/me", headers=request_headers, timeout=15)
    r.raise_for_status()
    return r.json()


me_info = get_me()
rate_limit = me_info.get("api_rate_limit_per_second") or 1
min_interval = 1.0 / rate_limit


def rate_limited_get(url: str, **kwargs) -> requests.Response:
    r = requests.get(url, **kwargs)
    time.sleep(min_interval)
    return r

START_DATE = datetime(2021, 1, 1)
print(f"Authenticated. Rate limit: {rate_limit} request(s) per second.")

def fetch_date_cursor_pages(
    url: str,
    data_key: str,
    request_headers: dict,
    params: dict | None = None,
    timeout: int = 15,
    max_pages: int | None = None,
) -> list[dict]:
    """Empirical Markets API Data Cursor Pagination Handler."""
    params = dict(params or {})
    frames = []
    page_count = 0
    while True:
        response = rate_limited_get(
            url,
            params=params,
            headers=request_headers,
            timeout=timeout,
        )
        response.raise_for_status()
        payload = response.json()

        rows = payload.get(data_key, [])
        if rows:
            frames.extend(rows)

        cursor = payload.get("date_cursor") or {}
        has_more = cursor.get("has_more", False)
        next_cursor = cursor.get("next_cursor")

        page_count += 1
        if max_pages is not None and page_count >= max_pages:
            break
        if not has_more or not next_cursor:
            break
        params["date_cursor"] = next_cursor
    return frames

def get_ticker_quant_signal(
    ticker: str,
    request_headers: dict,
    signal: str = "flow-ratio",
    start_date: datetime = START_DATE,
    end_date: datetime | None = None,
    universe: str = "all",  # all, etfs, or equities
    limit: int = 756,
) -> pd.DataFrame:
    params = {
        "start_date": start_date.strftime("%Y-%m-%d"),
        "universe": universe,
        "variant": "default",
        "limit": limit,
    }
    if end_date is not None:
        params["end_date"] = end_date.strftime("%Y-%m-%d")
    frames = fetch_date_cursor_pages(
        f"{API_HOST}/v1/quant/signals/{signal}/tickers/{ticker}",
        data_key="data",
        params=params,
        request_headers=request_headers,
    )
    df = pd.DataFrame(frames)
    df["date"] = pd.to_datetime(df["date"])
    return df.set_index("date").sort_index()


flow_ratio_df = get_ticker_quant_signal("AAPL", request_headers=request_headers, signal="flow-ratio")
flow_ratio_df

def get_ticker_ohlc_data(
    ticker: str,
    request_headers: dict,
    start_date: datetime = START_DATE,
    chunk_size: int = 1260,
) -> pd.DataFrame:
    print(f"Fetching OHLC data for ticker: {ticker}")
    frames = fetch_date_cursor_pages(
        f"{API_HOST}/v1/ohlc/tickers/{ticker}",
        data_key="data",
        params={"limit": chunk_size, "start_date": start_date.strftime("%Y-%m-%d")},
        request_headers=request_headers,
    )
    if not frames:
        return pd.DataFrame()
    df = pd.DataFrame(frames)
    df["date"] = pd.to_datetime(df["date"])
    return df.set_index("date").sort_index()

ohlc_df = get_ticker_ohlc_data("AAPL", request_headers=request_headers)
ohlc_df

df = ohlc_df.merge(
    flow_ratio_df[["value"]].rename(columns={"value": "flow_ratio"}),
    how="left",
    left_index=True,
    right_index=True,
)
df

def plot_flow_ratio_signal(df: pd.DataFrame):
    ticker = df["ticker"].iloc[0]
    fig, ax1 = plt.subplots(figsize=(12, 6))
    ax1.set_title(f"{ticker} Price and Flow Ratio Over Time")
    ax1.plot(df.index, df["close"], label="Close Price", color="black")
    ax1.set_xlabel("Date")
    ax1.set_ylabel("Close Price", color="black")
    ax1.tick_params(axis="y", labelcolor="black") 
    ax2 = ax1.twinx()
    ax2.plot(df.index, df["flow_ratio"], label="Flow Ratio", color="blue")
    ax2.set_ylabel("Flow Ratio", color="blue")
    ax2.tick_params(axis="y", labelcolor="blue")
    fig.tight_layout()
    plt.show()

plot_flow_ratio_signal(df)

df["flow_ratio"].hist(density=True, bins=30, alpha=0.6)
df["flow_ratio"].plot.kde(color="darkblue")
plt.title("Distribution of Flow Ratio Values")
plt.xlabel("Flow Ratio")
plt.ylabel("Density")
plt.show()

def get_ticker_signal_anomaly(
    ticker: str,
    request_headers: dict,
    signal: str = "flow-ratio",
    start_date: datetime = START_DATE,
) -> pd.DataFrame:
    r = requests.get(
        f"{API_HOST}/v1/quant/signals/{signal}/tickers/{ticker}/anomalies",
        headers=request_headers,
        params={"start_date": start_date.strftime("%Y-%m-%d")}
    )
    r.raise_for_status()
    anomalies = r.json().get("anomalies", [])
    df = pd.DataFrame(anomalies)
    if df.empty:
        return df
    df["date"] = pd.to_datetime(df["date"])
    df = df.set_index("date").sort_index()
    df = df.rename(columns={"value": "anomaly"})
    return df

def plot_ticker_signal_anomalies(df: pd.DataFrame):
    is_anomaly_mask = ~df["anomaly"].isna()
    fig, ax1 = plt.subplots(figsize=(12, 6))
    ax1.set_title(f"{df['ticker'].iloc[0]} Flow Ratio Anomalies Over Time")
    ax1.plot(df.index, df["close"], label="Close Price", color="black")
    ax1.set_xlabel("Date")
    ax1.set_ylabel("Close Price", color="black")
    ax1.tick_params(axis="y", labelcolor="black")
    ax1.scatter(
        df.index[is_anomaly_mask],
        df["close"][is_anomaly_mask],
        label="Anomalies",
        color="blue",
        marker="o",
        s=100
    )
    fig.tight_layout()
    plt.show()

flow_ratio_anomaly_df = get_ticker_signal_anomaly("AAPL", request_headers=request_headers, signal="flow-ratio")
df = df.merge(
    flow_ratio_anomaly_df[["anomaly"]],
    how="left",
    left_index=True,
    right_index=True,
)
plot_ticker_signal_anomalies(df)

tickers = ["SPY", "MSFT", "NVDA", "JNJ", "GLD"]

for t in tickers:
    t_ohlc_df = get_ticker_ohlc_data(t, request_headers=request_headers, start_date=START_DATE)
    t_anomaly = get_ticker_signal_anomaly(t, request_headers=request_headers, signal="flow-ratio", start_date=START_DATE)
    t_df = t_ohlc_df.merge(
        t_anomaly[["anomaly"]],
        how="left",
        left_index=True,
        right_index=True,
    )
    plot_ticker_signal_anomalies(t_df)