!pip install pandas numpy

import collections
import datetime
import functools
import logging
import random
import time
import uuid
from collections import deque

import numpy as np
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_account(account_id: str, initial_balance: float) -> dict:
    """
    Initializes a new user account with a given ID and initial balance.

    Parameters
    ----------
    account_id : str
        A unique identifier for the account.
    initial_balance : float
        The starting balance for the account.

    Returns
    -------
    dict
        A dictionary representing the newly created account's state.

    Examples
    --------
    >>> account = create_account("user123", 1000.0)
    >>> account['balance']
    1000.0
    """
    if not isinstance(account_id, str) or not account_id:
        logger.error("Invalid account_id provided. Must be a non-empty string.")
        raise ValueError("Account ID must be a non-empty string.")
    if not isinstance(initial_balance, (int, float)) or initial_balance < 0:
        logger.error("Invalid initial_balance provided. Must be a non-negative number.")
        raise ValueError("Initial balance must be a non-negative number.")

    account_state = {
        "account_id": account_id,
        "balance": initial_balance,
        "created_at": datetime.datetime.now(datetime.timezone.utc).isoformat(),
        "transaction_history": [],  # List of transaction dictionaries
        "failed_attempts": deque(maxlen=5), # Track recent failed attempts for rate limiting
        "trusted_locations": ['New York', 'London'], # Example trusted locations
        "last_known_location": None # For geographic fencing
    }
    logger.info(f"Account '{account_id}' created with initial balance {initial_balance}.")
    return account_state

def perform_withdrawal(account_state: dict, amount: float, transaction_id: str = None, location: str = None) -> tuple[dict, bool]:
    """
    Simulates a withdrawal from an account, including checks for sufficient funds and logging.

    Parameters
    ----------
    account_state : dict
        The current state dictionary of the account.
    amount : float
        The amount of money to withdraw.
    transaction_id : str, optional
        A unique identifier for the transaction. If None, a UUID will be generated.
    location : str, optional
        The geographic location from which the withdrawal is initiated.

    Returns
    -------
    tuple[dict, bool]
        The updated account state and a boolean indicating if the withdrawal was successful.

    Examples
    --------
    >>> account = create_account("user456", 500.0)
    >>> updated_account, success = perform_withdrawal(account, 100.0, transaction_id="tx_1")
    >>> success
    True
    >>> updated_account['balance']
    400.0
    """
    if transaction_id is None:
        transaction_id = str(uuid.uuid4())

    transaction_record = {
        "transaction_id": transaction_id,
        "type": "withdrawal",
        "amount": amount,
        "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
        "location": location,
        "status": "pending"
    }

    if not isinstance(amount, (int, float)) or amount <= 0:
        logger.warning(f"[{transaction_id}] Invalid withdrawal amount: {amount}. Must be a positive number.")
        transaction_record["status"] = "failed: invalid amount"
        account_state["transaction_history"].append(transaction_record)
        return account_state, False

    if account_state["balance"] < amount:
        logger.warning(f"[{transaction_id}] Withdrawal failed for account '{account_state['account_id']}': Insufficient funds. Requested: {amount}, Available: {account_state['balance']}.")
        transaction_record["status"] = "failed: insufficient funds"
        account_state["transaction_history"].append(transaction_record)
        account_state["failed_attempts"].append({"timestamp": transaction_record["timestamp"], "type": "insufficient_funds"})
        return account_state, False

    # Simulate potential delays or external system calls
    time.sleep(random.uniform(0.05, 0.2))

    account_state["balance"] -= amount
    transaction_record["status"] = "success"
    account_state["transaction_history"].append(transaction_record)
    account_state["last_known_location"] = location # Update last known location

    logger.info(f"[{transaction_id}] Withdrawal successful for account '{account_state['account_id']}'. Amount: {amount}, New balance: {account_state['balance']}.")
    return account_state, True

