# No external dependencies requiring pip install for this notebook, as `pandas` is usually pre-installed and `collections`, `logging`, `time`, `random` are built-in.

import pandas as pd
import logging
from collections import deque
import time
import random
from typing import Dict, Any, List, Optional, Deque

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

# The TRANSITIONS dictionary is already available in the kernel state.
# For demonstration purposes, we will ensure it's defined or referenced here.
# TRANSITIONS = {
#     'CREATED': {'CANCELLED', 'PENDING_EXECUTION'},
#     'PENDING_EXECUTION': {'CANCELLED', 'EXECUTED', 'PARTIALLY_EXECUTED', 'FAILED'},
#     'EXECUTED': {},
#     'CANCELLED': {},
#     'FAILED': {},
#     'PARTIALLY_EXECUTED': {'CANCELLED', 'EXECUTED', 'FAILED'}
# }
logger.info(f"Order state transitions defined: {TRANSITIONS}")

def create_order(user_id: str, symbol: str, order_type: str, amount: float, price: Optional[float] = None) -> Dict[str, Any]:
    """
    Initializes a new trading order.

    Parameters
    ----------
    user_id : str
        The ID of the user placing the order.
    symbol : str
        The trading pair (e.g., 'BTC/USD').
    order_type : str
        The type of order (e.g., 'MARKET', 'LIMIT').
    amount : float
        The quantity of the asset to trade.
    price : Optional[float], optional
        The limit price for a LIMIT order; None for MARKET orders, by default None.

    Returns
    -------
    Dict[str, Any]
        A dictionary representing the newly created order.
    """
    order_id = f"TRADE-{int(time.time() * 1000)}-{random.randint(1000, 9999)}"
    current_time = pd.Timestamp.now(tz='UTC').isoformat()
    order = {
        'order_id': order_id,
        'user_id': user_id,
        'symbol': symbol,
        'order_type': order_type,
        'amount': amount,
        'price': price,
        'current_state': 'CREATED',
        'created_at': current_time,
        'updated_at': current_time,
        'order_history': deque()
    }
    logger.info(f"Order {order_id} created in state CREATED.")
    return order

def record_event(order: Dict[str, Any], event_type: str, from_state: Optional[str], to_state: str, details: str) -> Dict[str, Any]:
    """
    Records an event in the order's history.

    Parameters
    ----------
    order : Dict[str, Any]
        The order dictionary to update.
    event_type : str
        The type of event (e.g., 'OrderCreated', 'StateChange').
    from_state : Optional[str]
        The state before the event.
    to_state : str
        The state after the event.
    details : str
        A descriptive message for the event.

    Returns
    -------
    Dict[str, Any]
        The updated order dictionary.
    """
    current_time = pd.Timestamp.now(tz='UTC').isoformat()
    event = {
        'timestamp': current_time,
        'event': event_type,
        'from_state': from_state,
        'to_state': to_state,
        'details': details
    }
    order['order_history'].append(event)
    order['updated_at'] = current_time
    logger.debug(f"Order {order['order_id']} - Recorded event: {event_type} ({from_state} -> {to_state})")
    return order

def validate_state_change(current_state: str, new_state: str) -> bool:
    """
    Validates if a state transition is allowed.

    Parameters
    ----------
    current_state : str
        The current state of the order.
    new_state : str
        The proposed new state for the order.

    Returns
    -------
    bool
        True if the transition is valid, False otherwise.
    """
    is_valid = new_state in TRANSITIONS.get(current_state, set())
    if not is_valid:
        logger.warning(f"Invalid state transition attempted: {current_state} -> {new_state}")
    return is_valid

def apply_state_change(order: Dict[str, Any], new_state: str, details: str) -> Dict[str, Any]:
    """
    Applies a state change to an order after validating the transition.

    Parameters
    ----------
    order : Dict[str, Any]
        The order dictionary to modify.
    new_state : str
        The target state for the order.
    details : str
        A description of why the state change is occurring.

    Returns
    -------
    Dict[str, Any]
        The updated order dictionary if the change was successful,
        or the original order if the change was invalid.
    """
    current_state = order['current_state']
    if validate_state_change(current_state, new_state):
        order['current_state'] = new_state
        order = record_event(order, f"StateChange:{current_state}->{new_state}", current_state, new_state, details)
        logger.info(f"Order {order['order_id']} state changed from {current_state} to {new_state}.")
    else:
        logger.warning(f"Order {order['order_id']}: Cannot change state from {current_state} to {new_state}. Invalid transition.")
        # Record an 'InvalidTransitionAttempt' event for auditing
        order = record_event(order, "InvalidTransitionAttempt", current_state, new_state, f"Attempted invalid transition from {current_state} to {new_state}.")
    return order

