"""On-Chain Fundamentals: DeFi TVL as Alternative Data - source and analyze DeFi TVL for crypto trading signals."""

import warnings

warnings.filterwarnings("ignore")

import plotly.graph_objects as go
import polars as pl
from plotly.subplots import make_subplots

from data import load_coingecko_ohlcv, load_defillama_chain_tvl
from utils.style import COLORS  # activates the ml4t Plotly template on import

print("On-Chain Fundamentals: DeFi TVL Analysis")

# Production defaults - Papermill injects overrides for CI

total_tvl = load_defillama_chain_tvl("total").with_columns(
    (pl.col("tvl_usd") / 1e9).alias("tvl_bn")
)
print(f"Total TVL data: {total_tvl.shape}")
print(f"Date range: {total_tvl['timestamp'].min()} → {total_tvl['timestamp'].max()}")
total_tvl.tail(5)

# Per-chain TVL (Ethereum, Solana, BSC, Arbitrum by default)
chains = ["Ethereum", "Solana", "BSC", "Arbitrum"]
chain_tvls = []
for chain in chains:
    df = load_defillama_chain_tvl(chain).rename({"tvl_usd": f"tvl_{chain.lower()}"})
    chain_tvls.append(df)
    print(f"  {chain}: {len(df):,} observations")

chain_data = chain_tvls[0]
for df in chain_tvls[1:]:
    chain_data = chain_data.join(df, on="timestamp", how="full", coalesce=True)
chain_data = chain_data.sort("timestamp").fill_null(0)
print(f"\nChain TVL data: {chain_data.shape}")
chain_data.tail(5)

# ETH prices come from the same canonical downloader
# (python data/crypto/onchain/download.py --dataset coingecko).
# Free-tier window is the trailing 365 days - re-run the downloader to
# refresh. For longer history, use a provider with a paid tier.
# CoinGecko's free tier appends a live intraday snapshot for the current
# day on top of that day's 00:00 daily bar, so the final calendar day can
# arrive twice. Collapse to one row per day (keep the most recent snapshot)
# before anything downstream joins or computes on it.
eth_prices = load_coingecko_ohlcv("ethereum").unique(
    subset="timestamp", keep="last", maintain_order=True
)
print(f"ETH prices: {eth_prices.shape}")
print(f"Window: {eth_prices['timestamp'].min()} → {eth_prices['timestamp'].max()}")

combined = (
    total_tvl.join(
        eth_prices.rename({"price_usd": "eth_price", "volume_usd": "eth_volume"}),
        on="timestamp",
        how="inner",
    )
    .join(
        chain_data.with_columns(pl.col("timestamp").cast(pl.Date)),
        on="timestamp",
        how="left",
    )
    .fill_null(strategy="forward")
)

print(f"Combined dataset: {combined.shape}, columns: {combined.columns}")
combined.tail(5)

# Plot TVL vs ETH price
fig = make_subplots(
    rows=2,
    cols=1,
    shared_xaxes=True,
    vertical_spacing=0.1,
    subplot_titles=("Total DeFi TVL", "ETH Price"),
    row_heights=[0.5, 0.5],
)

fig.add_trace(
    go.Scatter(
        x=combined["timestamp"],
        y=combined["tvl_bn"],
        name="TVL ($B)",
        line=dict(color=COLORS["blue"]),
        fill="tozeroy",
        fillcolor="rgba(10, 22, 40, 0.15)",
    ),
    row=1,
    col=1,
)

fig.add_trace(
    go.Scatter(
        x=combined["timestamp"],
        y=combined["eth_price"],
        name="ETH Price",
        line=dict(color=COLORS["amber"]),
    ),
    row=2,
    col=1,
)

fig.update_layout(
    title="DeFi TVL and ETH price rose and fell together over the trailing year",
    height=600,
    showlegend=True,
)
fig.update_yaxes(title_text="TVL (Billions USD)", row=1, col=1)
fig.update_yaxes(title_text="ETH Price (USD)", row=2, col=1)
fig.show()

chain_cols = [
    c for c in combined.columns if c.startswith("tvl_") and c not in {"tvl_bn", "tvl_usd"}
]
recent = combined.filter(pl.col("timestamp") > pl.col("timestamp").max() - pl.duration(days=30))
# Proper display names (acronyms like BSC survive .title(), which would print "Bsc").
chain_names = {c.lower(): c for c in chains}
chain_totals = {
    chain_names.get(col.replace("tvl_", ""), col.replace("tvl_", "").title()): recent[col].mean()
    / 1e9
    for col in chain_cols
}

fig = go.Figure(
    data=[
        go.Pie(
            labels=list(chain_totals.keys()),
            values=list(chain_totals.values()),
            hole=0.4,
            marker=dict(
                colors=[COLORS["blue"], COLORS["amber"], COLORS["copper"], COLORS["slate"]]
            ),
        )
    ]
)
fig.update_layout(title="Ethereum Dominates DeFi TVL - Trailing 30-Day Average")
fig.show()

