"""Alternative Data Evaluation: DeFi TVL Case Study - measure four evaluation dimensions on a real alt-data feed."""

import warnings

warnings.filterwarnings("ignore")

from dataclasses import dataclass

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

print("Alternative Data Evaluation: DeFi TVL Case Study")

# Production defaults - Papermill injects overrides for CI

tvl_data = load_defillama_chain_tvl("total").with_columns((pl.col("tvl_usd") / 1e9).alias("tvl_bn"))

# CoinGecko returns two rows for the download day (an intraday roll-up
# and a daily summary); collapse to one row per date by taking the last
# observation. Without this, the inner join below would propagate the
# duplicate into every downstream feature.
eth_data = (
    load_coingecko_ohlcv("ethereum")
    .select(pl.col("timestamp"), pl.col("price_usd").alias("eth_price"))
    .group_by("timestamp")
    .agg(pl.col("eth_price").last())
    .sort("timestamp")
)

print(
    f"TVL observations: {len(tvl_data):,} ({tvl_data['timestamp'].min()} → {tvl_data['timestamp'].max()})"
)
print(
    f"ETH observations: {len(eth_data):,} ({eth_data['timestamp'].min()} → {eth_data['timestamp'].max()})"
)

# CoinGecko free tier is 365 days, so the merge is bounded by ETH coverage.
data = tvl_data.join(eth_data, on="timestamp", how="inner").sort("timestamp")
print(
    f"Combined dataset: {data.shape}, range: {data['timestamp'].min()} → {data['timestamp'].max()}"
)
data.tail(5)

# Create features and forward returns
analysis = (
    data.with_columns(
        [
            # TVL momentum signals
            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") - pl.col("tvl_bn").rolling_mean(90))
                / pl.col("tvl_bn").rolling_std(90)
            ).alias("tvl_zscore"),
            # Forward returns at various horizons
            pl.col("eth_price").pct_change(7).shift(-7).alias("fwd_return_7d"),
            pl.col("eth_price").pct_change(14).shift(-14).alias("fwd_return_14d"),
            pl.col("eth_price").pct_change(30).shift(-30).alias("fwd_return_30d"),
            pl.col("eth_price").pct_change(60).shift(-60).alias("fwd_return_60d"),
        ]
    )
    .filter(pl.col("tvl_growth_30d").is_not_null())
    .filter(pl.col("fwd_return_30d").is_not_null())
)

print(f"Analysis dataset: {analysis.shape}")

signals = ["tvl_growth_7d", "tvl_growth_30d", "tvl_zscore"]
horizons = ["fwd_return_7d", "fwd_return_14d", "fwd_return_30d", "fwd_return_60d"]

ic_long = pl.concat(
    [
        analysis.select(
            pl.lit(s).alias("signal"),
            pl.lit(h).alias("horizon"),
            pl.corr(s, h).alias("IC"),
            pl.col(s).is_not_null().sum().alias("n_obs"),
        )
        for s in signals
        for h in horizons
    ]
)
ic_df = ic_long.filter(pl.col("n_obs") > 30)
ic_df

# Create IC heatmap (signals × horizons)
# Reshape data for heatmap
signal_order = ["tvl_growth_7d", "tvl_growth_30d", "tvl_zscore"]
horizon_order = ["fwd_return_7d", "fwd_return_14d", "fwd_return_30d", "fwd_return_60d"]

# Build matrix
ic_matrix = []
for signal in signal_order:
    row = []
    for horizon in horizon_order:
        ic_val = ic_df.filter((pl.col("signal") == signal) & (pl.col("horizon") == horizon))[
            "IC"
        ].to_list()
        row.append(ic_val[0] if ic_val else 0)
    ic_matrix.append(row)

# Clean labels
signal_labels = ["TVL Growth 7d", "TVL Growth 30d", "TVL Z-Score"]
horizon_labels = ["7d", "14d", "30d", "60d"]

# Create heatmap with custom colorscale
fig = go.Figure(
    data=go.Heatmap(
        z=ic_matrix,
        x=horizon_labels,
        y=signal_labels,
        colorscale=[
            [0.0, COLORS["negative"]],  # negative IC (red)
            [0.5, COLORS["silver"]],  # zero IC (neutral)
            [1.0, COLORS["positive"]],  # positive IC (green)
        ],
        zmid=0,  # Center colorscale at 0
        text=[[f"{v:.3f}" for v in row] for row in ic_matrix],
        texttemplate="%{text}",
        textfont={"size": 14, "color": "black"},
        colorbar=dict(title="IC", tickformat=".2f"),
    )
)

fig.update_layout(
    title="IC Reverses Sign with Horizon for the TVL Z-Score",
    xaxis_title="Forward Return Horizon",
    yaxis_title="Signal",
    height=350,
)
fig.show()

