import numpy as np
import pandas as pd
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class TWAPSchedule:
    """
    TWAP execution schedule generator.
    """
    total_shares: int
    duration_minutes: int
    interval_minutes: int = 5
    randomize: bool = True
    max_participation: float = 0.10
def generate(self) -> pd.DataFrame:
        """
        Generate TWAP child order schedule.
Returns DataFrame with time offsets and share quantities.
        """
        n_intervals = self.duration_minutes // self.interval_minutes
        base_shares = self.total_shares / n_intervals
schedule = []
        remaining = self.total_shares
for i in range(n_intervals):
            # Base quantity
            shares = base_shares
# Add randomization (+/- 20%) to reduce predictability
            if self.randomize and i < n_intervals - 1:
                jitter = np.random.uniform(-0.2, 0.2) * base_shares
                shares = max(1, int(shares + jitter))
            else:
                shares = remaining  # Last slice gets remainder
shares = min(shares, remaining)
            remaining -= shares
schedule.append({
                "interval": i,
                "time_offset_min": i * self.interval_minutes,
                "shares": int(shares),
                "cumulative_shares": self.total_shares - remaining,
                "pct_complete": (self.total_shares - remaining) / self.total_shares,
            })
if remaining <= 0:
                break
return pd.DataFrame(schedule)
class TWAPExecutor:
    """Simulate TWAP execution against market data."""
def __init__(
        self,
        max_participation: float = 0.10,
        spread_bps: float = 5.0,
    ):
        self.max_participation = max_participation
        self.spread_bps = spread_bps
def execute(
        self,
        schedule: pd.DataFrame,
        market_prices: pd.Series,
        market_volumes: pd.Series,
    ) -> dict:
        """
        Simulate TWAP execution.
        """
        fills = []
        total_filled = 0
        total_cost = 0
for _, row in schedule.iterrows():
            idx = min(int(row["interval"]), len(market_prices) - 1)
            price = market_prices.iloc[idx]
            volume = market_volumes.iloc[idx]
# Participation limit
            max_shares = int(volume * self.max_participation)
            filled = min(int(row["shares"]), max_shares)
# Execution price with spread
            exec_price = price * (1 + self.spread_bps / 20_000)
fills.append({
                "interval": row["interval"],
                "shares_requested": int(row["shares"]),
                "shares_filled": filled,
                "price": exec_price,
                "cost": filled * exec_price,
            })
total_filled += filled
            total_cost += filled * exec_price
avg_price = total_cost / total_filled if total_filled > 0 else 0
        twap_benchmark = market_prices.mean()
return {
            "fills": pd.DataFrame(fills),
            "total_filled": total_filled,
            "avg_execution_price": avg_price,
            "twap_benchmark": twap_benchmark,
            "slippage_bps": (avg_price / twap_benchmark - 1) * 10_000 if twap_benchmark > 0 else 0,
        }

class VWAPAlgorithm:
    """
    VWAP execution algorithm.
    Matches the market's volume profile to minimize tracking error.
    """
def __init__(
        self,
        max_participation: float = 0.15,
        spread_bps: float = 5.0,
    ):
        self.max_participation = max_participation
        self.spread_bps = spread_bps
def estimate_volume_profile(
        self,
        historical_volumes: pd.DataFrame,
        n_bins: int = 78,  # 5-min bins in 6.5hr trading day
    ) -> np.ndarray:
        """
        Estimate intraday volume distribution from historical data.
        Returns normalized volume weights per bin.
        """
        # Compute average volume profile across days
        if historical_volumes.shape[1] > 1:
            avg_profile = historical_volumes.mean(axis=1).values
        else:
            avg_profile = historical_volumes.values.flatten()
# Resize to n_bins if needed
        if len(avg_profile) != n_bins:
            from scipy.interpolate import interp1d
            x_old = np.linspace(0, 1, len(avg_profile))
            x_new = np.linspace(0, 1, n_bins)
            f = interp1d(x_old, avg_profile, kind="linear")
            avg_profile = f(x_new)
# Normalize to weights
        profile = avg_profile / avg_profile.sum()
        return profile
