# These are Python imports for accessing experimental features
from sona.type_system import TypeInferenceEngine, TypeEnvironment
from sona.type_aware_interpreter import TypeAwareSonaInterpreter

# Python code to use the experimental type-aware interpreter
from sona.type_aware_interpreter import TypeAwareSonaInterpreter

# Create a basic type-aware interpreter
interpreter = TypeAwareSonaInterpreter(
    strict_typing=False,        # Gradual typing (warnings only)
    enable_type_optimizations=True  # Performance optimizations
)

# For strict typing (experimental)
strict_interpreter = TypeAwareSonaInterpreter(
    strict_typing=True,         # Strict type checking
    enable_type_optimizations=True
)

# Python code to start a type-aware REPL session
from sona.type_aware_interpreter import TypeAwareREPL

# Create type-aware REPL
repl = TypeAwareREPL(strict_typing=False)

# Evaluate code with type information
result, errors, stats = repl.evaluate_with_types("let x = 42 + 3.14")

print(f"Result: {result}")
print(f"Type errors: {errors}")
print(f"Type statistics: {stats}")

# Get insights into type system usage
stats = interpreter.get_type_statistics()

print(f"Expressions typed: {stats['expressions_typed']}")
print(f"Type optimizations applied: {stats['type_optimizations_applied']}")
print(f"Type cache size: {stats['type_cache_size']}")
print(f"Strict mode: {stats['strict_mode']}")

# The type system can catch potential issues
code = """
let number = 42
let text = "hello"
let result = number + text  // Type mismatch detected
"""

result, errors, stats = repl.evaluate_with_types(code)
if errors:
    print("Type errors found:")
    for error in errors:
        print(f"  - {error}")

# Create interpreter with optimizations enabled
interpreter = TypeAwareSonaInterpreter(
    strict_typing=False,
    enable_type_optimizations=True
)

# The interpreter can optimize operations when types are inferred
# For example: integer addition can use faster code paths

# Basic types available in the type system
from sona.type_system.types import (
    INT_TYPE,      # Integer type
    FLOAT_TYPE,    # Float type
    STRING_TYPE,   # String type
    BOOL_TYPE,     # Boolean type
    UNIT_TYPE,     # Unit/void type
    TypeVariable,  # Type variables for inference
    FunctionType   # Function types
)

# calculator_typed.py - Using type-aware interpreter
from sona.type_aware_interpreter import TypeAwareSonaInterpreter

interpreter = TypeAwareSonaInterpreter(enable_type_optimizations=True)

# Sona code with automatic type inference
calculator_code = """
func add(a, b) {
    return a + b
}

func multiply(a, b) {
    return a * b
}

func calculate_area(width, height) {
    return multiply(width, height)
}

let width = 10
let height = 20
let area = calculate_area(width, height)
print("Area: " + str(area))
"""

# Execute with type awareness
result = interpreter.transform(interpreter.parse(calculator_code))
stats = interpreter.get_type_statistics()

print(f"Type optimizations applied: {stats['type_optimizations_applied']}")

# error_detection.py - Catching type errors
from sona.type_aware_interpreter import TypeAwareREPL

repl = TypeAwareREPL(strict_typing=True)

# Code with potential type issues
problematic_code = """
let number = 42
let text = "hello"
let mixed = number + text  // This will be flagged in strict mode
"""

result, errors, stats = repl.evaluate_with_types(problematic_code)

if errors:
    print("Type errors detected:")
    for error in errors:
        print(f"  - {error}")
else:
    print("No type errors found")
    print(f"Result: {result}")

# performance_comparison.py - Comparing regular vs type-aware interpreters
import time
from sona.interpreter import SonaInterpreter
from sona.type_aware_interpreter import TypeAwareSonaInterpreter

# Test code
test_code = """
for i in range(1000) {
    let result = i * 2 + i * 3
}
"""

# Regular interpreter
regular_interpreter = SonaInterpreter()
start_time = time.time()
regular_interpreter.transform(regular_interpreter.parse(test_code))
regular_time = time.time() - start_time

# Type-aware interpreter with optimizations
type_interpreter = TypeAwareSonaInterpreter(enable_type_optimizations=True)
start_time = time.time()
type_interpreter.transform(type_interpreter.parse(test_code))
type_time = time.time() - start_time

print(f"Regular interpreter: {regular_time:.4f} seconds")
print(f"Type-aware interpreter: {type_time:.4f} seconds")
print(f"Performance difference: {regular_time/type_time:.2f}x")

# Show type statistics
stats = type_interpreter.get_type_statistics()
print(f"Type optimizations applied: {stats['type_optimizations_applied']}")