ic_df.sort(pl.col("IC").abs(), descending=True).head(3)

# Visualize IC by horizon (signal decay)
pivot_data = ic_df.filter(pl.col("signal") == "tvl_growth_30d")

fig = go.Figure()
fig.add_trace(
    go.Bar(
        x=[h.replace("fwd_return_", "") for h in pivot_data["horizon"]],
        y=pivot_data["IC"],
        text=[f"{ic:.3f}" if ic is not None else "N/A" for ic in pivot_data["IC"]],
        textposition="auto",
        marker_color=COLORS["blue"],
    )
)

fig.update_layout(
    title="TVL 30-Day Growth Signal Peaks at Mid Horizon, Decays Past 60 Days",
    xaxis_title="Forward Return Horizon",
    yaxis_title="Information Coefficient",
    height=400,
)
fig.show()

rolling_window = 180
rolling_ic_df = pl.DataFrame(
    {
        "timestamp": analysis["timestamp"][rolling_window:],
        "rolling_ic": [
            analysis.slice(i - rolling_window, rolling_window)
            .select(pl.corr("tvl_growth_30d", "fwd_return_30d"))
            .item()
            for i in range(rolling_window, len(analysis))
        ],
    }
).filter(pl.col("rolling_ic").is_not_null())

ic_mean = rolling_ic_df["rolling_ic"].mean()
ic_std = rolling_ic_df["rolling_ic"].std()
ic_positive_pct = (rolling_ic_df["rolling_ic"] > 0).mean()

rolling_ic_df.select(
    pl.lit(rolling_window).alias("window_days"),
    pl.lit(len(rolling_ic_df)).alias("n_windows"),
    pl.col("rolling_ic").mean().round(3).alias("mean_ic"),
    pl.col("rolling_ic").std().round(3).alias("std_ic"),
    (pl.col("rolling_ic") > 0).mean().round(3).alias("share_positive"),
)

fig = go.Figure()
fig.add_trace(
    go.Scatter(
        x=rolling_ic_df["timestamp"],
        y=rolling_ic_df["rolling_ic"],
        name="Rolling IC",
        line=dict(color=COLORS["slate"], width=1.5),
        fill="tozeroy",
        fillcolor="rgba(26, 45, 74, 0.15)",
    )
)
fig.add_hline(y=0, line_dash="dash", line_color=COLORS["neutral"])
fig.add_hline(
    y=ic_mean,
    line_dash="dot",
    line_color=COLORS["blue"],
    annotation_text=f"Mean: {ic_mean:.3f}",
)

# Add bands for positive/negative regions
fig.add_hrect(y0=0, y1=0.2, fillcolor=COLORS["positive"], opacity=0.05)
fig.add_hrect(y0=-0.2, y1=0, fillcolor=COLORS["negative"], opacity=0.05)

fig.update_layout(
    title="Rolling 180-Day IC Crosses Zero - Signal Is Regime-Dependent",
    xaxis_title="Date",
    yaxis_title="Information Coefficient",
    height=400,
)
fig.show()

tvl_modern = tvl_data.filter(pl.col("tvl_bn") >= 0.1).sort("timestamp")
date_gaps = tvl_modern.with_columns(
    (pl.col("timestamp") - pl.col("timestamp").shift(1)).dt.total_days().alias("days_gap")
)
gaps = date_gaps.filter(pl.col("days_gap") > 1)
extreme_changes = tvl_modern.with_columns(
    pl.col("tvl_bn").pct_change().alias("daily_change")
).filter(pl.col("daily_change").abs() > 0.20)

tvl_modern.select(
    pl.col("timestamp").min().alias("start"),
    pl.col("timestamp").max().alias("end"),
    pl.len().alias("n_obs"),
    pl.col("tvl_bn").min().round(2).alias("min_bn"),
    pl.col("tvl_bn").max().round(1).alias("max_bn"),
    pl.col("tvl_bn").mean().round(1).alias("mean_bn"),
    pl.lit(tvl_modern["tvl_usd"].null_count()).alias("nulls"),
    pl.lit(len(gaps)).alias("date_gaps"),
    pl.lit(len(extreme_changes)).alias("daily_moves_gt_20pct"),
)

@dataclass
class DataQualityMetrics:
    coverage_years: float
    missing_pct: float
    gap_days: int
    extreme_moves_pct: float
    methodology_transparent: bool
    pit_available: bool

    @property
    def score(self) -> float:
        return min(
            100.0,
            min(25.0, self.coverage_years * 5)
            + max(0.0, 25.0 - self.missing_pct * 100)
            + max(0.0, 20.0 - self.extreme_moves_pct * 100)
            + (15 if self.methodology_transparent else 0)
            + (15 if self.pit_available else 0),
        )


