import numpy as np
import pandas as pd
from dataclasses import dataclass
@dataclass
class TransactionCostModel:
    """
    Comprehensive transaction cost model.
    All costs expressed as a fraction of trade value (decimal, not bps).
    """
    # Fixed costs
    commission_per_share: float = 0.005   # $0.005/share
    min_commission: float = 1.0           # $1 minimum per trade
    exchange_fee_per_share: float = 0.003 # Regulatory fees
# Spread costs
    half_spread_bps: float = 5.0          # Half bid-ask spread in bps
# Market impact parameters (Almgren-Chriss)
    temporary_impact_coeff: float = 0.1   # Temporary impact coefficient
    permanent_impact_coeff: float = 0.05  # Permanent impact coefficient
    impact_exponent: float = 0.5          # Concavity of impact function
def estimate_cost(
        self,
        price: float,
        shares: int,
        daily_volume: int,
        volatility: float,
        side: str = "buy",
    ) -> dict:
        """
        Estimate total transaction cost for a single trade.
Args:
            price: current stock price
            shares: number of shares to trade
            daily_volume: average daily volume
            volatility: daily volatility (decimal)
            side: 'buy' or 'sell'
        """
        trade_value = abs(shares * price)
        participation_rate = abs(shares) / max(daily_volume, 1)
# 1. Commission
        commission = max(
            abs(shares) * self.commission_per_share,
            self.min_commission
        )
        commission_pct = commission / trade_value if trade_value > 0 else 0
# 2. Exchange and regulatory fees
        exchange_fees = abs(shares) * self.exchange_fee_per_share
        exchange_pct = exchange_fees / trade_value if trade_value > 0 else 0
# 3. Spread cost (half spread for crossing)
        spread_cost = trade_value * self.half_spread_bps / 10_000
        spread_pct = self.half_spread_bps / 10_000
# 4. Market impact (Almgren-Chriss square-root model)
        # Temporary impact: proportional to sqrt(participation rate) * volatility
        temp_impact = (
            self.temporary_impact_coeff
volatility
             (participation_rate * self.impact_exponent)
        )

# Permanent impact: linear in participation rate
        perm_impact = (
            self.permanent_impact_coeff
volatility
participation_rate
        )

total_impact = temp_impact + perm_impact
        impact_cost = trade_value * total_impact
# Total cost
        total_cost = commission + exchange_fees + spread_cost + impact_cost
        total_pct = total_cost / trade_value if trade_value > 0 else 0
return {
            "trade_value": trade_value,
            "shares": abs(shares),
            "participation_rate": participation_rate,
            "commission": commission,
            "commission_pct": commission_pct,
            "exchange_fees": exchange_fees,
            "spread_cost": spread_cost,
            "spread_pct": spread_pct,
            "temporary_impact": temp_impact,
            "permanent_impact": perm_impact,
            "impact_cost": impact_cost,
            "total_cost": total_cost,
            "total_cost_pct": total_pct,
            "total_cost_bps": total_pct * 10_000,
        }

class AlmgrenChrissModel:
    """
    Almgren-Chriss market impact model for optimal execution.
Models both temporary (transient) and permanent impact.
    Temporary impact dissipates after trading; permanent impact
    reflects new information incorporated into the price.
    """
def __init__(
        self,
        sigma: float = 0.02,      # Daily volatility
        eta: float = 0.1,          # Temporary impact coefficient
        gamma: float = 0.05,       # Permanent impact coefficient
        lambda_risk: float = 1e-6, # Risk aversion parameter
    ):
        self.sigma = sigma
        self.eta = eta
        self.gamma = gamma
        self.lambda_risk = lambda_risk
def optimal_trajectory(
        self,
        total_shares: int,
        n_periods: int,
        daily_volume: int,
    ) -> dict:
        """
        Compute the optimal execution trajectory that minimizes
        expected cost + risk aversion * variance.
Returns shares to trade in each period.
        """
        X = total_shares
        T = n_periods
# Participation rate if executed uniformly
        uniform_rate = abs(X) / (T * daily_volume)
