#!pip install numpy pandas matplotlib seaborn
# No custom libraries, so standard installs are sufficient.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from collections import deque
import random
import time
import logging

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def create_twap_state(total_quantity: int, duration_seconds: int, slice_interval_seconds: int) -> dict:
    """
    Initializes the state dictionary for the TWAP execution algorithm.

    Parameters
    ----------
    total_quantity : int
        The total number of shares/units to be traded.
    duration_seconds : int
        The total duration in seconds over which the order should be executed.
    slice_interval_seconds : int
        The time interval in seconds between each child order execution.

    Returns
    -------
    dict
        An initialized state dictionary for TWAP execution.
    """
    logger.info(f"Initializing TWAP state for {total_quantity} units over {duration_seconds}s with {slice_interval_seconds}s interval.")
    state = {
        'total_quantity': total_quantity,
        'remaining_quantity': total_quantity,
        'duration_seconds': duration_seconds,
        'slice_interval_seconds': slice_interval_seconds,
        'start_time': None,
        'current_time': 0,
        'executed_orders': [],
        'market_prices': [],
        'twap_target_price_history': [],
        'slippage_history': [],
        'effective_price_history': [],
        'last_executed_price': None
    }
    logger.debug("TWAP state initialized.")
    return state

def generate_market_data(current_price: float, volatility: float) -> float:
    """
    Simulates market price data for a given time step using a random walk model.

    Parameters
    ----------
    current_price : float
        The market price at the previous time step.
    volatility : float
        A measure of the market's price fluctuation (e.g., 0.001 for 0.1% daily change).

    Returns
    -------
    float
        The simulated market price for the current time step.
    """
    if current_price <= 0:
        logger.warning(f"Current price is non-positive ({current_price}). Resetting to 100 for market data generation.")
        current_price = 100.0

    # Simulate a random walk with some jitter
    price_change = current_price * (np.random.normal(0, volatility) + random.uniform(-0.0001, 0.0001))
    new_price = max(1.0, current_price + price_change) # Ensure price doesn't go below 1
    logger.debug(f"Generated market data: current_price={current_price:.2f}, new_price={new_price:.2f}")
    return new_price

def calculate_twap_orders(state: dict) -> int:
    """
    Calculates the quantity of shares/units to be traded in the current time slice
    based on the TWAP strategy.

    Parameters
    ----------
    state : dict
        The current TWAP execution state dictionary.

    Returns
    -------
    int
        The quantity to be traded in the current slice.
    """
    remaining_quantity = state['remaining_quantity']
    duration_seconds = state['duration_seconds']
    current_time = state['current_time']
    slice_interval_seconds = state['slice_interval_seconds']

    remaining_time = duration_seconds - current_time

    if remaining_time <= 0 or remaining_quantity <= 0:
        logger.info("No remaining time or quantity to calculate orders.")
        return 0

    # Calculate the number of remaining slices
    num_remaining_slices = remaining_time / slice_interval_seconds
    if num_remaining_slices < 1: # Handle cases where remaining time is less than one slice interval
        num_remaining_slices = 1

    # Calculate average quantity per slice
    quantity_per_slice = int(np.ceil(remaining_quantity / num_remaining_slices))

    # Ensure we don't over-execute in the last slice
    quantity_to_execute = min(quantity_per_slice, remaining_quantity)

    # Ensure at least 1 unit is traded if quantity remains
    if quantity_to_execute == 0 and remaining_quantity > 0:
        quantity_to_execute = 1
        logger.warning(f"Calculated 0 quantity but {remaining_quantity} remains. Executing 1 unit.")

    logger.debug(f"Calculated TWAP order for current slice: {quantity_to_execute} units.")
    return quantity_to_execute