def check_rate_limit(account_state: dict, max_attempts: int = 3, time_window_seconds: int = 300, cooldown_seconds: int = 60) -> tuple[dict, bool]:
    """
    Checks if an account has exceeded the rate limit for failed attempts and applies a cooldown if necessary.

    Parameters
    ----------
    account_state : dict
        The current state dictionary of the account.
    max_attempts : int, optional
        The maximum number of failed attempts allowed within the time window.
        Defaults to 3.
    time_window_seconds : int, optional
        The time window (in seconds) for counting failed attempts. Defaults to 300 (5 minutes).
    cooldown_seconds : int, optional
        The duration (in seconds) for which attempts are blocked after exceeding the limit.
        Defaults to 60 (1 minute).

    Returns
    -------
    tuple[dict, bool]
        The updated account state and a boolean indicating if the attempt is allowed.

    Examples
    --------
    >>> account = create_account("user789", 1000.0)
    >>> # Simulate failed attempts
    >>> account['failed_attempts'].append({'timestamp': (datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(seconds=10)).isoformat(), 'type': 'auth_fail'})
    >>> account['failed_attempts'].append({'timestamp': (datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(seconds=5)).isoformat(), 'type': 'auth_fail'})
    >>> updated_account, allowed = check_rate_limit(account, max_attempts=2, time_window_seconds=60)
    >>> allowed # Should be False if limit exceeded
    False
    """
    current_time = datetime.datetime.now(datetime.timezone.utc)
    recent_failed_attempts = deque([
        attempt for attempt in account_state["failed_attempts"]
        if (current_time - datetime.datetime.fromisoformat(attempt["timestamp"]).replace(tzinfo=datetime.timezone.utc)).total_seconds() < time_window_seconds
    ], maxlen=account_state["failed_attempts"].maxlen)

    account_state["failed_attempts"] = recent_failed_attempts # Update deque to remove old attempts

    if len(recent_failed_attempts) >= max_attempts:
        last_attempt_time = datetime.datetime.fromisoformat(recent_failed_attempts[-1]["timestamp"]).replace(tzinfo=datetime.timezone.utc)
        if (current_time - last_attempt_time).total_seconds() < cooldown_seconds:
            logger.warning(f"Account '{account_state['account_id']}' is rate-limited. Too many failed attempts recently.")
            return account_state, False
        else:
            # Cooldown period has passed, clear attempts for a fresh start
            logger.info(f"Account '{account_state['account_id']}' cooldown period expired. Clearing failed attempts.")
            account_state["failed_attempts"].clear()

    logger.debug(f"Account '{account_state['account_id']}' is within rate limits. Failed attempts: {len(recent_failed_attempts)}.")
    return account_state, True

def check_geographic_fencing(account_state: dict, current_location: str) -> tuple[dict, bool]:
    """
    Checks if the current withdrawal location is within the account's trusted geographic areas.

    Parameters
    ----------
    account_state : dict
        The current state dictionary of the account.
    current_location : str
        The geographic location from which the withdrawal is initiated.

    Returns
    -------
    tuple[dict, bool]
        The updated account state and a boolean indicating if the location is trusted (True) or untrusted (False).

    Examples
    --------
    >>> account = create_account("user_geo", 1000.0)
    >>> account['trusted_locations'] = ['New York', 'London']
    >>> updated_account, allowed = check_geographic_fencing(account, "New York")
    >>> allowed
    True
    >>> updated_account, allowed = check_geographic_fencing(account, "Moscow")
    >>> allowed
    False
    """
    if current_location is None or current_location.strip() == "":
        logger.warning(f"Account '{account_state['account_id']}': Withdrawal attempt from unknown location. Allowing by default but logging.")
        return account_state, True # Allow if location is unknown, but log for review

    if current_location not in account_state.get("trusted_locations", []):
        logger.warning(f"Account '{account_state['account_id']}': Withdrawal attempt from untrusted location: {current_location}.")
        return account_state, False

    logger.info(f"Account '{account_state['account_id']}': Withdrawal from trusted location: {current_location}.")
    return account_state, True