# Optimal rate depends on risk aversion
        # Higher risk aversion -> faster execution (front-loaded)
        kappa = np.sqrt(self.lambda_risk  self.sigma*2 / self.eta)
# Optimal trajectory
        trajectory = np.zeros(T)
        remaining = X
        for t in range(T):
            if kappa * (T - t) > 0:
                trade_rate = remaining  np.sinh(kappa) / np.sinh(kappa  (T - t))
            else:
                trade_rate = remaining
            trade_rate = min(abs(trade_rate), abs(remaining)) * np.sign(remaining)
            trajectory[t] = trade_rate
            remaining -= trade_rate
# Cost estimation
        costs = self._estimate_trajectory_cost(
            trajectory, daily_volume
        )
return {
            "trajectory": trajectory,
            "cumulative_shares": np.cumsum(trajectory),
            "remaining_shares": X - np.cumsum(trajectory),
            "expected_cost": costs["expected_cost"],
            "cost_std": costs["cost_std"],
            "participation_rates": np.abs(trajectory) / daily_volume,
        }
def _estimate_trajectory_cost(
        self,
        trajectory: np.ndarray,
        daily_volume: int,
    ) -> dict:
        """Estimate cost and risk of a given trajectory."""
        total_temp_impact = 0
        total_perm_impact = 0
for shares in trajectory:
            rate = abs(shares) / daily_volume
            total_temp_impact += self.eta  self.sigma  np.sqrt(rate) * abs(shares)
            total_perm_impact += self.gamma  self.sigma  rate * abs(shares)
expected_cost = total_temp_impact + total_perm_impact
        # Simplified variance estimate
        cost_std = self.sigma  np.sqrt(sum(trajectory*2))
return {
            "expected_cost": expected_cost,
            "temporary_cost": total_temp_impact,
            "permanent_cost": total_perm_impact,
            "cost_std": cost_std,
        }

class RealisticBacktest:
    """
    Backtest engine with integrated transaction cost modeling.
    """
def __init__(
        self,
        cost_model: TransactionCostModel = None,
        initial_capital: float = 1_000_000,
    ):
        self.cost_model = cost_model or TransactionCostModel()
        self.initial_capital = initial_capital
def run(
        self,
        prices: pd.DataFrame,
        volumes: pd.DataFrame,
        target_weights: pd.DataFrame,
        volatilities: pd.DataFrame = None,
    ) -> pd.DataFrame:
        """
        Run backtest with realistic transaction costs.
Args:
            prices: daily close prices (assets as columns)
            volumes: daily volume
            target_weights: target portfolio weights at each time
            volatilities: daily volatility estimates
        """
        assets = prices.columns.tolist()
        dates = prices.index
        n_dates = len(dates)
# Initialize
        capital = self.initial_capital
        current_shares = pd.Series(0.0, index=assets)
        results = []
if volatilities is None:
            volatilities = prices.pct_change().rolling(21).std()
for i in range(1, n_dates):
            date = dates[i]
            prev_date = dates[i - 1]
# Current portfolio value
            current_value = (current_shares * prices.loc[date]).sum() + capital
            if current_value <= 0:
                break
# Target shares
            target = target_weights.loc[date] if date in target_weights.index else pd.Series(0, index=assets)
            target_shares = (target * current_value / prices.loc[date]).fillna(0)
# Trades needed
            trades = target_shares - current_shares
# Compute costs for each trade
            total_cost = 0
            for asset in assets:
                if abs(trades[asset]) < 1:
                    continue
cost = self.cost_model.estimate_cost(
                    price=prices.loc[date, asset],
                    shares=int(trades[asset]),
                    daily_volume=int(volumes.loc[date, asset]) if date in volumes.index else 1_000_000,
                    volatility=volatilities.loc[date, asset] if date in volatilities.index else 0.02,
                )
                total_cost += cost["total_cost"]
# Execute trades (after costs)
            capital -= total_cost
            current_shares = target_shares.copy()
# Record
            portfolio_value = (current_shares * prices.loc[date]).sum() + capital
            daily_return = portfolio_value / (
                (current_shares * prices.loc[prev_date]).sum() + capital
            ) - 1 if i > 1 else 0
