<?php

// Imagine a simplified database setup
class UserDB {
    private $data = [
        1 => ['id' => 1, 'name' => 'Alice'],
        2 => ['id' => 2, 'name' => 'Bob'],
    ];
    public function find(int $id) {
        echo "\nDB Query: Fetching user {$id}\n"; // Simulate a database call
        return $this->data[$id] ?? null;
    }
}

class PostDB {
    private $data = [
        101 => ['id' => 101, 'title' => 'First Post', 'authorId' => 1],
        102 => ['id' => 102, 'title' => 'Second Post', 'authorId' => 1],
        103 => ['id' => 103, 'title' => 'Third Post', 'authorId' => 2],
    ];
    public function all() {
        echo "\nDB Query: Fetching all posts\n"; // Simulate a database call
        return array_values($this->data);
    }
}

// --- Inefficient GraphQL Resolver (Illustrating N+1) ---

class InefficientResolvers {
    public static function resolvePosts($root, $args, $context) {
        // This initial call is fine, fetches all posts once
        return $context['postDB']->all();
    }

    public static function resolvePostAuthor($post, $args, $context) {
        // PROBLEM: For EACH post, this resolver triggers a NEW database call.
        // If there are N posts, this results in N separate queries to fetch authors.
        // Total queries: 1 (for all posts) + N (for N authors) = N+1 queries.
        echo "Calling resolvePostAuthor for Post ID: {$post['id']} (Author ID: {$post['authorId']})\n";
        return $context['userDB']->find($post['authorId']);
    }
}

// Example of how GraphQL might execute this (conceptual)
/*
query {
  posts {
    title
    author {
      name
    }
  }
}
*/

// Simulate execution flow:
$userDB = new UserDB();
$postDB = new PostDB();

$context = ['userDB' => $userDB, 'postDB' => $postDB];

echo "\n--- Simulating Inefficient N+1 Execution ---\n";
$posts = InefficientResolvers::resolvePosts(null, [], $context);

foreach ($posts as $post) {
    $author = InefficientResolvers::resolvePostAuthor($post, [], $context);
    // Use $author['name'] here as GraphQL would
}

echo "\n--- End Inefficient Execution ---\n\n";
// Observe the number of 'DB Query: Fetching user X' calls relative to the number of posts.
// Each post triggers its own author lookup.

<?php

// Conceptual DataLoader Interface/Class
// In a real application, you'd use a library like 'siler/dataloader' or a custom implementation.

interface DataLoaderInterface {
    public function load($key);
    public function loadMany(array $keys);
    public function prime($key, $value);
    public function clear($key);
    public function clearAll();
    public function getBatchFn();
}

/**
 * A simplified conceptual DataLoader class to illustrate its core principles.
 * In production, use a robust library.
 */
class ConceptualDataLoader implements DataLoaderInterface {
    private $batchFn;
    private $cache = []; // Simple in-memory cache
    private $queue = []; // Keys waiting to be batched

    public function __construct(callable $batchFn) {
        $this->batchFn = $batchFn;
    }

    public function load($key) {
        if (isset($this->cache[$key])) {
            return $this->cache[$key]; // Serve from cache if available
        }

        if (!isset($this->queue[$key])) {
            $this->queue[$key] = true; // Mark key for batching
            // Schedule batch execution for the 'next tick' of the event loop
            // In a real async PHP environment, this would be a real deferral mechanism.
            // For synchronous PHP, this means the batch function runs only once
            // after all 'load' calls have completed in the current execution frame.
            // The actual mechanism is usually handled by the GraphQL execution engine's deferred resolution.
            // For simplicity, we'll assume a batch execution at the 'end' of the current call stack.
        }

        // In a real DataLoader, this returns a Promise that resolves when the batchFn is executed.
        // For this conceptual synchronous example, we defer resolution to when batchFn is actually called.
        // This part is the hardest to simulate purely synchronously without Promises/async.
        // We will just return the key for now and expect the batchFn to pick it up later.
        return $key; // Placeholder, real DataLoader returns a Promise
    }

    public function loadMany(array $keys) {
        // Delegates to load() for each key, or a more optimized batching if all keys are new.
        $results = [];
        foreach ($keys as $key) {
            $results[$key] = $this->load($key);
        }
        return $results; // Placeholder, real DataLoader returns an array of Promises
    }

