// Simple GET request
$response = fetch('https://api.example.com/users');
$users = $response->json();

// POST request with JSON body
$response = fetch('https://api.example.com/users', [
    'method' => 'POST',
    'headers' => ['Content-Type' => 'application/json'],
    'body' => ['name' => 'John Doe', 'email' => 'john@example.com'],
]);

use function async;
use function await;
use Fetch\Interfaces\Response as ResponseInterface;

// Using Promise-style chaining
async(fn () => fetch('https://api.example.com/users'))
    ->then(fn (ResponseInterface $response) => $response->json())
    ->catch(fn (\Throwable $e) => print "Error: " . $e->getMessage());

// Using async/await syntax
try {
    $response = await(async(fn () => fetch('https://api.example.com/users')));
    $users = $response->json();
} catch (\Throwable $e) {
    echo 'Error: ' . $e->getMessage();
}

// Chain methods to build your request
$response = fetch()
    ->baseUri('https://api.example.com')
    ->withHeaders(['Accept' => 'application/json'])
    ->withToken('your-auth-token')
    ->withQueryParameters(['page' => 1, 'limit' => 10])
    ->get('/users');

// Async with fluent API
async(fn () => fetch()
    ->baseUri('https://api.example.com')
    ->withBody(['name' => 'John Doe'])
    ->post('/users'))
    ->then(fn ($response) => $response->json());

use function all;
use function await;
use function async;

// Prepare multiple async requests
$userPromise = async(fn () => fetch('https://api.example.com/users'));
$postsPromise = async(fn () => fetch('https://api.example.com/posts'));
$commentsPromise = async(fn () => fetch('https://api.example.com/comments'));

// Wait for all to complete
$results = await(all([
    'users' => $userPromise,
    'posts' => $postsPromise,
    'comments' => $commentsPromise
]));

// Access results
$users = $results['users']->json();
$posts = $results['posts']->json();
$comments = $results['comments']->json();

use Task;
use Enum\TaskStatus;

// Create a task for a request
$task = async(fn () => fetch('https://api.example.com/large-dataset'));

// Start the task
$task->start();

// Check the task status
if ($task->getStatus() === TaskStatus::RUNNING) {
    // You can pause the task if needed
    $task->pause();

    // And resume it later
    $task->resume();
}

// Cancel the task if needed
$task->cancel();

// Retry the task if it failed
if ($task->getStatus() === TaskStatus::FAILED) {
    $task->retry();
}

// Get the result when complete
if ($task->getStatus() === TaskStatus::COMPLETED) {
    $response = $task->getResult();
    $data = $response->json();
}

// Retry up to 3 times with a 100ms delay between retries
$response = fetch('https://api.example.com/unstable-endpoint', [
    'retries' => 3,
    'retry_delay' => 100
]);

// Or with fluent API
$response = fetch()
    ->retry(3, 100)
    ->get('https://api.example.com/unstable-endpoint');

$response = fetch('https://api.example.com/users/1');

// Check if request was successful
if ($response->ok()) {
    // HTTP status code
    echo $response->status(); // 200

    // Response body as JSON
    $user = $response->json();

    // Response body as string
    $body = $response->body();

    // Get a specific header
    $contentType = $response->header('Content-Type');
}

// Basic auth
$response = fetch('https://api.example.com/secure', [
    'auth' => ['username', 'password']
]);

// Bearer token
$response = fetch()
    ->withToken('your-oauth-token')
    ->get('https://api.example.com/secure');

$response = fetch('https://api.example.com', [
    'proxy' => 'http://proxy.example.com:8080'
]);

// Or with fluent API
$response = fetch()
    ->withProxy('http://proxy.example.com:8080')
    ->get('https://api.example.com');

// Synchronous error handling
try {
    $response = fetch('https://api.example.com/nonexistent');

    if ($response->failed()) {
        echo "Request failed with status: " . $response->status();
    }
} catch (\Throwable $e) {
    echo "Exception: " . $e->getMessage();
}

// Asynchronous error handling
async(fn () => fetch('https://api.example.com/nonexistent'))
    ->then(function ($response) {
        if ($response->ok()) {
            return $response->json();
        }
        throw new \Exception("Request failed with status: " . $response->status());
    })
    ->catch(function (\Throwable $e) {
        echo "Error: " . $e->getMessage();

        // You could retry the request here
        return retry();
    });