# Add node with detailed ISL config
mesh.add_node(
    "sat-1",
    orbit_alt=550,                # km
    orbit_inc=53,                 # degrees inclination
    isl_config={
        "range_km": 5000,         # Max ISL range
        "bandwidth": 10e9,        # 10 Gbps
        "latency_per_km": 0.003,  # ms per km
        "max_connections": 4,     # Max simultaneous links
        "optical": True           # Optical vs RF
    }
)

# View current links
links = mesh.get_links("sat-1")
for link in links:
    print(f"{link.source} ↔ {link.target}")
    print(f"  Distance: {link.distance_km:.0f} km")
    print(f"  Bandwidth: {link.bandwidth / 1e9:.0f} Gbps")
    print(f"  Latency: {link.latency_ms:.1f} ms")
    print(f"  Status: {link.status}")

# Shortest path (default)
route = mesh.find_route(source, dest, algorithm="shortest_path")

# Maximum bandwidth
route = mesh.find_route(source, dest, algorithm="max_bandwidth")

# Minimum latency
route = mesh.find_route(source, dest, algorithm="min_latency")

# Load balanced
route = mesh.find_route(source, dest, algorithm="load_balanced")

# Update positions (typically from TLE)
mesh.update_positions(epoch=datetime.now())

# Or subscribe to position updates
@mesh.on_topology_change
def handle_change(event):
    if event.type == "link_lost":
        print(f"Link lost: {event.source} ↔ {event.target}")
        # Routes using this link are automatically rerouted
    elif event.type == "link_established":
        print(f"New link: {event.source} ↔ {event.target}")

# Get current network state
state = mesh.get_state()
print(f"Active nodes: {state.active_nodes}")
print(f"Active links: {state.active_links}")
print(f"Network diameter: {state.diameter} hops")
print(f"Avg path length: {state.avg_path_length:.1f} hops")

# Find multiple disjoint paths
paths = mesh.find_paths(
    source="sat-1",
    destination="ground-svalbard",
    num_paths=3,
    disjoint=True        # No shared links
)

for i, path in enumerate(paths):
    print(f"Path {i+1}: {' → '.join(path.nodes)}")
    print(f"  Bandwidth: {path.bandwidth / 1e6:.0f} Mbps")

# Split data across paths
transfers = mesh.split_transfer(
    data_size=1e9,       # 1 GB
    paths=paths,
    strategy="proportional"  # By bandwidth
)

# Reserve bandwidth for critical traffic
reservation = mesh.reserve_bandwidth(
    source="sat-1",
    destination="ground-svalbard",
    bandwidth=100e6,     # 100 Mbps
    duration_seconds=300,
    priority="critical"
)

# Monitor traffic
traffic = mesh.get_traffic()
for link in traffic.links:
    print(f"{link.id}: {link.utilization:.1%} utilized")
    print(f"  Current: {link.current_throughput / 1e6:.0f} Mbps")
    print(f"  Peak: {link.peak_throughput / 1e6:.0f} Mbps")

from rotastellar_distributed import SpaceMesh

# Create mesh for a Walker constellation
mesh = SpaceMesh(api_key="rs_...")

# Add 40 satellites in polar orbit
for plane in range(8):
    for sat in range(5):
        mesh.add_node(
            f"sat-{plane}-{sat}",
            orbit_alt=550,
            orbit_inc=97.5,
            raan=plane * 45,          # Right ascension
            true_anomaly=sat * 72,    # Position in plane
            isl_range=5000
        )

# Add global ground stations
stations = [
    ("svalbard", 78.2, 15.6),
    ("hawaii", 19.8, -155.5),
    ("singapore", 1.3, 103.8),
    ("chile", -33.4, -70.6),
    ("south-africa", -33.9, 18.4),
]
for name, lat, lon in stations:
    mesh.add_ground_station(name, lat, lon)

# Network stats
state = mesh.get_state()
print(f"Satellites: {state.active_nodes}")
print(f"ISL links: {state.active_links}")
print(f"Ground stations: {state.ground_stations}")
print(f"Global coverage: {state.coverage:.1%}")

# Any satellite can reach ground within 2 hops
for sat in mesh.nodes:
    routes = mesh.find_paths(sat, "any-ground", max_hops=2)
    assert len(routes) > 0, f"{sat} has no route to ground!"

from rotastellar_distributed import SyncScheduler, SpaceMesh

# Initialize both
mesh = SpaceMesh(api_key="rs_...")
scheduler = SyncScheduler(
    api_key="rs_...",
    mesh=mesh              # Enable ISL routing
)

# Schedule sync - will use ISL if direct pass unavailable
sync = scheduler.schedule_sync(
    node="sat-1",
    data_size=100e6,
    priority="critical",
    allow_relay=True       # Allow ISL relay
)

# Sync might go: sat-1 → sat-2 → ground-svalbard
print(f"Route: {' → '.join(sync.route.path)}")