!pip install pandas matplotlib seaborn

import logging
import time
import random
from datetime import datetime, timedelta
from collections import deque
from typing import Dict, List, Any, Optional

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

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

def create_audit_state(retention_days: int = 30) -> Dict[str, Any]:
    """
    Initializes the state for the position snapshot system.

    Parameters
    ----------
    retention_days : int
        How many snapshots to keep in the rolling window.

    Returns
    -------
    dict
        Initial state containing snapshots and configuration.
    """
    logger.info(f"Initializing audit state with {retention_days} days retention.")
    return {
        "snapshots": deque(maxlen=retention_days),
        "config": {"retention_days": retention_days},
        "metrics": {"total_captured": 0, "failures": 0}
    }

def capture_daily_snapshot(state: Dict[str, Any], positions: Dict[str, float]) -> Dict[str, Any]:
    """
    Captures a new position snapshot into the state with retry logic.

    Parameters
    ----------
    state : dict
        Current system state.
    positions : dict
        Dictionary of tickers and quantities.

    Returns
    -------
    dict
        Updated state with the new snapshot.
    """
    max_retries = 3
    base_delay = 0.1

    for attempt in range(max_retries):
        try:
            # Simulate potential API failure
            if random.random() < 0.1:
                raise ConnectionError("Failed to connect to Position Service")

            timestamp = datetime.now().isoformat()
            snapshot = {
                "timestamp": timestamp,
                "data": positions.copy(),
                "checksum": hash(frozenset(positions.items()))
            }

            state["snapshots"].append(snapshot)
            state["metrics"]["total_captured"] += 1
            logger.info(f"Successfully captured snapshot at {timestamp}")
            return state

        except Exception as e:
            state["metrics"]["failures"] += 1
            jitter = random.uniform(0, 0.1)
            delay = (base_delay * (2 ** attempt)) + jitter
            logger.warning(f"Attempt {attempt + 1} failed: {e}. Retrying in {delay:.2f}s...")
            time.sleep(delay)

    logger.error("Max retries reached. Could not capture snapshot.")
    return state

def summarize_audit_trail(state: Dict[str, Any]) -> pd.DataFrame:
    """
    Aggregates snapshot data into a flat DataFrame.

    Parameters
    ----------
    state : dict
        The current audit state.

    Returns
    -------
    pd.DataFrame
        DataFrame containing historical positions.
    """
    records = []
    for snap in state["snapshots"]:
        for ticker, qty in snap["data"].items():
            records.append({
                "timestamp": pd.to_datetime(snap["timestamp"]),
                "ticker": ticker,
                "quantity": qty
            })

    df = pd.DataFrame(records)
    logger.debug(f"Generated summary with {len(df)} rows.")
    return df

# 1. Initialize State
audit_state = create_audit_state(retention_days=15)

# 2. Simulate 10 days of crypto position changes
# Using crypto assets: Bitcoin, Ethereum, and Solana
base_positions = {"BTC": 1.5, "ETH": 25.0, "SOL": 150.0}

for i in range(10):
    # Add random volatility typical of crypto markets
    current_positions = {k: round(v + random.uniform(-v*0.05, v*0.05), 4) for k, v in base_positions.items()}
    # Capture snapshot
    audit_state = capture_daily_snapshot(audit_state, current_positions)

# 3. Generate Summary
history_df = summarize_audit_trail(audit_state)
display(history_df.head(10))

# 4. Visualization
plt.figure(figsize=(12, 6))
sns.lineplot(data=history_df, x='timestamp', y='quantity', hue='ticker', marker='o')
plt.title("Daily Position Snapshots Over Time")
plt.xlabel("Date")
plt.ylabel("Quantity Held")
plt.grid(True, linestyle='--', alpha=0.6)
plt.legend(title='Asset')
plt.show()