def block_withdrawal(account_state: dict, transaction_details: dict, is_suspicious: bool, reason: str = "") -> tuple[dict, bool]:
    """
    Decides whether to block a withdrawal based on suspicious flags and security analysis.

    Parameters
    ----------
    account_state : dict
        The current state dictionary of the account.
    transaction_details : dict
        A dictionary containing details of the transaction to be evaluated.
    is_suspicious : bool
        True if preliminary checks have flagged the transaction as suspicious.
    reason : str, optional
        A descriptive reason for blocking the withdrawal.

    Returns
    -------
    tuple[dict, bool]
        The updated account state and a boolean indicating if the withdrawal was blocked.

    Examples
    --------
    >>> account = create_account("user_block", 1000.0)
    >>> tx_details = {"amount": 500, "transaction_id": "tx_block1", "location": "Tokyo"}
    >>> updated_account, blocked = block_withdrawal(account, tx_details, True, reason="Untrusted location")
    >>> blocked
    True
    """
    transaction_id = transaction_details.get("transaction_id", "N/A")

    if is_suspicious:
        logger.warning(f"[{transaction_id}] Withdrawal for account '{account_state['account_id']}' BLOCKED. Reason: {reason or 'Suspicious activity detected'}.")
        # Add blocked transaction to history with status 'blocked'
        transaction_details["status"] = "blocked"
        transaction_details["block_reason"] = reason or "Suspicious activity detected"
        transaction_details["timestamp"] = datetime.datetime.now(datetime.timezone.utc).isoformat()
        account_state["transaction_history"].append(transaction_details)
        account_state["failed_attempts"].append({"timestamp": transaction_details["timestamp"], "type": "blocked_withdrawal"})
        return account_state, True
    else:
        logger.info(f"[{transaction_id}] Withdrawal for account '{account_state['account_id']}' allowed to proceed (not suspicious).")
        return account_state, False

def detect_anomaly(account_state: dict, transaction_details: dict,
                   large_withdrawal_threshold: float = 1000.0,
                   recent_failed_attempts_threshold: int = 3,
                   time_window_for_attempts: int = 300) -> tuple[bool, str]:
    """
    Detects anomalies in a withdrawal attempt based on predefined rules.

    Parameters
    ----------
    account_state : dict
        The current state dictionary of the account.
    transaction_details : dict
        A dictionary containing details of the transaction to be evaluated.
    large_withdrawal_threshold : float, optional
        Amount above which a withdrawal is considered large. Defaults to 1000.0.
    recent_failed_attempts_threshold : int, optional
        Number of recent failed attempts to trigger an anomaly. Defaults to 3.
    time_window_for_attempts : int, optional
        Time window in seconds for counting recent failed attempts. Defaults to 300.

    Returns
    -------
    tuple[bool, str]
        A boolean indicating True if an anomaly is detected, and a string describing the reason.

    Examples
    --------
    >>> account = create_account("user_anomaly", 5000.0)
    >>> tx_details = {"amount": 1500, "transaction_id": "tx_anomaly1", "location": "New York"}
    >>> is_anomaly, reason = detect_anomaly(account, tx_details)
    >>> is_anomaly
    True
    >>> reason
    'Large withdrawal amount (1500.0) exceeding threshold (1000.0)'
    """
    amount = transaction_details.get("amount", 0.0)
    location = transaction_details.get("location", None)
    transaction_id = transaction_details.get("transaction_id", "N/A")

    # Rule 1: Unusually large withdrawal amount
    if amount > large_withdrawal_threshold:
        logger.warning(f"[{transaction_id}] Anomaly detected for account '{account_state['account_id']}': Large withdrawal amount ({amount}) exceeding threshold ({large_withdrawal_threshold}).")
        return True, f"Large withdrawal amount ({amount}) exceeding threshold ({large_withdrawal_threshold})"

    # Rule 2: Multiple failed attempts recently
    current_time = datetime.datetime.now(datetime.timezone.utc)
    recent_failed_attempts = [
        attempt for attempt in account_state.get("failed_attempts", deque())
        if (current_time - datetime.datetime.fromisoformat(attempt["timestamp"]).replace(tzinfo=datetime.timezone.utc)).total_seconds() < time_window_for_attempts
    ]
    if len(recent_failed_attempts) >= recent_failed_attempts_threshold:
        logger.warning(f"[{transaction_id}] Anomaly detected for account '{account_state['account_id']}': Multiple failed attempts ({len(recent_failed_attempts)}) within {time_window_for_attempts} seconds.")
        return True, f"Multiple failed attempts ({len(recent_failed_attempts)}) recently"

    # Rule 3: Withdrawal from a new/untrusted location
    if location and location not in account_state.get("trusted_locations", []):
        logger.warning(f"[{transaction_id}] Anomaly detected for account '{account_state['account_id']}': Withdrawal from untrusted location: {location}.")
        return True, f"Withdrawal from untrusted location: {location}"

    logger.info(f"[{transaction_id}] No anomalies detected for account '{account_state['account_id']}'.")
    return False, "No anomaly detected"

