import collections

# Code Part 1: Demonstrating KeyError and basic dictionary access
# Forge a new dictionary for demonstration
user_data = {
    "id": "USR001",
    "name": "Alice Smith",
    "email": "alice@example.com"
}

print("--- Part 1: Dictionary Fundamentals and Common Pitfalls ---")

# Accessing an existing key: This operates correctly.
print(f"User name: {user_data['name']}")

# Attempting to access a non-existent key: This will trigger a KeyError.
try:
    print(f"User phone: {user_data['phone']}")
except KeyError as e:
    print(f"Caught an expected error: KeyError - {e}")
    print("Explanation: Attempting to retrieve a value using a key that does not exist in the dictionary directly raises a KeyError.")

# Demonstrating how unchecked key access can lead to issues
def get_user_status(user_id, data_store):
    # Without proper validation, this could fail if user_id is not in data_store
    # or if data_store[user_id] is not a dict with 'status'
    return data_store.get(user_id, {}).get("status", "unknown")

sample_store = {"USR001": {"status": "active"}, "USR002": {"status": "inactive"}}
print(f"Status for USR001: {get_user_status('USR001', sample_store)}")
print(f"Status for USR003 (non-existent user): {get_user_status('USR003', sample_store)}")
print("Explanation: Using .get() defensively at multiple levels prevents KeyError and gracefully handles missing data.")

import collections

# Code Part 2: Proactive Key Management: Validation and Safe Access
# Forge a dictionary for secure access examples
config_settings = {
    "timeout_seconds": 30,
    "retries_count": 5,
    "log_level": "INFO"
}

print("\n--- Part 2: Proactive Key Management: Validation and Safe Access ---")

# 1. Utilize dict.get() for safe key access
# Get an existing value
timeout = config_settings.get("timeout_seconds")
print(f"Timeout (existing): {timeout}")

# Get a non-existent value, returns None by default
max_memory = config_settings.get("max_memory_mb")
print(f"Max memory (non-existent, default None): {max_memory}")

# Get a non-existent value with a specified default
database_url = config_settings.get("database_url", "sqlite:///app.db")
print(f"Database URL (non-existent, custom default): {database_url}")

# 2. Validate key presence using 'in' operator
if "log_level" in config_settings:
    print(f"'log_level' exists. Current value: {config_settings['log_level']}")
else:
    print("'log_level' does not exist.")

if "api_key" not in config_settings:
    print("'api_key' does not exist. Consider adding it with a default value.")

# 3. Leverage collections.defaultdict for automatic default values
# Engineer a defaultdict where missing keys will initialize to an empty list
user_permissions = collections.defaultdict(list)
user_permissions["admin"].append("create")
user_permissions["admin"].append("delete")
user_permissions["guest"].append("view")

print(f"Admin permissions: {user_permissions['admin']}")
# Accessing a new key 'editor' automatically initializes an empty list
print(f"Editor permissions (new, auto-initialized): {user_permissions['editor']}")
user_permissions['editor'].append("edit")
print(f"Editor permissions after adding: {user_permissions['editor']}")

# 4. Implement custom validation for key insertion
def add_setting(settings_dict: dict, key: any, value: any):
    # Example: Ensure key is a non-empty string and value is not None
    if not isinstance(key, str) or not key or not key.isidentifier():
        print(f"Validation Error: Key '{key}' is not a valid identifier string.")
        return
    if value is None:
        print(f"Validation Error: Value for key '{key}' cannot be None.")
        return
    if key in settings_dict:
        print(f"Warning: Key '{key}' already exists. Overwriting.")
    settings_dict[key] = value

print("\nApplying custom validation:")
new_app_config = {}
add_setting(new_app_config, "app_name", "MyApplication") # Valid
add_setting(new_app_config, 123, "invalid_key_type") # Invalid key type
add_setting(new_app_config, "invalid key", "value") # Invalid key format
add_setting(new_app_config, "empty_value", None) # Invalid value
add_setting(new_app_config, "app_name", "NewApp") # Overwriting
print(f"New app config: {new_app_config}")

import copy

# Code Part 3: Safeguarding Data Integrity: Immutability and State Management
# Forge a nested dictionary to illustrate copy behaviors
original_config = {
    "app_name": "API Service",
    "database": {
        "host": "localhost",
        "port": 5432,
        "user": "admin"
    },
    "features": ["auth", "logging"]
}

print("\n--- Part 3: Safeguarding Data Integrity: Immutability and State Management ---")

# 1. Demonstrating shallow copy dangers
# A shallow copy duplicates the top-level, but shares nested references
shallow_copy_config = original_config.copy()

print("\nInitial states:")
print(f"Original config database host: {original_config['database']['host']}")
print(f"Shallow copy config database host: {shallow_copy_config['database']['host']}")

# Modify a nested dictionary in the shallow copy
shallow_copy_config["database"]["host"] = "prod-db-server"
shallow_copy_config["features"].append("metrics")