def generate_schedule(
        self,
        total_shares: int,
        volume_profile: np.ndarray,
        expected_volumes: np.ndarray = None,
    ) -> pd.DataFrame:
        """
        Generate VWAP child order schedule.
Args:
            total_shares: total order size
            volume_profile: normalized volume weights per bin
            expected_volumes: expected actual volumes per bin
        """
        n_bins = len(volume_profile)
        target_shares = total_shares * volume_profile
schedule = []
        remaining = total_shares
for i in range(n_bins):
            shares = min(int(np.round(target_shares[i])), remaining)
# Apply participation limit
            if expected_volumes is not None:
                max_shares = int(expected_volumes[i] * self.max_participation)
                shares = min(shares, max_shares)
shares = max(0, shares)
            remaining -= shares
schedule.append({
                "bin": i,
                "target_pct": volume_profile[i],
                "shares": shares,
                "cumulative": total_shares - remaining,
                "pct_complete": (total_shares - remaining) / total_shares,
            })
# Handle remainder: distribute to highest-volume bins
        if remaining > 0:
            sorted_bins = np.argsort(volume_profile)[::-1]
            for bin_idx in sorted_bins:
                add = min(remaining, int(target_shares[bin_idx] * 0.2))
                schedule[bin_idx]["shares"] += add
                remaining -= add
                if remaining <= 0:
                    break
return pd.DataFrame(schedule)
def calculate_vwap_benchmark(
        self,
        prices: pd.Series,
        volumes: pd.Series,
    ) -> float:
        """Compute VWAP benchmark price."""
        return (prices * volumes).sum() / volumes.sum()
def evaluate_execution(
        self,
        fills: pd.DataFrame,
        prices: pd.Series,
        volumes: pd.Series,
    ) -> dict:
        """Evaluate execution quality vs VWAP benchmark."""
        vwap = self.calculate_vwap_benchmark(prices, volumes)
total_shares = fills["shares_filled"].sum()
        total_cost = (fills["shares_filled"] * fills["execution_price"]).sum()
        avg_price = total_cost / total_shares if total_shares > 0 else 0
return {
            "vwap_benchmark": vwap,
            "avg_execution_price": avg_price,
            "slippage_bps": (avg_price / vwap - 1) * 10_000 if vwap > 0 else 0,
            "total_filled": total_shares,
            "fill_rate": total_shares / fills["shares_requested"].sum() if fills["shares_requested"].sum() > 0 else 0,
        }

class ImplementationShortfall:
    """
    Implementation Shortfall execution algorithm.
    Optimizes the trade-off between market impact (trading too fast)
    and timing risk (trading too slow).
Based on Almgren-Chriss optimal execution framework.
    """
def __init__(
        self,
        risk_aversion: float = 1e-6,
        temporary_impact: float = 0.1,
        permanent_impact: float = 0.05,
    ):
        self.risk_aversion = risk_aversion
        self.eta = temporary_impact
        self.gamma = permanent_impact
def optimal_schedule(
        self,
        total_shares: int,
        n_periods: int,
        daily_volume: int,
        volatility: float,
        urgency: str = "medium",
    ) -> pd.DataFrame:
        """
        Generate optimal IS execution schedule.
Urgency levels control the speed/cost tradeoff:
'low': minimize impact, accept timing risk
'medium': balanced
'high': minimize timing risk, accept higher impact
        """
        # Adjust risk aversion by urgency
        urgency_map = {
            "low": self.risk_aversion * 0.1,
            "medium": self.risk_aversion,
            "high": self.risk_aversion * 10,
        }
        lambda_val = urgency_map.get(urgency, self.risk_aversion)

# Almgren-Chriss decay rate
        kappa = np.sqrt(lambda_val  volatility*2 / self.eta)
schedule = []
        remaining = float(total_shares)
for t in range(n_periods):
            periods_left = n_periods - t
            if periods_left <= 0:
                trade = remaining
            else:
                # Optimal trade rate
                if kappa * periods_left > 0:
                    trade = remaining  np.sinh(kappa) / np.sinh(kappa  periods_left)
                else:
                    trade = remaining / periods_left
trade = min(abs(trade), abs(remaining)) * np.sign(total_shares)
            remaining -= trade