def execute_order_chunk(state: dict, quantity: int, market_price: float) -> dict:
    """
    Simulates the execution of a single child order (chunk) at a given market price.
    Incorporates try/except with exponential backoff for resilient execution.

    Parameters
    ----------
    state : dict
        The current TWAP execution state dictionary.
    quantity : int
        The quantity of units to execute in this chunk.
    market_price : float
        The current market price at which to attempt execution.

    Returns
    -------
    dict
        The updated state dictionary after attempting execution.
    """
    if quantity <= 0:
        logger.debug("Attempted to execute zero or negative quantity. Skipping.")
        return state

    max_retries = 3
    base_backoff_seconds = 0.1
    executed_price = None

    for attempt in range(max_retries):
        try:
            # Simulate execution success/failure with some probability
            if random.random() < 0.9: # 90% chance of successful execution
                # Simulate a small market impact or price fluctuation during execution
                executed_price = market_price * (1 + random.uniform(-0.0005, 0.0005))
                logger.info(f"Successfully executed {quantity} units at {executed_price:.2f} (Attempt {attempt + 1}).")
                break
            else:
                raise ConnectionError("Simulated temporary network issue.")
        except ConnectionError as e:
            logger.warning(f"Execution attempt {attempt + 1} failed: {e}. Retrying...")
            if attempt < max_retries - 1:
                backoff_time = (base_backoff_seconds * (2 ** attempt)) + random.uniform(0, 0.05) # Add jitter
                logger.info(f"Waiting for {backoff_time:.2f} seconds before retrying.")
                time.sleep(backoff_time)
            else:
                logger.error(f"Failed to execute {quantity} units after {max_retries} attempts.")
                executed_price = market_price # Fallback to market price if execution truly fails
                break # Exit loop even on final failure to log and proceed

    if executed_price is not None:
        slippage = executed_price - market_price
        state['executed_orders'].append({
            'time': state['current_time'],
            'quantity': quantity,
            'market_price': market_price,
            'executed_price': executed_price
        })
        state['remaining_quantity'] -= quantity
        state['slippage_history'].append(slippage)
        state['effective_price_history'].append(executed_price)
        state['last_executed_price'] = executed_price
        logger.debug(f"Order chunk executed. Remaining quantity: {state['remaining_quantity']}")
    else:
        logger.error(f"No execution recorded for quantity {quantity} at time {state['current_time']}. Market price: {market_price:.2f}.")

    return state

def track_execution_metrics(state: dict, market_price: float) -> dict:
    """
    Updates the state with key execution metrics, specifically the current market price.

    Parameters
    ----------
    state : dict
        The current TWAP execution state dictionary.
    market_price : float
        The market price at the current time step.

    Returns
    -------
    dict
        The updated state dictionary with appended market prices.
    """
    state['market_prices'].append({
        'time': state['current_time'],
        'price': market_price
    })

    # Using deque for rolling window if we needed a specific window size
    # For now, we'll just append to a list for full history
    # example: price_window = deque(maxlen=10) ; price_window.append(market_price)

    logger.debug(f"Tracking metrics at time {state['current_time']}: market_price={market_price:.2f}")
    return state

def summarize_execution(state: dict) -> pd.DataFrame:
    """
    Calculates and returns a summary of the TWAP execution.

    Parameters
    ----------
    state : dict
        The final TWAP execution state dictionary.

    Returns
    -------
    pd.DataFrame
        A DataFrame containing the summary statistics of the execution.
    """
    executed_orders_df = pd.DataFrame(state['executed_orders'])

    if executed_orders_df.empty:
        logger.warning("No orders were executed, returning empty summary.")
        return pd.DataFrame([{
            'Metric': 'Total Quantity Executed',
            'Value': 0
        }, {
            'Metric': 'Actual TWAP Achieved',
            'Value': np.nan
        }, {
            'Metric': 'Volume-Weighted Average Price (VWAP)',
            'Value': np.nan
        }, {
            'Metric': 'Total Slippage',
            'Value': np.nan
        }])

    total_executed_quantity = executed_orders_df['quantity'].sum()

    # Actual TWAP (Time-Weighted Average Price) is the average of the executed prices
    # Assuming each executed price represents the price for its corresponding slice time
    # Since slices are regular, a simple average of executed prices is the TWAP.
    # If we wanted true time-weighted, we'd need to weight by time duration of each price.
    actual_twap = executed_orders_df['executed_price'].mean()

    # Volume-Weighted Average Price
    vwap = (executed_orders_df['quantity'] * executed_orders_df['executed_price']).sum() / total_executed_quantity

    total_slippage = executed_orders_df['executed_price'].sum() - executed_orders_df['market_price'].sum()

    summary_data = {
        'Metric': [
            'Total Quantity Executed',
            'Actual TWAP Achieved',
            'Volume-Weighted Average Price (VWAP)',
            'Total Slippage'
        ],
        'Value': [
            total_executed_quantity,
            actual_twap,
            vwap,
            total_slippage
        ]
    }
    summary_df = pd.DataFrame(summary_data)
    logger.info("Execution summary generated.")
    return summary_df