coverage_years = (tvl_modern["timestamp"].max() - tvl_modern["timestamp"].min()).days / 365
missing_pct = tvl_modern["tvl_usd"].null_count() / len(tvl_modern)
extreme_pct = len(extreme_changes) / len(tvl_modern)

quality = DataQualityMetrics(
    coverage_years=coverage_years,
    missing_pct=missing_pct,
    gap_days=int(gaps["days_gap"].max()) if len(gaps) > 0 else 0,
    extreme_moves_pct=extreme_pct,
    methodology_transparent=True,  # docs.llama.fi documents TVL aggregation
    pit_available=False,  # no vintage endpoint; historical revisions possible
)

pl.DataFrame(
    {
        "dimension": [
            "coverage_years",
            "missing_pct",
            "max_gap_days",
            "extreme_moves_pct",
            "methodology_transparent",
            "pit_available",
            "composite_score",
        ],
        "value": [
            f"{quality.coverage_years:.1f}",
            f"{quality.missing_pct:.2%}",
            str(quality.gap_days),
            f"{quality.extreme_moves_pct:.2%}",
            str(quality.methodology_transparent),
            str(quality.pit_available),
            f"{quality.score:.0f}/100",
        ],
    }
)

legal = {
    "data_source": "DefiLlama (defillama.com)",
    "source_type": "Public",
    "mnpi_risk": "Low",
    "mnpi_reasoning": (
        "TVL is computed from on-chain transactions visible to anyone with an "
        "RPC endpoint; DefiLlama aggregates publicly verifiable state without "
        "insider access."
    ),
    "usage_restrictions": "Attribution requested; API rate limits apply",
    "jurisdictional_issues": (
        "Crypto regulation varies by jurisdiction; institutional use typically "
        "requires a compliance sign-off on the underlying smart-contract exposure."
    ),
}

pl.DataFrame(
    {
        "dimension": list(legal.keys()),
        "value": list(legal.values()),
    }
)

def calculate_required_alpha(
    data_cost: float,
    annual_hours: float,
    hourly_rate: float,
    aum: float,
    allocation_pct: float = 0.10,
    target_roi: float = 3.0,
) -> dict:
    total_cost = data_cost + annual_hours * hourly_rate
    allocated_capital = aum * allocation_pct
    required_alpha_bps = (total_cost * target_roi / allocated_capital) * 10_000
    return {
        "total_annual_cost": total_cost,
        "allocated_capital": allocated_capital,
        "required_alpha_bps": required_alpha_bps,
    }


integration_hours = 40
maintenance_hours = 20
hourly_rate = 150
annual_hours = integration_hours + maintenance_hours

cost_table = pl.DataFrame(
    [
        {
            "fund_size": label,
            "aum_usd": aum,
            **calculate_required_alpha(0, annual_hours, hourly_rate, aum),
        }
        for label, aum in [
            ("Small ($10M)", 10_000_000),
            ("Mid ($50M)", 50_000_000),
            ("Large ($500M)", 500_000_000),
        ]
    ]
).with_columns(
    pl.col("required_alpha_bps").round(1),
    pl.col("total_annual_cost").cast(pl.Int64),
    pl.col("allocated_capital").cast(pl.Int64),
)
cost_table

best_ic = ic_df["IC"].abs().max()
avg_ic = ic_df["IC"].abs().mean()

pl.DataFrame(
    {
        "metric": [
            "data_cost_usd_per_year",
            "integration_cost_usd_per_year",
            "best_abs_ic",
            "average_abs_ic",
            "rolling_ic_share_positive",
        ],
        "value": [
            "0",
            f"{annual_hours * hourly_rate:,}",
            f"{best_ic:.3f}",
            f"{avg_ic:.3f}",
            f"{ic_positive_pct:.1%}",
        ],
    }
)

# Build the four-panel dashboard in a SINGLE cell so the inline backend
# does not capture progressive-render intermediates with only the first
# (or first two) gauges populated (feedback_split_cell_figure_bug).
fig = make_subplots(
    rows=2,
    cols=2,
    subplot_titles=(
        "Signal Quality (IC)",
        "Data Quality Score",
        "IC Stability Over Time",
        "Cost-Benefit Analysis",
    ),
    specs=[
        [{"type": "indicator"}, {"type": "indicator"}],
        [{"type": "scatter"}, {"type": "bar"}],
    ],
    vertical_spacing=0.28,
    horizontal_spacing=0.12,
)