    public function prime($key, $value) {
        $this->cache[$key] = $value;
    }

    public function clear($key) {
        unset($this->cache[$key]);
    }

    public function clearAll() {
        $this->cache = [];
        $this->queue = [];
    }

    public function getBatchFn(): callable {
        return $this->batchFn;
    }

    /**
     * Simulate the batch execution point. In a real system, this is triggered automatically.
     * For demonstration, we manually call it to show what happens.
     */
    public function executeBatch() {
        if (empty($this->queue)) {
            return; // Nothing to batch
        }

        $keysToLoad = array_keys($this->queue);
        $this->queue = []; // Clear the queue for the next cycle

        echo "\n--- DataLoader Batch Execution for keys: " . implode(', ', $keysToLoad) . " ---\n";
        // Execute the actual batch function, which takes an array of keys
        // and returns an array of results in the same order.
        $results = call_user_func($this->batchFn, $keysToLoad);

        // Prime the cache with the results
        foreach ($keysToLoad as $index => $key) {
            $this->prime($key, $results[$index]);
        }
        echo "--- End DataLoader Batch Execution ---\n\n";
    }
}

// Example batch function for fetching users
$userBatchLoader = new ConceptualDataLoader(function(array $userIds) {
    echo "DB Query: Batch fetching users: " . implode(', ', $userIds) . "\n";
    $dbResults = []; // Simulate a single database query that fetches multiple users
    // In a real scenario, this would be `SELECT * FROM users WHERE id IN (...)`
    foreach ($userIds as $id) {
        // Simulate fetching from a mock DB, ensuring order matches input keys
        $dbResults[] = ['id' => $id, 'name' => 'User ' . $id];
    }
    return $dbResults;
});

// --- Simulating DataLoader Usage ---
echo "\n--- Simulating DataLoader Usage ---\n";
$user1Promise = $userBatchLoader->load(1);
$user2Promise = $userBatchLoader->load(2);
$user1AgainPromise = $userBatchLoader->load(1); // Will be served from cache or batched once
$user3Promise = $userBatchLoader->load(3);

// At this point, no DB queries have happened yet for these loads.
// The DataLoader collects the keys.

// When GraphQL's execution cycle allows, the batch function is triggered.
// In a real setup, this is asynchronous and transparent.
// Here, we manually trigger the batch execution.
$userBatchLoader->executeBatch();

// After execution, results are available (conceptually via promises or direct access for this demo)
// For this conceptual example, if you were to access results, they would now be in the cache.
// e.g., $userBatchLoader->load(1) would now return the cached value directly.

echo "\n--- End DataLoader Usage ---\n\n";

<?php

require_once __DIR__ . '/vendor/autoload.php'; // Assumes Composer autoloader

use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\Type;
use GraphQL\Schema;
use GraphQL\GraphQL;

// Include a real DataLoader library, e.g., siler/dataloader
// Or provide your own implementation that adheres to the pattern.
// For this example, we'll use a simplified mock DataLoader that mimics its behavior.

/**
 * A simple DataLoader implementation for demonstration purposes.
 * In a real project, use 'siler/dataloader' or similar.
 */
class MyDataLoader {
    private $batchFn;
    private $cache = [];
    private $queue = [];
    private $pendingPromise;

    public function __construct(callable $batchFn) {
        $this->batchFn = $batchFn;
    }

    public function load($key) {
        if (isset($this->cache[$key])) {
            return $this->cache[$key]; // Serve from cache
        }

        if (!isset($this->queue[$key])) {
            $this->queue[$key] = true; // Mark key for batching
            if (!$this->pendingPromise) {
                // Schedule batch execution to run after the current call stack completes.
                // In a real async PHP environment (ReactPHP, Amp), this would be a real Promise.
                // For synchronous context, we simulate this by holding a pending state.
                $this->pendingPromise = true; // Placeholder for a deferred operation
                // In a proper GraphQL-PHP integration, this promise resolution is handled
                // by the executor, which collects all 'load' calls and executes batches.

                // For this example, we'll manually execute the batch at a conceptual 'tick' point.
            }
        }
        // Return a representation that will be resolved later (conceptually a Promise)
        return new class($key) { // A dummy object to hold the key until resolution
            public $key;
            public $resolvedValue = null;
            public function __construct($key) { $this->key = $key; }
        };
    }