print("\nAfter modifying shallow copy's nested elements:")
# Observe: Original config's nested database host has also changed!
print(f"Original config database host (after shallow modification): {original_config['database']['host']}")
print(f"Original config features (after shallow modification): {original_config['features']}")
print(f"Shallow copy config database host: {shallow_copy_config['database']['host']}")
print(f"Shallow copy config features: {shallow_copy_config['features']}")
print("Explanation: Shallow copy shares references to nested objects. Modifying nested objects in the copy affects the original.")

# Reset original for deep copy demonstration
original_config = {
    "app_name": "API Service",
    "database": {
        "host": "localhost",
        "port": 5432,
        "user": "admin"
    },
    "features": ["auth", "logging"]
}

# 2. Utilizing deep copy for complete independence
deep_copy_config = copy.deepcopy(original_config)

print("\nInitial states (for deep copy):")
print(f"Original config database host: {original_config['database']['host']}")
print(f"Deep copy config database host: {deep_copy_config['database']['host']}")

# Modify a nested dictionary in the deep copy
deep_copy_config["database"]["host"] = "test-db-server"
deep_copy_config["features"].append("monitoring")

print("\nAfter modifying deep copy's nested elements:")
# Observe: Original config remains unaffected
print(f"Original config database host (after deep modification): {original_config['database']['host']}")
print(f"Original config features (after deep modification): {original_config['features']}")
print(f"Deep copy config database host: {deep_copy_config['database']['host']}")
print(f"Deep copy config features: {deep_copy_config['features']}")
print("Explanation: Deep copy recursively duplicates all nested objects, ensuring complete independence from the original.")

# 3. Briefly introduce immutability concept (e.g., tuples as keys)
# While Python's dicts are mutable, we can enforce immutability for keys.
immutable_coords = {(1, 2): "point_A", (3, 4): "point_B"}
print(f"\nImmutable keys example: {immutable_coords}")
# Attempting to modify a tuple key will fail, as tuples are immutable:
# immutable_coords[(1, 2)][0] = 5 # This would raise an error if (1,2) was a list
print("Explanation: Using immutable types like tuples as keys prevents accidental modification of dictionary keys.")

import threading
import collections
from typing import Dict, Any, Optional

# Code Part 4: Advanced Strategies: Context Managers, Type Hinting, and Atomic Operations
# Forge a dictionary for advanced error handling
service_status: Dict[str, str] = {
    "auth_service": "online",
    "data_processor": "offline"
}

print("\n--- Part 4: Advanced Strategies: Context Managers, Type Hinting, and Atomic Operations ---")

# 1. Robust error handling with try-except for KeyError
def get_service_health(service_name: str, status_dict: Dict[str, str]) -> str:
    try:
        return status_dict[service_name]
    except KeyError:
        print(f"Warning: Service '{service_name}' status not found. Returning 'unknown'.")
        return "unknown"

print(f"Auth service status: {get_service_health('auth_service', service_status)}")
print(f"Billing service status: {get_service_health('billing_service', service_status)}") # Non-existent

# 2. Leveraging Type Hinting for clarity and early error detection
# Type hints improve readability and allow static analysis tools to catch errors.
# Define a type alias for a user profile dictionary for better readability
UserProfile = Dict[str, Any]

def update_user_profile(user_id: str, profile_data: UserProfile) -> None:
    """
    Updates a user's profile in a simulated database.
    Profile data is expected to be a dictionary with string keys.
    """
    # In a real application, 'users' would be a persistent store.
    # For demonstration, we use a simple global dict.
    global global_users # Declare intent to modify global variable
    global_users: Dict[str, UserProfile] = {
        "user123": {"name": "John Doe", "email": "john@example.com"}
    }
    if user_id in global_users:
        global_users[user_id].update(profile_data)
        print(f"Profile for {user_id} updated: {global_users[user_id]}")
    else:
        global_users[user_id] = profile_data # Create if not exists
        print(f"New profile for {user_id} created: {global_users[user_id]}")

# Initialize global_users for demonstration
global_users: Dict[str, UserProfile] = {}

update_user_profile("user123", {"email": "john.doe@newmail.com", "age": 30})
update_user_profile("user456", {"name": "Jane Smith", "city": "New York"})

# 3. Atomic Operations for Concurrent Dictionary Access (Conceptual, simplified)
# In a multi-threaded environment, concurrent modifications can lead to race conditions.
# We use a Lock to ensure atomic updates.
shared_metrics: Dict[str, int] = collections.defaultdict(int)
metrics_lock = threading.Lock()

def increment_metric(metric_name: str, value: int = 1):
    # We ensure that reading, modifying, and writing back is an atomic operation
    with metrics_lock:
        shared_metrics[metric_name] += value
    print(f"Thread Safe: Metric '{metric_name}' incremented to {shared_metrics[metric_name]} (Thread {threading.current_thread().name})")

# Simulate concurrent updates
threads = []
for i in range(5):
    t = threading.Thread(target=increment_metric, args=("page_views",), name=f"Thread-{i}")
    threads.append(t)
    t.start()
for t in threads:
    t.join()

print(f"Final shared metrics: {shared_metrics}")
print("Explanation: The 'with metrics_lock:' ensures that only one thread can modify 'shared_metrics' at a time, preventing race conditions and ensuring data consistency.")