import datason

# These attacks are now BLOCKED with SecurityError:
deep_dict_attack = {}
current = deep_dict_attack
for i in range(1005):  # Way over limit of 50
    current["nest"] = {}
    current = current["nest"]

try:
    datason.serialize(deep_dict_attack)
except datason.SecurityError as e:
    print(f"✅ BLOCKED: {e}")
    # Output: "Maximum serialization depth (51) exceeded limit (50)"

# These attacks are now BLOCKED with SecurityError:
massive_dict = {f"key_{i}": i for i in range(200_000)}  # > 100K limit
massive_list = [f"item_{i}" for i in range(200_000)]   # > 100K limit

try:
    datason.serialize(massive_dict)
except datason.SecurityError as e:
    print(f"✅ BLOCKED: {e}")
    # Output: "Dictionary size (200000) exceeds maximum allowed size (100000)"

# These attacks are now SAFELY HANDLED with warnings:
circular_dict = {}
circular_dict["self"] = circular_dict

with warnings.catch_warnings(record=True) as w:
    result = datason.serialize(circular_dict)
    print(f"✅ SAFE: {w[0].message}")
    print(f"Result: {result}")
    # Output: "Circular reference detected at depth 1. Replacing with None..."
    # Result: {"self": None}

# These attacks trigger safe truncation with warnings:
massive_string = "A" * 1_000_001  # Over 1M limit

with warnings.catch_warnings(record=True) as w:
    result = datason.serialize(massive_string)
    print(f"✅ TRUNCATED: {w[0].message}")
    print(f"Ends with: {result[-20:]}")
    # Output: "String length (1000001) exceeds maximum (1000000). Truncating."
    # Result: "AAAA...AAAA...[TRUNCATED]"

# These attacks are contained by cache limits:
from datason.core import _TYPE_CACHE, _TYPE_CACHE_SIZE_LIMIT

# Create many unique types to try to exhaust cache
for i in range(1000):
    class DynamicType:
        def __init__(self):
            self.value = i
    obj = DynamicType()
    datason.serialize(obj)

# Cache size is properly limited
assert len(_TYPE_CACHE) <= _TYPE_CACHE_SIZE_LIMIT  # ✅ PROTECTED

from unittest.mock import Mock
import io

# These problematic objects are safely handled:
mock_obj = Mock()
mock_obj.configure_mock(**{f"attr_{i}": "value" for i in range(200)})

io_obj = io.BytesIO(b"attack_data" * 1000)

with warnings.catch_warnings(record=True) as w:
    result1 = datason.serialize(mock_obj)  # ✅ DETECTED: "mock object"
    result2 = datason.serialize(io_obj)    # ✅ DETECTED: "problematic io object"

# These expensive operations complete safely:
complex_data = {}
for i in range(100):
    level = {}
    for j in range(100):
        level[f"key_{j}"] = {"data": list(range(100)), "meta": {"id": j}}
    complex_data[f"level_{i}"] = level

import time
start = time.time()
result = datason.serialize(complex_data)  # ✅ COMPLETES SAFELY
end = time.time()
assert end - start < 30  # Within reasonable time limits

# These attempts to bypass security through optimization paths FAIL:
homogeneous_attack = {}
current = homogeneous_attack
for i in range(1005):  # Try to look "homogeneous" to bypass checks
    current["attack"] = {}  # All identical - appears homogeneous
    current = current["attack"]

try:
    datason.serialize(homogeneous_attack)
except datason.SecurityError as e:
    print(f"✅ BYPASS BLOCKED: {e}")
    # Output: "Maximum serialization depth exceeded"

import threading
from concurrent.futures import ThreadPoolExecutor

# These concurrent attacks are safely handled:
def concurrent_serialize(data_id):
    data = {"id": data_id, "nested": {"level1": {"data": [1, 2, 3]}}}
    return datason.serialize(data)

with ThreadPoolExecutor(max_workers=10) as executor:
    futures = [executor.submit(concurrent_serialize, i) for i in range(50)]
    results = [f.result() for f in futures]

assert len(results) == 50  # ✅ ALL COMPLETE SAFELY
assert all(isinstance(r, dict) for r in results)  # ✅ ALL VALID

import warnings
import logging

# Set up security monitoring
logging.basicConfig(level=logging.WARNING)
logger = logging.getLogger("datason.security")

# Capture security warnings in production
with warnings.catch_warnings(record=True) as w:
    result = datason.serialize(untrusted_data)
    if w:
        for warning in w:
            logger.warning(f"Security event: {warning.message}")

import datason

# ✅ GOOD: Handle untrusted data safely
try:
    result = datason.serialize(untrusted_data)
except datason.SecurityError as e:
    logger.warning(f"Blocked potentially malicious data: {e}")
    return None

# ✅ GOOD: Monitor for security warnings in production
import warnings
with warnings.catch_warnings(record=True) as w:
    result = datason.serialize(data)
    if w:
        logger.info(f"Security warnings: {[str(warning.message) for warning in w]}")

# ✅ GOOD: Test with your own security scenarios
def test_my_security_scenario():
    # Your specific attack vector
    attack_data = create_potential_attack()

    # Should either complete safely or raise SecurityError
    try:
        result = datason.serialize(attack_data)
        assert_safe_result(result)
    except datason.SecurityError:
        pass  # Expected for attack data

# ❌ AVOID: Don't serialize sensitive data
sensitive_data = {"password": "secret", "api_key": "12345"}
# Filter before serializing
safe_data = {k: v for k, v in data.items() if k not in ["password", "api_key"]}
result = datason.serialize(safe_data)

from datason.core import MAX_SERIALIZATION_DEPTH, MAX_OBJECT_SIZE, MAX_STRING_LENGTH

print(f"Max depth: {MAX_SERIALIZATION_DEPTH}")      # 50 (reduced from 1000)
print(f"Max object size: {MAX_OBJECT_SIZE}")        # 100,000 (reduced from 10M)  
print(f"Max string length: {MAX_STRING_LENGTH}")    # 1,000,000