    // Method to manually run the batch (in a real scenario, executor calls this)
    public function executeBatch() {
        if (empty($this->queue)) {
            return; // Nothing to batch
        }

        $keysToLoad = array_keys($this->queue);
        $this->queue = []; // Clear for next cycle
        $this->pendingPromise = null; // Clear pending state

        echo "\nDB Query (Batched): Fetching IDs: " . implode(', ', $keysToLoad) . "\n";
        // Execute the actual batch function
        $results = call_user_func($this->batchFn, $keysToLoad);

        // Prime the cache and resolve dummy objects
        foreach ($keysToLoad as $index => $key) {
            $this->cache[$key] = $results[$index];
            // This part is complex to simulate: in a real system, the Promise resolves
            // here, pushing the value back to wherever `load()` was called.
            // For this example, we assume subsequent `load()` calls will hit the cache.
        }
    }
}

// --- Mock Database and Context --- //
class MockUserDB {
    private $data = [
        1 => ['id' => 1, 'name' => 'Alice'],
        2 => ['id' => 2, 'name' => 'Bob'],
        3 => ['id' => 3, 'name' => 'Charlie'],
    ];

    // This method is now designed to be called by the DataLoader batch function
    public function findMany(array $ids): array {
        // Simulate a single DB query using IN clause
        $users = [];
        foreach ($ids as $id) {
            $users[] = $this->data[$id] ?? null;
        }
        return $users;
    }
}

class MockPostDB {
    private $data = [
        101 => ['id' => 101, 'title' => 'First Post', 'authorId' => 1],
        102 => ['id' => 102, 'title' => 'Second Post', 'authorId' => 1],
        103 => ['id' => 103, 'title' => 'Third Post', 'authorId' => 2],
        104 => ['id' => 104, 'title' => 'Fourth Post', 'authorId' => 3],
    ];

    public function all(): array {
        echo "DB Query: Fetching all posts\n";
        return array_values($this->data);
    }
}

// --- Setting up the GraphQL Schema with DataLoader --- //

// Define the User Type
$userType = new ObjectType([
    'name' => 'User',
    'fields' => [
        'id' => Type::id(),
        'name' => Type::string(),
    ],
]);

// Define the Post Type
$postType = new ObjectType([
    'name' => 'Post',
    'fields' => [
        'id' => Type::id(),
        'title' => Type::string(),
        'author' => [
            'type' => $userType,
            'resolve' => function ($post, $args, $context) {
                // Instead of direct DB call, use DataLoader to fetch the author.
                // The DataLoader instance is passed through the context.
                // It queues the request and returns a 'promise-like' object.
                echo "Resolver called for Post ID: {$post['id']}, requesting author ID: {$post['authorId']}\n";
                return $context['userLoader']->load($post['authorId']);
            },
        ],
    ],
]);

// Define the Root Query Type
$queryType = new ObjectType([
    'name' => 'Query',
    'fields' => [
        'posts' => [
            'type' => Type::listOf($postType),
            'resolve' => function ($root, $args, $context) {
                return $context['postDB']->all();
            },
        ],
    ],
]);

$schema = new Schema(['query' => $queryType]);

// --- Prepare Context with DataLoader --- //
$mockUserDB = new MockUserDB();
$mockPostDB = new MockPostDB();

// Instantiate DataLoader for users
$userLoader = new MyDataLoader(function (array $userIds) use ($mockUserDB) {
    // This is the batch function. It receives an array of user IDs.
    // It must return an array of users in the *same order* as the input IDs.
    $users = $mockUserDB->findMany($userIds);
    return $users;
});

// The context passed to GraphQL::execute() should include our DataLoader
$context = [
    'userDB' => $mockUserDB,
    'postDB' => $mockPostDB,
    'userLoader' => $userLoader,
];

// --- Execute a GraphQL Query --- //
$query = 'query { posts { id title author { id name } } }';