def simulate_exchange_response(order: Dict[str, Any], outcome: str = 'random', max_retries: int = 3, base_delay: float = 0.1) -> Dict[str, Any]:
    """
    Simulates an asynchronous response from a cryptocurrency exchange with retries.

    Parameters
    ----------
    order : Dict[str, Any]
        The current order dictionary.
    outcome : str, optional
        The simulated outcome ('success', 'failure', 'cancel', 'random'), by default 'random'.
    max_retries : int, optional
        Maximum number of retries for 'failure' outcome, by default 3.
    base_delay : float, optional
        Base delay in seconds for exponential backoff, by default 0.1.

    Returns
    -------
    Dict[str, Any]
        The updated order dictionary with the final state after simulation.
    """
    for attempt in range(max_retries + 1):
        delay = base_delay * (2 ** attempt) + random.uniform(0, 0.1)  # Exponential backoff with jitter
        time.sleep(delay)

        logger.debug(f"Order {order['order_id']} - Simulating exchange response (Attempt {attempt+1})...")

        simulated_status: str
        details_msg: str

        actual_outcome = outcome
        if outcome == 'random':
            actual_outcome = random.choice(['success', 'failure', 'cancel'])

        if actual_outcome == 'success':
            simulated_status = 'EXECUTED'
            details_msg = "Trade executed successfully on exchange"
        elif actual_outcome == 'cancel':
            simulated_status = 'CANCELLED'
            details_msg = "Order cancelled. Reason: User decided to cancel or exchange rejected."
        else: # failure
            simulated_status = 'FAILED'
            details_msg = "Exchange reported failure or timeout."

        # Attempt to apply the state change
        updated_order = apply_state_change(order, simulated_status, details_msg)

        # If the state changed to a terminal state or it was a success, break
        if updated_order['current_state'] in ['EXECUTED', 'CANCELLED', 'FAILED'] or actual_outcome == 'success':
            return updated_order

        # If it's a failure and retries are exhausted, set to FAILED
        if actual_outcome == 'failure' and attempt == max_retries:
            return apply_state_change(order, 'FAILED', "Max retries reached, order marked as FAILED.")

        # For temporary failures, apply a PENDING_EXECUTION state with retry information
        if actual_outcome == 'failure':
            order = apply_state_change(order, 'PENDING_EXECUTION', f"Order sent to exchange, anticipating failure. Retrying (Attempt {attempt+2})")
            logger.warning(f"Order {order['order_id']} - Exchange communication failed. Retrying in {delay:.2f}s.")

    return order # Should ideally not reach here if max_retries leads to FAILED

def process_order(order: Dict[str, Any], exchange_outcome: str = 'random', max_exchange_retries: int = 3) -> Dict[str, Any]:
    """
    Processes an order through its lifecycle, simulating exchange interaction.

    Parameters
    ----------
    order : Dict[str, Any]
        The initial order dictionary.
    exchange_outcome : str, optional
        The desired outcome from the simulated exchange ('success', 'failure', 'cancel', 'random'), by default 'random'.
    max_exchange_retries : int, optional
        Maximum retries for exchange communication, by default 3.

    Returns
    -------
    Dict[str, Any]
        The final order dictionary after processing.
    """
    # Initial event: OrderCreated
    order = record_event(order, 'OrderCreated', None, 'CREATED', f"Trade order {order['order_id']} created for user {order['user_id']}")

    # Transition to PENDING_EXECUTION
    order = apply_state_change(order, 'PENDING_EXECUTION', "Order sent to exchange for execution")

    # Simulate exchange response with retries
    order = simulate_exchange_response(order, outcome=exchange_outcome, max_retries=max_exchange_retries)

    logger.info(f"Order {order['order_id']} processing complete. Final state: {order['current_state']}")
    return order

def create_df_from_history(order_history: Deque[Dict[str, Any]]) -> pd.DataFrame:
    """
    Converts an order's history deque into a pandas DataFrame.

    Parameters
    ----------
    order_history : Deque[Dict[str, Any]]
        The deque containing historical events for an order.

    Returns
    -------
    pd.DataFrame
        A DataFrame representing the order's history.
    """
    if not order_history:
        return pd.DataFrame()
    df = pd.DataFrame(list(order_history))
    df['timestamp'] = pd.to_datetime(df['timestamp'])
    return df

# Create a successful order
order_success_crypto = create_order(
    user_id='crypto_user_001',
    symbol='BTC/USD',
    order_type='LIMIT',
    amount=0.01,
    price=60000.0
)
success_history_crypto = list(order_success_crypto['order_history'])

# Process the order with a successful outcome
order_success_crypto = process_order(order_success_crypto, exchange_outcome='success')
success_history_crypto = list(order_success_crypto['order_history']) # Update history after processing

