import requestx as rx

# Simple GET request
response = rx.get("https://api.github.com/users/octocat")
print(response.status_code)
print(response.json())

# With Client (recommended for multiple requests)
with rx.Client() as client:
    response = client.get("https://httpbin.org/get")
    data = response.json()
    print(data["url"])

import requestx as rx

# Environment variables are automatically used when trust_env=True (default)
client = rx.Client(trust_env=True)

# This will use HTTP_PROXY, HTTPS_PROXY if set
response = client.get("https://api.github.com/users/octocat")

import requestx as rx

# Create a client with custom settings
client = rx.Client(
    base_url="https://api.example.com",  # Base URL for relative requests
    auth=("username", "password"),        # BasicAuth tuple or rx.BasicAuth
    params={"key": "value"},              # Default query parameters
    headers={"X-Custom": "header"},       # Default headers
    timeout=rx.Timeout(connect=5.0, read=30.0),  # Timeout configuration
    verify=True,                          # SSL verification
    proxy="http://proxy:8080",            # Proxy URL
    limits=rx.Limits(max_connections=100), # Connection pool limits
    trust_env=True,                       # Use environment variables
)

# Context manager support
with rx.Client() as client:
    response = client.get("/users")
    print(response.json())

# GET
response = client.get(url, params={"key": "value"}, headers={"X-Header": "value"})

# POST
response = client.post(url, json={"key": "value"})
response = client.post(url, data={"key": "value"})  # Form data
response = client.post(url, content=b"raw bytes")   # Raw body

# PUT, PATCH, DELETE, OPTIONS, HEAD
response = client.put(url, json={"update": "data"})
response = client.patch(url, data={"partial": "update"})
response = client.delete(url)
response = client.options(url)
response = client.head(url)

# Generic request method
response = client.request("METHOD", url, **kwargs)

response = client.get("https://httpbin.org/get")

# Status
print(response.status_code)      # 200
print(response.is_success)       # True
print(response.is_redirect)      # False
print(response.is_error)         # False

# Content
print(response.content)          # b'{"...": "..."}'
print(response.text)             # '{"...": "..."}'
data = response.json()           # Parsed JSON

# Headers
print(response.headers)          # [("Content-Type", "application/json"), ...]
print(dict(response.headers))    # {"content-type": "application/json"}

# Timing
print(response.elapsed)          # 0.123 seconds

# Other
print(response.url)              # "https://httpbin.org/get"
response.raise_for_status()      # Raises on 4xx/5xx

timeout = rx.Timeout(
    connect=5.0,    # Connection timeout
    read=30.0,      # Read timeout
    write=15.0,     # Write timeout
    pool=10.0,      # Pool timeout
    total=60.0,     # Total timeout (overrides others if set)
)

# Or shorthand
timeout = rx.Timeout(timeout=30.0)  # Total timeout

limits = rx.Limits(
    max_connections=100,           # Max concurrent connections
    max_keepalive_connections=20,  # Max idle connections
    keepalive_expiry=30.0,         # Idle connection timeout
)

config = rx.Config(
    # Connection Pool Settings
    pool_idle_timeout_secs=300,        # How long (seconds) to keep idle connections alive (default: 300)
    pool_max_idle_per_host=1024,       # Max idle connections per host (default: 1024)
    
    # HTTP/2 Settings (requires async client - planned for future release)
    http2_keep_alive_interval_secs=30, # Interval between HTTP/2 ping frames (default: 30)
    http2_keep_alive_timeout_secs=10,  # Timeout waiting for ping response (default: 10)
    http2_initial_stream_window_size=1048576,      # Flow control window per stream in bytes (default: 1048576)
    http2_initial_connection_window_size=16777216, # Flow control window per connection in bytes (default: 16777216)
    
    # Runtime Settings (Tokio) - for future async support
    worker_threads=8,                  # Number of worker threads (default: 8)
    max_blocking_threads=512,          # Max threads for blocking operations (default: 512)
    thread_name="requestx-worker",     # Prefix for thread names (default: "requestx-worker")
    thread_stack_size=1048576,         # Stack size per thread in bytes (default: 1048576)
)

# Use with Client
client = rx.Client(config=config)

# High-throughput API client
config = rx.Config(
    pool_idle_timeout_secs=600,      # Keep connections alive longer
    pool_max_idle_per_host=2048,     # More idle connections per host
)

# Low-latency trading system
config = rx.Config(
    pool_idle_timeout_secs=30,       # Quick cleanup of unused connections
    pool_max_idle_per_host=512,      # Focus on recent connections
)

# Memory-constrained environment
config = rx.Config(
    pool_idle_timeout_secs=60,       # Shorter idle timeout
    pool_max_idle_per_host=128,      # Fewer idle connections
)

# Basic Auth
auth = rx.BasicAuth("username", "password")

# Bearer Token
auth = rx.BearerAuth("your-jwt-token")

# Tuple (auto-converted to BasicAuth)
client = rx.Client(auth=("username", "password"))

# Use stream() context manager for large responses
with client.stream("GET", url) as response:
    for chunk in response.iter_bytes():
        process(chunk)

    for line in response.iter_lines():
        process_line(line)

    for text_chunk in response.iter_text():
        process_text(text_chunk)

import requestx as rx

try:
    response = client.get("https://httpbin.org/status/404")
    # This will NOT raise - response is returned
    print(response.status_code)  # 404
except rx.RequestXException as e:
    # Network error (DNS, connection refused, etc.)
    print(f"Network error: {e}")

# Explicit error raising
response = client.get("https://httpbin.org/status/500")
response.raise_for_status()  # Raises HTTPStatusError

# Build a request without sending
request = client.build_request("POST", "/submit", json={"data": "value"})

# Then send it later
response = client.send(request)

# By default, redirects are NOT followed (httpx-compatible)
client = rx.Client(follow_redirects=True)  # Enable redirect following

# Using Cookies class
cookies = rx.Cookies()
cookies.set("session_id", "abc123")
cookies.set("user_id", "42", domain="example.com")

client = rx.Client(cookies=cookies)
response = client.get("https://example.com")

# Read cookies from response
print(dict(response.cookies))

# String proxy
client = rx.Client(proxy="http://proxy:8080")

# Or from environment (automatic with trust_env=True)
client = rx.Client(trust_env=True)

# httpx
import httpx

response = httpx.get("https://example.com")

# RequestX
import requestx as rx

response = rx.get("https://example.com")  # Same API!