# Initial parameters for TWAP execution
total_order_quantity = 100  # Total shares to buy/sell
execution_duration_seconds = 120  # 10 minutes
slice_interval_seconds = 10  # Execute every 10 seconds
initial_market_price = 100.0
market_volatility = 0.0005 # 0.05% price change per interval

logger.info("Starting TWAP execution demonstration.")

# 1. Initialize TWAP state
twap_state = create_twap_state(
    total_quantity=total_order_quantity,
    duration_seconds=execution_duration_seconds,
    slice_interval_seconds=slice_interval_seconds
)
twap_state['start_time'] = 0

current_price = initial_market_price

# Run the TWAP simulation
while twap_state['current_time'] < twap_state['duration_seconds'] and twap_state['remaining_quantity'] > 0:
    # Generate market data for the current time step
    current_price = generate_market_data(current_price, market_volatility)
    twap_state = track_execution_metrics(twap_state, current_price)

    # Calculate order quantity for the current slice
    quantity_to_execute = calculate_twap_orders(twap_state)

    if quantity_to_execute > 0:
        # Execute the order chunk
        twap_state = execute_order_chunk(twap_state, quantity_to_execute, current_price)

    # Increment current time
    twap_state['current_time'] += twap_state['slice_interval_seconds']
    logger.debug(f"Time: {twap_state['current_time']}s, Remaining Quantity: {twap_state['remaining_quantity']}")

logger.info("TWAP execution simulation finished.")

# 2. Summarize execution
summary_df = summarize_execution(twap_state)
display(summary_df)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from collections import deque
import random
import time
import logging

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# Prepare data for plotting
market_prices_df = pd.DataFrame(twap_state['market_prices'])
executed_orders_df = pd.DataFrame(twap_state['executed_orders'])

plt.figure(figsize=(14, 7))
sns.lineplot(x='time', y='price', data=market_prices_df, label='Market Price', color='skyblue')

if not executed_orders_df.empty:
    sns.scatterplot(
        x='time',
        y='executed_price',
        size='quantity',
        hue='quantity',
        data=executed_orders_df,
        palette='viridis',
        sizes=(50, 400), # Adjust size range for better visualization
        legend='brief'
    )

plt.title('Market Price Evolution and TWAP Order Execution')
plt.xlabel('Time (seconds)')
plt.ylabel('Price')
plt.grid(True, linestyle='--', alpha=0.6)
plt.legend()
plt.tight_layout()
plt.show()

if not executed_orders_df.empty:
    plt.figure(figsize=(12, 6))
    sns.barplot(x=executed_orders_df['time'], y=executed_orders_df['executed_price'] - executed_orders_df['market_price'], palette='coolwarm')
    plt.title('Slippage per Executed Order')
    plt.xlabel('Time (seconds)')
    plt.ylabel('Slippage (Executed Price - Market Price)')
    plt.grid(axis='y', linestyle='--', alpha=0.6)
    plt.xticks(rotation=45)
    plt.tight_layout()
    plt.show()
else:
    logger.info("No executed orders to plot slippage.")