def generate_audit_log(event_type: str, account_id: str, data: dict = None) -> dict:
    """
    Generates a comprehensive audit log entry for a given event.

    Parameters
    ----------
    event_type : str
        The type of event (e.g., 'withdrawal_success', 'withdrawal_blocked').
    account_id : str
        The ID of the account related to the event.
    data : dict, optional
        Additional details pertinent to the event (e.g., amount, location, reason).
        Defaults to an empty dictionary.

    Returns
    -------
    dict
        A dictionary representing the audit log entry.

    Examples
    --------
    >>> log_entry = generate_audit_log("withdrawal_success", "user123", {"amount": 100, "new_balance": 900})
    >>> log_entry['event_type']
    'withdrawal_success'
    """
    if data is None:
        data = {}

    log_entry = {
        "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
        "event_id": str(uuid.uuid4()),
        "event_type": event_type,
        "account_id": account_id,
        "data": data
    }
    logger.info(f"AUDIT: [Account: {account_id}] Event: {event_type} - Details: {data}")
    return log_entry

def try_with_exponential_backoff(max_retries: int = 3, base_delay: float = 1.0, max_delay: float = 60.0, errors: tuple = (Exception,)): # Changed default errors for broader applicability
    """
    A decorator that retries a function with exponential backoff and jitter.

    Parameters
    ----------
    max_retries : int, optional
        The maximum number of times to retry the decorated function. Defaults to 3.
    base_delay : float, optional
        The base delay in seconds for exponential backoff. Defaults to 1.0.
    max_delay : float, optional
        The maximum delay in seconds between retries. Defaults to 60.0.
    errors : tuple, optional
        A tuple of exception types to catch and retry on. Defaults to (Exception,).

    Returns
    -------
    Callable
        The decorated function with retry logic.

    Examples
    --------
    >>> @try_with_exponential_backoff(max_retries=2, base_delay=0.1, errors=(ValueError,))
    >>> def flaky_function():
    >>>     if random.random() < 0.7: # 70% chance of failure
    >>>         raise ValueError("Simulated transient error")
    >>>     return "Success"
    >>> # Example usage:
    >>> # result = flaky_function()
    >>> # print(result) # Might print 'Success' or raise ValueError after retries
    """
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for i in range(max_retries + 1):
                try:
                    return func(*args, **kwargs)
                except errors as e:
                    if i == max_retries:
                        logger.error(f"Function '{func.__name__}' failed after {max_retries} retries: {e}")
                        raise

                    # Exponential backoff with jitter
                    delay = min(max_delay, base_delay * (2 ** i) + random.uniform(0, base_delay))
                    logger.warning(f"Function '{func.__name__}' failed with '{e}'. Retrying in {delay:.2f} seconds (attempt {i+1}/{max_retries}).")
                    time.sleep(delay)
            return func(*args, **kwargs) # Should not be reached, but for type hinting
        return wrapper
    return decorator