echo "\n--- Executing GraphQL Query with DataLoader ---\n";
try {
    $result = GraphQL::executeQuery($schema, $query, null, $context);

    // In a real GraphQL-PHP application, the executor would manage the async resolution
    // of the DataLoader promises. For this synchronous example, we manually trigger
    // the DataLoader's batch execution after the GraphQL query has gathered all load calls.
    // This is a conceptual step to demonstrate *when* the batching happens.
    $userLoader->executeBatch(); // Manually trigger the batch function

    $output = $result->toArray();
    echo json_encode($output, JSON_PRETTY_PRINT);

} catch (Exception $e) {
    echo json_encode(['errors' => [['message' => $e->getMessage()]]]);
}

echo "\n--- End GraphQL Query Execution ---\n";
// Observe the number of 'DB Query' messages. There should be only two: one for posts, one for batched users.

<?php

// This code snippet focuses on conceptual best practices and error handling
// within the batch function, rather than a full executable example.

/**
 * Conceptual batch function demonstrating error handling and data consistency.
 * In a real scenario, this would interact with a database or external API.
 */
$advancedUserBatchFn = function (array $userIds) {
    $results = [];
    // Simulate fetching users from a data source that might return errors or missing data.
    // The order of results *must* correspond to the order of input $userIds.

    // Example: Database call with potential failures
    try {
        // In a real database call (e.g., using PDO or an ORM):
        // $dbUsers = $pdo->query("SELECT * FROM users WHERE id IN (" . implode(',', $userIds) . ")")->fetchAll(PDO::FETCH_ASSOC);
        // $mappedUsers = [];
        // foreach ($dbUsers as $user) { $mappedUsers[$user['id']] = $user; }

        foreach ($userIds as $id) {
            if ($id === 999) { // Simulate a specific ID causing an error
                $results[] = new Exception("User ID {$id} not found or inaccessible.");
            } elseif ($id === 10) { // Simulate a missing user
                $results[] = null; // Return null if user doesn't exist
            } else {
                // Simulate successful user data
                $results[] = ['id' => $id, 'name' => 'User ' . $id . ' (Batched)'];
            }
        }
    } catch (Throwable $e) {
        // Catch any exceptions from the underlying data fetching mechanism.
        // If the entire batch fails, return an exception for each requested ID.
        foreach ($userIds as $id) {
            $results[] = $e; // Propagate the exception for each item in the batch
        }
    }

    return $results;
};

// Example of how to use this advanced batch function with a DataLoader (conceptual):
// $advancedUserLoader = new MyDataLoader($advancedUserBatchFn);

// Example of prime (pre-filling cache)
// $advancedUserLoader->prime(1, ['id' => 1, 'name' => 'Preloaded Alice']);

// Example of clearing cache
// $advancedUserLoader->clear(1); // Clear cache for user ID 1
// $advancedUserLoader->clearAll(); // Clear entire cache

// --- Conceptual Error Handling in GraphQL Resolver --- //
// When a DataLoader returns an Exception for a specific key, GraphQL-PHP
// will typically propagate this as an error for that field in the response.

/*
// Inside a GraphQL resolver:
'resolve' => function ($post, $args, $context) use ($advancedUserLoader) {
    try {
        $authorPromise = $advancedUserLoader->load($post['authorId']);
        // In a real async/promise system, you'd chain .then() / .catch()
        // For synchronous PHP with DataLoader, the executor handles this.
        return $authorPromise; // GraphQL-PHP will unwrap the result or error
    } catch (Exception $e) {
        // If the *load itself* throws an immediate error (rare, DataLoader catches batch errors),
        // handle it here. Otherwise, the batch function's error propagates.
        // Return null or throw a GraphQL error for this specific field.
        throw new GraphQL\Error\Error("Could not fetch author for post {$post['id']}: " . $e->getMessage());
    }
},
*/

// Monitoring and Metrics (Conceptual)
/*
// Integrate with a monitoring system (e.g., Prometheus, Datadog)
class QueryMonitor {
    public function recordBatchedQuery(string $resource, int $count) {
        // Increment counter for batched queries
        // Log duration, number of items, etc.
    }
}

// In your batch function:
$advancedUserBatchFn = function (array $userIds) use ($mockUserDB, $queryMonitor) {
    // ... existing logic ...
    $startTime = microtime(true);
    $users = $mockUserDB->findMany($userIds);
    $endTime = microtime(true);
    $queryMonitor->recordBatchedQuery('users', count($userIds));
    // Log ($endTime - $startTime) for duration
    return $users;
};
*/