# Signal quality gauge
fig.add_trace(
    go.Indicator(
        mode="gauge+number",
        value=avg_ic * 100,  # Convert to percentage for readability
        title={"text": "Average |IC| × 100"},
        gauge={
            "axis": {"range": [0, 10]},
            "bar": {"color": COLORS["blue"]},
            "steps": [
                {"range": [0, 2], "color": COLORS["negative"]},
                {"range": [2, 5], "color": COLORS["amber"]},
                {"range": [5, 10], "color": COLORS["positive"]},
            ],
            "threshold": {
                "line": {"color": "black", "width": 2},
                "thickness": 0.75,
                "value": avg_ic * 100,
            },
        },
    ),
    row=1,
    col=1,
)

# Data quality gauge
fig.add_trace(
    go.Indicator(
        mode="gauge+number",
        value=quality.score,
        title={"text": "Data Quality"},
        gauge={
            "axis": {"range": [0, 100]},
            "bar": {"color": COLORS["slate"]},
            "steps": [
                {"range": [0, 50], "color": COLORS["negative"]},
                {"range": [50, 75], "color": COLORS["amber"]},
                {"range": [75, 100], "color": COLORS["positive"]},
            ],
        },
    ),
    row=1,
    col=2,
)

# Rolling IC and cost-benefit panels
fig.add_trace(
    go.Scatter(
        x=rolling_ic_df["timestamp"],
        y=rolling_ic_df["rolling_ic"],
        mode="lines",
        name="Rolling IC",
        line=dict(color=COLORS["slate"], width=2),
        fill="tozeroy",
        fillcolor="rgba(26, 45, 74, 0.15)",
        showlegend=False,
    ),
    row=2,
    col=1,
)
# Add zero line on the rolling-IC subplot. Mixed-spec make_subplots places the
# row=2,col=1 scatter on the primary x/y axes (indicator subplots don't claim
# numbered axes), so reference the first scatter axes directly via "x domain".
fig.add_shape(
    type="line",
    x0=0,
    x1=1,
    y0=0,
    y1=0,
    xref="x domain",
    yref="y",
    line=dict(dash="dash", color=COLORS["neutral"]),
)

risk_to_score = {"Low": 100, "Medium": 50, "High": 20, "Critical": 0}
dimension_names = ["Signal", "Data", "Legal", "Commercial"]
dimension_scores = [
    min(100, avg_ic * 1000),
    quality.score,
    risk_to_score[legal["mnpi_risk"]],
    85,  # free data + ~$9k/yr engineering at the median fund size
]
dimension_colors = [
    COLORS["positive"] if s >= 60 else (COLORS["amber"] if s >= 40 else COLORS["negative"])
    for s in dimension_scores
]

fig.add_trace(
    go.Bar(
        x=dimension_names,
        y=dimension_scores,
        marker_color=dimension_colors,
        text=[f"{s:.0f}" for s in dimension_scores],
        textposition="outside",
        showlegend=False,
    ),
    row=2,
    col=2,
)

fig.update_layout(
    height=750,
    title="Four-Dimension Evaluation Dashboard - DefiLlama TVL",
    margin=dict(t=90, b=60, l=60, r=60),
)
# Force the rolling-IC subplot (row=2, col=1) x-axis to render as datetime.
# In mixed-spec make_subplots (indicator + scatter + bar) the subplot xaxis can
# default to numeric epoch ticks when traces are added before the layout pass;
# the explicit type+range below pins it to the actual data window.
_ts_min = rolling_ic_df["timestamp"].min()
_ts_max = rolling_ic_df["timestamp"].max()
fig.update_xaxes(type="date", range=[_ts_min, _ts_max], row=2, col=1)
fig.update_yaxes(title_text="Rolling IC", row=2, col=1)
fig.update_yaxes(title_text="Dimension Score (0–100)", range=[0, 110], row=2, col=2)
fig.show()

evidence_summary = pl.DataFrame(
    {
        "dimension": ["Signal", "Data", "Legal", "Commercial"],
        "headline_metric": [
            f"avg |IC| {avg_ic:.3f}, best |IC| {best_ic:.3f}",
            f"{quality.score:.0f}/100 (coverage {quality.coverage_years:.1f}y, missing {quality.missing_pct:.1%})",
            f"MNPI risk {legal['mnpi_risk']} (public on-chain data)",
            f"~${annual_hours * hourly_rate:,}/yr engineering, $0 data fees",
        ],
        "binding_caveat": [
            f"Rolling IC mean {ic_mean:+.3f}, positive in {ic_positive_pct:.0%} of windows; sign reverses with horizon - likely contrarian rather than directional",
            "No point-in-time vintages - historical revisions can backfill, inflating any backtest",
            "Crypto regulation varies by jurisdiction; institutional deployment requires compliance review of underlying smart-contract exposure",
            f"Required alpha at small fund (10% allocation, 3× ROI) is {cost_table.filter(pl.col('fund_size') == 'Small ($10M)')['required_alpha_bps'].item():.1f} bps - small funds carry the cost-recovery burden",
        ],
    }
)
evidence_summary