def process_withdrawal_flow(account_state: dict, amount: float, location: str, all_audit_logs: list,
                            large_withdrawal_threshold: float = 1000.0,
                            max_failed_attempts: int = 3,
                            failed_attempts_window: int = 300,
                            cooldown_period: int = 60) -> tuple[dict, bool, str]:
    """
    Orchestrates the security workflow for processing withdrawal requests using standalone functions.
    """
    transaction_id = str(uuid.uuid4())
    transaction_details = {"amount": amount, "transaction_id": transaction_id, "location": location}
    account_id = account_state['account_id']

    all_audit_logs.append(generate_audit_log("withdrawal_request", account_id, transaction_details))

    # Step 1: Rate Limiting Check
    account_state, allowed_by_rate_limit = check_rate_limit(account_state,
                                                             max_attempts=max_failed_attempts,
                                                             time_window_seconds=failed_attempts_window,
                                                             cooldown_seconds=cooldown_period)
    if not allowed_by_rate_limit:
        reason = "Rate limit exceeded"
        account_state, _ = block_withdrawal(account_state, transaction_details, True, reason)
        all_audit_logs.append(generate_audit_log("withdrawal_blocked", account_id, {**transaction_details, "reason": reason}))
        return account_state, False, reason

    # Step 2: Geographic Fencing Check
    account_state, allowed_by_geo = check_geographic_fencing(account_state, location)
    if not allowed_by_geo:
        reason = f"Untrusted location: {location}"
        account_state, _ = block_withdrawal(account_state, transaction_details, True, reason)
        all_audit_logs.append(generate_audit_log("withdrawal_blocked", account_id, {**transaction_details, "reason": reason}))
        return account_state, False, reason

    # Step 3: Anomaly Detection
    is_anomaly, anomaly_reason = detect_anomaly(account_state, transaction_details,
                                                large_withdrawal_threshold=large_withdrawal_threshold,
                                                recent_failed_attempts_threshold=max_failed_attempts,
                                                time_window_for_attempts=failed_attempts_window)
    if is_anomaly:
        # Decide whether to block based on anomaly
        # For this demo, we will block all detected anomalies
        account_state, _ = block_withdrawal(account_state, transaction_details, True, anomaly_reason)
        all_audit_logs.append(generate_audit_log("withdrawal_blocked", account_id, {**transaction_details, "reason": anomaly_reason}))
        return account_state, False, anomaly_reason

    # Step 4: Perform Withdrawal (if all checks pass)
    updated_account, success = perform_withdrawal(account_state, amount, transaction_id, location)
    if success:
        all_audit_logs.append(generate_audit_log("withdrawal_success", account_id, {**transaction_details, "new_balance": updated_account['balance']}))
        return updated_account, True, "Withdrawal successful"
    else:
        # This else block captures failures from perform_withdrawal itself (e.g., insufficient funds)
        last_tx_status = updated_account['transaction_history'][-1]['status'] if updated_account['transaction_history'] else 'unknown_error'
        reason = f"Withdrawal failed: {last_tx_status}"
        all_audit_logs.append(generate_audit_log("withdrawal_failed", account_id, {**transaction_details, "reason": reason}))
        return updated_account, False, reason

# Initialize Accounts
accounts = {
    "user_legit": create_account("user_legit", 5000.0),
    "user_high_risk": create_account("user_high_risk", 7500.0),
    "user_rate_limit": create_account("user_rate_limit", 2000.0),
    "user_geo": create_account("user_geo", 3000.0)
}

accounts["user_legit"]['trusted_locations'] = ['New York', 'London', 'Paris']
accounts["user_high_risk"]['trusted_locations'] = ['London', 'Zurich']
accounts["user_rate_limit"]['trusted_locations'] = ['Berlin']
accounts["user_geo"]['trusted_locations'] = ['Tokyo', 'Kyoto']

# Global list to collect audit logs
all_audit_logs = []

# Define simulation thresholds
SIM_LARGE_WITHDRAWAL_THRESHOLD = 1200.0
SIM_MAX_FAILED_ATTEMPTS = 3
SIM_FAILED_ATTEMPTS_WINDOW = 60
SIM_COOLDOWN_PERIOD = 10

print("\n--- Starting Transaction Simulation ---")