# Display the final order state and history
logger.info(f"Final state of successful order: {order_success_crypto['current_state']}")
display(pd.DataFrame([order_success_crypto]))

# Convert history to DataFrame and display
success_df_crypto = create_df_from_history(order_success_crypto['order_history'])
display(success_df_crypto)

# Create a cancelled order
order_cancel_crypto = create_order(
    user_id='crypto_user_002',
    symbol='ETH/USD',
    order_type='MARKET',
    amount=0.5
)
cancel_history_crypto = list(order_cancel_crypto['order_history'])

# Process the order with a cancelled outcome
order_cancel_crypto = process_order(order_cancel_crypto, exchange_outcome='cancel')
cancel_history_crypto = list(order_cancel_crypto['order_history']) # Update history after processing

# Display the final order state and history
logger.info(f"Final state of cancelled order: {order_cancel_crypto['current_state']}")
display(pd.DataFrame([order_cancel_crypto]))

# Convert history to DataFrame and display
cancel_df_crypto = create_df_from_history(order_cancel_crypto['order_history'])
display(cancel_df_crypto)

# Create a potentially failed order
order_failed_crypto = create_order(
    user_id='crypto_user_003',
    symbol='ADA/USD',
    order_type='LIMIT',
    amount=100.0,
    price=0.7
)
failed_history_crypto = list(order_failed_crypto['order_history'])

# Process the order with a failure outcome (and max retries set to 1 for quick demonstration of failure)
# Note: To see multiple retries before failure, increase max_exchange_retries
order_failed_crypto = process_order(order_failed_crypto, exchange_outcome='failure', max_exchange_retries=1)
failed_history_crypto = list(order_failed_crypto['order_history']) # Update history after processing

# Display the final order state and history
logger.info(f"Final state of failed order: {order_failed_crypto['current_state']}")
display(pd.DataFrame([order_failed_crypto]))

# Convert history to DataFrame and display
failed_df_crypto = create_df_from_history(order_failed_crypto['order_history'])
display(failed_df_crypto)

# Create an order that is PENDING_EXECUTION
order_invalid_crypto = create_order(
    user_id='crypto_user_004',
    symbol='DOGE/USD',
    order_type='MARKET',
    amount=1000.0
)
order_invalid_crypto = record_event(order_invalid_crypto, 'OrderCreated', None, 'CREATED', f"Trade order {order_invalid_crypto['order_id']} created for user {order_invalid_crypto['user_id']}")
order_invalid_crypto = apply_state_change(order_invalid_crypto, 'PENDING_EXECUTION', "Ready for valid execution attempt")

invalid_history_crypto = list(order_invalid_crypto['order_history'])

# Attempt an invalid state transition (e.g., from PENDING_EXECUTION directly to CREATED)
order_invalid_crypto = apply_state_change(order_invalid_crypto, 'CREATED', "Attempting to revert to CREATED from PENDING_EXECUTION")
invalid_history_crypto = list(order_invalid_crypto['order_history']) # Update history after processing

# Display the final order state and history
logger.info(f"Final state of order after invalid transition attempt: {order_invalid_crypto['current_state']}")
display(pd.DataFrame([order_invalid_crypto]))

# Convert history to DataFrame and display
invalid_df_crypto = create_df_from_history(order_invalid_crypto['order_history'])
display(invalid_df_crypto)

import matplotlib.pyplot as plt
import seaborn as sns

def plot_order_timeline(df: pd.DataFrame, title: str):
    """
    Plots the event timeline for an order.

    Parameters
    ----------
    df : pd.DataFrame
        DataFrame containing order history with 'timestamp' and 'event' columns.
    title : str
        Title for the plot.
    """
    if df.empty:
        logger.warning(f"Cannot plot empty DataFrame for: {title}")
        return

    plt.figure(figsize=(12, 6))
    sns.scatterplot(x='timestamp', y='event', data=df, s=200, hue='event', legend=False)
    plt.plot(df['timestamp'], df['event'], linestyle='--', color='gray', alpha=0.7)
    plt.title(f'Order Event Timeline: {title}')
    plt.xlabel('Timestamp')
    plt.ylabel('Event')
    plt.xticks(rotation=45, ha='right')
    plt.grid(axis='y', linestyle='--', alpha=0.7)
    plt.tight_layout()
    plt.show()

# Plotting timelines for each scenario
plot_order_timeline(success_df_crypto, 'Successful Order')
plot_order_timeline(cancel_df_crypto, 'Cancelled Order')
plot_order_timeline(failed_df_crypto, 'Failed Order (with retries)')
plot_order_timeline(invalid_df_crypto, 'Invalid Transition Attempt')