results.append({
                "date": date,
                "portfolio_value": portfolio_value,
                "daily_return": daily_return,
                "total_cost": total_cost,
                "cost_bps": total_cost / max(current_value, 1) * 10_000,
                "turnover": trades.abs().sum() / max(current_value, 1),
            })
results_df = pd.DataFrame(results).set_index("date")
# Summary
        returns = results_df["daily_return"]
        ann_return = returns.mean() * 252
        ann_vol = returns.std() * np.sqrt(252)
        sharpe = ann_return / ann_vol if ann_vol > 0 else 0
        total_costs = results_df["total_cost"].sum()
        avg_cost_bps = results_df["cost_bps"].mean()
print(f"Backtest Results (with TCA):")
        print(f"  Annual Return: {ann_return:.2%}")
        print(f"  Annual Vol: {ann_vol:.2%}")
        print(f"  Sharpe: {sharpe:.2f}")
        print(f"  Total Costs: ${total_costs:,.0f}")
        print(f"  Avg Cost per Trade: {avg_cost_bps:.1f} bps")
        print(f"  Avg Daily Turnover: {results_df['turnover'].mean():.2%}")
return results_df

def turnover_analysis(
    weights: pd.DataFrame,
    returns: pd.Series = None,
) -> pd.DataFrame:
    """
    Analyze portfolio turnover and its cost implications.
    """
    # Weight changes
    weight_changes = weights.diff().abs()
    daily_turnover = weight_changes.sum(axis=1) / 2  # One-way turnover
    annual_turnover = daily_turnover.mean() * 252
# Decompose turnover sources
    # Active turnover (from rebalancing) vs passive (from price drift)
    if returns is not None:
        # Drift-adjusted weights (what weights would be without rebalancing)
        drifted = weights.shift(1) * (1 + returns)
        drifted = drifted.div(drifted.sum(axis=1), axis=0)
        active_changes = (weights - drifted).abs().sum(axis=1) / 2
        passive_changes = daily_turnover - active_changes
    else:
        active_changes = daily_turnover
        passive_changes = pd.Series(0, index=daily_turnover.index)
results = pd.DataFrame({
        "daily_turnover": daily_turnover,
        "active_turnover": active_changes,
        "passive_turnover": passive_changes,
    })
print(f"Turnover Analysis:")
    print(f"  Annual turnover: {annual_turnover:.1%}")
    print(f"  Median daily: {daily_turnover.median():.4%}")
    print(f"  Max daily: {daily_turnover.max():.4%}")
# Cost estimation at different cost levels
    for cost_bps in [5, 10, 20, 50]:
        annual_cost = annual_turnover * cost_bps / 10_000
        print(f"  Cost at {cost_bps} bps: {annual_cost:.2%} annual drag")
return results

def break_even_analysis(
    annual_turnover: float,
    cost_bps_range: np.ndarray = None,
    target_sharpe: float = 1.0,
    volatility: float = 0.15,
) -> pd.DataFrame:
    """
    Compute break-even alpha for different cost assumptions.
    """
    if cost_bps_range is None:
        cost_bps_range = np.arange(1, 51)
results = []
    for cost_bps in cost_bps_range:
        annual_cost = annual_turnover * cost_bps / 10_000
        # Minimum alpha = cost + target_sharpe * volatility
        min_alpha = annual_cost + target_sharpe * volatility
        # Alpha just to break even (Sharpe > 0)
        break_even_alpha = annual_cost
results.append({
            "cost_bps": cost_bps,
            "annual_cost": annual_cost,
            "break_even_alpha": break_even_alpha,
            "min_alpha_for_target": min_alpha,
        })
results_df = pd.DataFrame(results)
print(f"Break-Even Analysis (Turnover: {annual_turnover:.0%}):")
    print(f"{'Cost (bps)':>12} {'Annual Drag':>12} {'Break-Even Alpha':>18}")
    for _, row in results_df.iloc[::5].iterrows():
        print(f"{row['cost_bps']:>12.0f} {row['annual_cost']:>12.2%} {row['break_even_alpha']:>18.2%}")
return results_df