# Scenario 1: Legitimate withdrawal
print("\n--- user_legit: Legitimate withdrawal ---")
accounts["user_legit"], success, msg = process_withdrawal_flow(
    accounts["user_legit"], 100.0, "New York", all_audit_logs,
    large_withdrawal_threshold=SIM_LARGE_WITHDRAWAL_THRESHOLD,
    max_failed_attempts=SIM_MAX_FAILED_ATTEMPTS,
    failed_attempts_window=SIM_FAILED_ATTEMPTS_WINDOW,
    cooldown_period=SIM_COOLDOWN_PERIOD
)
print(f"Result: {msg}, Success: {success}, Balance: {accounts['user_legit']['balance']:.2f}")

# Scenario 2: Large withdrawal (Anomaly Detection)
print("\n--- user_high_risk: Large withdrawal ---")
accounts["user_high_risk"], success, msg = process_withdrawal_flow(
    accounts["user_high_risk"], 1500.0, "London", all_audit_logs,
    large_withdrawal_threshold=SIM_LARGE_WITHDRAWAL_THRESHOLD,
    max_failed_attempts=SIM_MAX_FAILED_ATTEMPTS,
    failed_attempts_window=SIM_FAILED_ATTEMPTS_WINDOW,
    cooldown_period=SIM_COOLDOWN_PERIOD
)
print(f"Result: {msg}, Success: {success}, Balance: {accounts['user_high_risk']['balance']:.2f}")

# Scenario 3: Untrusted geographic location
print("\n--- user_geo: Untrusted location ---")
accounts["user_geo"], success, msg = process_withdrawal_flow(
    accounts["user_geo"], 500.0, "Beijing", all_audit_logs,
    large_withdrawal_threshold=SIM_LARGE_WITHDRAWAL_THRESHOLD,
    max_failed_attempts=SIM_MAX_FAILED_ATTEMPTS,
    failed_attempts_window=SIM_FAILED_ATTEMPTS_WINDOW,
    cooldown_period=SIM_COOLDOWN_PERIOD
)
print(f"Result: {msg}, Success: {success}, Balance: {accounts['user_geo']['balance']:.2f}")

# Scenario 4: Rate Limiting (multiple failed attempts)
print("\n--- user_rate_limit: Rate limit attempts ---")
for _ in range(4):
    # Simulate failed withdrawal (e.g., insufficient funds deliberately)
    accounts["user_rate_limit"], success, msg = process_withdrawal_flow(
        accounts["user_rate_limit"], 5000.0, "Berlin", all_audit_logs,
        large_withdrawal_threshold=SIM_LARGE_WITHDRAWAL_THRESHOLD,
        max_failed_attempts=SIM_MAX_FAILED_ATTEMPTS,
        failed_attempts_window=SIM_FAILED_ATTEMPTS_WINDOW,
        cooldown_period=SIM_COOLDOWN_PERIOD
    )
    print(f"Result: {msg}, Success: {success}, Failed attempts: {len(accounts['user_rate_limit']['failed_attempts'])}")
    time.sleep(1) # Simulate some time between attempts

# Attempt after rate limit is active
accounts["user_rate_limit"], success, msg = process_withdrawal_flow(
    accounts["user_rate_limit"], 100.0, "Berlin", all_audit_logs,
    large_withdrawal_threshold=SIM_LARGE_WITHDRAWAL_THRESHOLD,
    max_failed_attempts=SIM_MAX_FAILED_ATTEMPTS,
    failed_attempts_window=SIM_FAILED_ATTEMPTS_WINDOW,
    cooldown_period=SIM_COOLDOWN_PERIOD
)
print(f"Result: {msg}, Success: {success}, Failed attempts: {len(accounts['user_rate_limit']['failed_attempts'])}")

# Scenario 5: Mixed scenario - Legit from trusted, then untrusted, then large
print("\n--- user_legit: Mixed scenarios ---")
accounts["user_legit"], success, msg = process_withdrawal_flow(
    accounts["user_legit"], 200.0, "Paris", all_audit_logs,
    large_withdrawal_threshold=SIM_LARGE_WITHDRAWAL_THRESHOLD,
    max_failed_attempts=SIM_MAX_FAILED_ATTEMPTS,
    failed_attempts_window=SIM_FAILED_ATTEMPTS_WINDOW,
    cooldown_period=SIM_COOLDOWN_PERIOD
)
print(f"Result: {msg}, Success: {success}, Balance: {accounts['user_legit']['balance']:.2f}")