def create_tvl_features(df: pl.DataFrame) -> pl.DataFrame:
    """Compute TVL momentum, valuation, and regime features."""
    return df.with_columns(
        pl.col("tvl_bn").pct_change(7).alias("tvl_growth_7d"),
        pl.col("tvl_bn").pct_change(30).alias("tvl_growth_30d"),
        pl.col("tvl_bn").pct_change(90).alias("tvl_growth_90d"),
        pl.col("tvl_bn").rolling_mean(7).alias("tvl_ma7"),
        pl.col("tvl_bn").rolling_mean(30).alias("tvl_ma30"),
        (
            (pl.col("tvl_bn") - pl.col("tvl_bn").rolling_mean(90))
            / pl.col("tvl_bn").rolling_std(90)
        ).alias("tvl_zscore"),
        pl.col("eth_price").pct_change(7).alias("eth_return_7d"),
        pl.col("eth_price").pct_change(30).alias("eth_return_30d"),
    ).with_columns(
        (pl.col("tvl_bn") / pl.col("eth_price")).alias("tvl_price_ratio"),
        (pl.col("tvl_growth_30d") - pl.col("eth_return_30d")).alias("tvl_eth_spread"),
        # Warm-up rows without a valid 90-day z-score stay null (unclassified),
        # never fall through to "neutral"; the regime aggregation excludes them.
        pl.when(pl.col("tvl_zscore").is_null())
        .then(pl.lit(None, dtype=pl.String))
        .when(pl.col("tvl_zscore") > 1.0)
        .then(pl.lit("expansion"))
        .when(pl.col("tvl_zscore") < -1.0)
        .then(pl.lit("contraction"))
        .otherwise(pl.lit("neutral"))
        .alias("tvl_regime"),
    )


features = create_tvl_features(combined)
print(f"Features created: {len(features.columns)} columns")

features.select(
    "timestamp",
    "tvl_bn",
    "eth_price",
    "tvl_growth_30d",
    "eth_return_30d",
    "tvl_eth_spread",
    "tvl_regime",
).tail(10)

# Calculate forward returns
analysis = features.with_columns(
    [
        pl.col("eth_return_30d").shift(-30).alias("fwd_eth_return_30d"),
        pl.col("eth_return_7d").shift(-7).alias("fwd_eth_return_7d"),
    ]
).filter(pl.col("fwd_eth_return_30d").is_not_null())

# Regime analysis
regime_returns = (
    analysis.filter(pl.col("tvl_regime").is_not_null())
    .group_by("tvl_regime")
    .agg(
        pl.col("fwd_eth_return_30d").mean().alias("avg_fwd_return"),
        pl.col("fwd_eth_return_30d").std().alias("std_fwd_return"),
        pl.len().alias("n_obs"),
        (pl.col("fwd_eth_return_30d") > 0).mean().alias("win_rate"),
    )
    .sort("avg_fwd_return", descending=True)
)

regime_returns

# Visualize regime returns
fig = go.Figure(
    data=[
        go.Bar(
            x=regime_returns["tvl_regime"],
            y=regime_returns["avg_fwd_return"],
            text=[f"{r:.1%}" if r is not None else "N/A" for r in regime_returns["avg_fwd_return"]],
            textposition="auto",
            # Color by the sign of the average forward return (green = positive, red = negative)
            marker_color=[
                COLORS["positive"] if (r is not None and r > 0) else COLORS["negative"]
                for r in regime_returns["avg_fwd_return"]
            ],
        )
    ]
)

fig.update_layout(
    title="Depressed-TVL (Contraction) Regime Precedes the Best Forward ETH Return",
    xaxis_title="TVL Regime (90-day z-score)",
    yaxis_title="Average Forward 30-Day Return",
    yaxis_tickformat=".1%",
    height=400,
)
fig.show()

ic = (
    analysis.filter(
        pl.col("tvl_growth_30d").is_not_null() & pl.col("fwd_eth_return_30d").is_not_null()
    )
    .select(pl.corr("tvl_growth_30d", "fwd_eth_return_30d"))
    .item()
)
band = "moderate" if abs(ic) > 0.1 else "weak" if abs(ic) > 0.05 else "negligible"
print(f"IC(TVL growth → forward 30d ETH return) = {ic:+.3f}  ({band} linear signal)")

features.select(
    pl.col("tvl_bn").min().round(1).alias("tvl_min_bn"),
    pl.col("tvl_bn").max().round(1).alias("tvl_max_bn"),
    pl.col("tvl_bn").mean().round(1).alias("tvl_mean_bn"),
    pl.col("tvl_bn").std().round(1).alias("tvl_std_bn"),
    (pl.col("tvl_growth_30d").mean() * 100).round(2).alias("avg_30d_growth_pct"),
    (pl.col("tvl_eth_spread").mean() * 100).round(2).alias("avg_tvl_eth_spread_pct"),
)

features.tail(1).select(
    "timestamp",
    pl.col("tvl_bn").round(1).alias("tvl_bn"),
    pl.col("eth_price").round(0).alias("eth_price"),
    "tvl_regime",
)