participation = abs(trade) / daily_volume
schedule.append({
                "period": t,
                "shares": int(trade),
                "remaining": int(remaining),
                "pct_complete": 1 - remaining / total_shares,
                "participation_rate": participation,
                "expected_impact_bps": (
                    self.eta  volatility  np.sqrt(participation) * 10_000
                ),
            })
return pd.DataFrame(schedule)
def measure_shortfall(
        self,
        decision_price: float,
        fills: list[dict],
    ) -> dict:
        """
        Measure implementation shortfall.
IS = (Execution Cost - Decision Price  Shares) / (Decision Price  Shares)
        """
        total_shares = sum(f["shares"] for f in fills)
        total_cost = sum(f["shares"] * f["price"] for f in fills)
        avg_price = total_cost / total_shares if total_shares > 0 else decision_price
# Implementation shortfall breakdown
        shortfall = (avg_price - decision_price) / decision_price
# Decomposition
        # Delay: price move from decision to first fill
        delay_cost = (fills[0]["price"] - decision_price) / decision_price if fills else 0
# Impact: price move caused by trading
        timing_cost = shortfall - delay_cost
return {
            "decision_price": decision_price,
            "avg_execution_price": avg_price,
            "total_shortfall_bps": shortfall * 10_000,
            "delay_cost_bps": delay_cost * 10_000,
            "impact_cost_bps": timing_cost * 10_000,
            "total_cost": total_cost,
        }

def select_algorithm(
    order_size: int,
    daily_volume: int,
    urgency: str,
    alpha_half_life_hours: float = None,
    is_rebalance: bool = False,
) -> dict:
    """
    Recommend execution algorithm based on order characteristics.
    """
    participation_rate = order_size / max(daily_volume, 1)
if is_rebalance and urgency == "low":
        algo = "TWAP"
        reason = "Rebalancing trade with no urgency; minimize market footprint"
    elif participation_rate > 0.05 and urgency != "high":
        algo = "VWAP"
        reason = f"Large order ({participation_rate:.1%} of ADV); match volume profile"
    elif alpha_half_life_hours and alpha_half_life_hours < 4:
        algo = "IS_AGGRESSIVE"
        reason = f"Fast-decaying alpha ({alpha_half_life_hours}h half-life); minimize delay cost"
    elif urgency == "high":
        algo = "IS_MODERATE"
        reason = "High urgency; balance impact vs timing risk"
    elif participation_rate < 0.01:
        algo = "MARKET"
        reason = f"Small order ({participation_rate:.2%} of ADV); immediate execution"
    else:
        algo = "VWAP"
        reason = "Default; match volume-weighted benchmark"
return {
        "algorithm": algo,
        "reason": reason,
        "participation_rate": participation_rate,
        "estimated_duration_minutes": max(
            10, int(participation_rate / 0.05 * 390)
        ),
    }

def execution_quality_report(
    fills: pd.DataFrame,
    benchmark_prices: pd.DataFrame,
    decision_price: float,
) -> dict:
    """
    Comprehensive execution quality report.
    """
    total_shares = fills["shares"].sum()
    total_cost = (fills["shares"] * fills["execution_price"]).sum()
    avg_price = total_cost / total_shares
vwap = (benchmark_prices["price"] * benchmark_prices["volume"]).sum() / benchmark_prices["volume"].sum()
    twap = benchmark_prices["price"].mean()
    arrival_price = benchmark_prices["price"].iloc[0]
    close_price = benchmark_prices["price"].iloc[-1]
report = {
        "avg_execution_price": avg_price,
        "vs_vwap_bps": (avg_price / vwap - 1) * 10_000,
        "vs_twap_bps": (avg_price / twap - 1) * 10_000,
        "vs_arrival_bps": (avg_price / arrival_price - 1) * 10_000,
        "vs_close_bps": (avg_price / close_price - 1) * 10_000,
        "vs_decision_bps": (avg_price / decision_price - 1) * 10_000,
        "fill_rate": total_shares / fills["shares_requested"].sum() if "shares_requested" in fills else 1.0,
    }
print(f"Execution Quality Report:")
    for k, v in report.items():
        if "bps" in k:
            print(f"  {k}: {v:+.1f} bps")
        else:
            print(f"  {k}: {v:.4f}")
return report