accounts["user_legit"], success, msg = process_withdrawal_flow(
    accounts["user_legit"], 300.0, "Cairo", all_audit_logs,
    large_withdrawal_threshold=SIM_LARGE_WITHDRAWAL_THRESHOLD,
    max_failed_attempts=SIM_MAX_FAILED_ATTEMPTS,
    failed_attempts_window=SIM_FAILED_ATTEMPTS_WINDOW,
    cooldown_period=SIM_COOLDOWN_PERIOD
) # Untrusted
print(f"Result: {msg}, Success: {success}, Balance: {accounts['user_legit']['balance']:.2f}")

accounts["user_legit"], success, msg = process_withdrawal_flow(
    accounts["user_legit"], 1300.0, "New York", all_audit_logs,
    large_withdrawal_threshold=SIM_LARGE_WITHDRAWAL_THRESHOLD,
    max_failed_attempts=SIM_MAX_FAILED_ATTEMPTS,
    failed_attempts_window=SIM_FAILED_ATTEMPTS_WINDOW,
    cooldown_period=SIM_COOLDOWN_PERIOD
) # Large, but trusted location
print(f"Result: {msg}, Success: {success}, Balance: {accounts['user_legit']['balance']:.2f}")

print("\n--- Simulation Complete ---")

# Display some audit logs
print("\n--- Sample Audit Logs ---")
for log in all_audit_logs[:5]: # Display first 5 logs
    print(f"Event: {log['event_type']} | Account: {log['account_id']} | Data: {log['data']}")

# Convert audit logs to DataFrame
audit_df = pd.DataFrame(all_audit_logs)

# Extract relevant information from 'data' column for easier analysis
audit_df['amount'] = audit_df['data'].apply(lambda x: x.get('amount'))
audit_df['location'] = audit_df['data'].apply(lambda x: x.get('location'))
audit_df['reason'] = audit_df['data'].apply(lambda x: x.get('reason'))
audit_df['block_reason'] = audit_df['data'].apply(lambda x: x.get('block_reason'))
audit_df['new_balance'] = audit_df['data'].apply(lambda x: x.get('new_balance'))

# Convert timestamp to datetime objects
audit_df['timestamp'] = pd.to_datetime(audit_df['timestamp'])

# Display basic information about the audit log DataFrame
print("\n--- Audit Log DataFrame Info ---")
print(audit_df.info())
print("\n--- Audit Log Head ---")
print(audit_df.head())

# Calculate overall statistics
total_requests = len(audit_df)
successful_withdrawals = audit_df[audit_df['event_type'] == 'withdrawal_success'].shape[0]
blocked_withdrawals = audit_df[audit_df['event_type'] == 'withdrawal_blocked'].shape[0]
failed_withdrawals = audit_df[audit_df['event_type'] == 'withdrawal_failed'].shape[0]

print(f"\nTotal Withdrawal Requests: {total_requests}")
print(f"Successful Withdrawals: {successful_withdrawals}")
print(f"Blocked Withdrawals: {blocked_withdrawals}")
print(f"Failed Withdrawals (e.g., insufficient funds): {failed_withdrawals}")

# Analyze reasons for blocked withdrawals
blocked_reasons = audit_df[audit_df['event_type'] == 'withdrawal_blocked']['reason'].value_counts()
print("\nReasons for Blocked Withdrawals:")
print(blocked_reasons)

# Analyze event types
event_type_counts = audit_df['event_type'].value_counts()
print("\nEvent Type Counts:")
print(event_type_counts)

plt.figure(figsize=(10, 6))
sns.barplot(x=event_type_counts.index, y=event_type_counts.values, palette='viridis')
plt.title('Distribution of Withdrawal Event Types')
plt.xlabel('Event Type')
plt.ylabel('Count')
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

plt.figure(figsize=(12, 7))
sns.barplot(x=blocked_reasons.values, y=blocked_reasons.index, palette='magma')
plt.title('Reasons for Blocked Withdrawals')
plt.xlabel('Count')
plt.ylabel('Reason for Blocking')
plt.grid(axis='x', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()