<?php

/*
 * This file is part of the official PHP MCP SDK.
 *
 * A collaboration between Symfony and the PHP Foundation.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

/*
 * Conformance fixture for the modern (SEP-2575) lifecycle, served at /stateless
 * alongside the handshake-era fixture at /. The element set mirrors
 * server.php's where the eras overlap, so a difference in results points at the
 * lifecycle rather than at drifted fixtures.
 */

ini_set('display_errors', '0');

require_once dirname(__DIR__, 2).'/vendor/autoload.php';

use Http\Discovery\Psr17Factory;
use Laminas\HttpHandlerRunner\Emitter\SapiEmitter;
use Mcp\Exception\MissingRequiredClientCapabilityException;
use Mcp\Schema\ClientCapabilities;
use Mcp\Schema\Content\AudioContent;
use Mcp\Schema\Content\EmbeddedResource;
use Mcp\Schema\Content\ImageContent;
use Mcp\Schema\Content\TextContent;
use Mcp\Schema\Elicitation\ElicitationSchema;
use Mcp\Schema\Elicitation\StringSchemaDefinition;
use Mcp\Schema\Enum\CacheScope;
use Mcp\Schema\Enum\ProtocolVersion;
use Mcp\Schema\Request\ElicitRequest;
use Mcp\Schema\Result\CallToolResult;
use Mcp\Schema\Result\InputRequiredResult;
use Mcp\Server;
use Mcp\Server\Transport\StatelessHttpTransport;
use Mcp\Server\Wire\CachePolicy;
use Mcp\Tests\Conformance\Elements;
use Mcp\Tests\Conformance\FileLogger;
use Mcp\Tests\Conformance\MrtrElements;

chdir(__DIR__);

$logger = new FileLogger(__DIR__.'/logs/conformance-stateless.log', true);

$psr17Factory = new Psr17Factory();
$request = $psr17Factory->createServerRequestFromGlobals();

$protocol = Server::builder()
    ->setServerInfo('mcp-conformance-test-server', '1.0.0')
    ->setLogger($logger)
    // Tools
    ->addTool(static fn () => 'This is a simple text response for testing.', name: 'test_simple_text', description: 'Tests simple text content response')
    ->addTool(static fn () => new ImageContent(Elements::TEST_IMAGE_BASE64, 'image/png'), name: 'test_image_content', description: 'Tests image content response')
    ->addTool(static fn () => new AudioContent(Elements::TEST_AUDIO_BASE64, 'audio/wav'), name: 'test_audio_content', description: 'Tests audio content response')
    ->addTool(static fn () => EmbeddedResource::fromText('test://embedded-resource', 'This is an embedded resource content.'), name: 'test_embedded_resource', description: 'Tests embedded resource content response')
    ->addTool([Elements::class, 'toolMultipleTypes'], name: 'test_multiple_content_types', description: 'Tests response with multiple content types')
    ->addTool(static fn () => CallToolResult::error([new TextContent('This tool intentionally returns an error for testing')]), name: 'test_error_handling', description: 'Tests error response handling')
    // Exercises the -32021 path.
    ->addTool(
        static function (): never {
            throw new MissingRequiredClientCapabilityException(new ClientCapabilities(roots: false, sampling: true), 'test_missing_capability requires the sampling capability.');
        },
        name: 'test_missing_capability',
        description: 'Always reports a missing client capability, for testing -32021 handling',
    )
    // The ask travels back inside the result, never as its own request.
    ->addTool(
        static fn (): InputRequiredResult => new InputRequiredResult(
            [
                'conformance_probe' => new ElicitRequest(
                    'Please provide a value for the conformance probe.',
                    new ElicitationSchema(['value' => new StringSchemaDefinition('Value')], ['value']),
                ),
            ],
            requestState: base64_encode(json_encode(['tool' => 'test_streaming_elicitation'], \JSON_THROW_ON_ERROR)),
        ),
        name: 'test_streaming_elicitation',
        description: 'Returns an InputRequiredResult asking for elicitation input',
    )
    // Logs server-side only; no logLevel was requested, so nothing goes out.
    ->addTool(
        static function () use ($logger): string {
            $logger->info('test_logging_tool executed');

            return 'Logged.';
        },
        name: 'test_logging_tool',
        description: 'Emits a server-side log message while returning normally',
    )
    // Mirrors its arguments into Mcp-Param-* headers (SEP-2243).
    ->addTool(
        static fn (string $region = '', int $retries = 0): string => sprintf('region=%s retries=%d', $region, $retries),
        name: 'test_custom_headers',
        description: 'Tests custom header mirroring via x-mcp-header',
        inputSchema: [
            'type' => 'object',
            'properties' => [
                'region' => ['type' => 'string', 'x-mcp-header' => 'Region'],
                'retries' => ['type' => 'integer', 'x-mcp-header' => 'Retries'],
            ],
            'required' => ['region'],
        ],
    )
    ->addTool([Elements::class, 'toolWithProgress'], name: 'test_tool_with_progress', description: 'Tests tool that reports progress notifications')
    // Multi round-trip request tools (SEP-2322).
    ->addTool([MrtrElements::class, 'elicitation'], name: 'test_input_required_result_elicitation', description: 'MRTR: asks for a name via elicitation')
    ->addTool([MrtrElements::class, 'sampling'], name: 'test_input_required_result_sampling', description: 'MRTR: asks for a sampling completion')
    ->addTool([MrtrElements::class, 'listRoots'], name: 'test_input_required_result_list_roots', description: 'MRTR: asks for the client roots')
    ->addTool([MrtrElements::class, 'elicitation'], name: 'test_input_required_result_request_state', description: 'MRTR: exercises requestState round-tripping')
    ->addTool([MrtrElements::class, 'multipleInputs'], name: 'test_input_required_result_multiple_inputs', description: 'MRTR: asks for two inputs at once')
    ->addTool([MrtrElements::class, 'multiRound'], name: 'test_input_required_result_multi_round', description: 'MRTR: asks across two sequential rounds')
    ->addTool([MrtrElements::class, 'capabilities'], name: 'test_input_required_result_capabilities', description: 'MRTR: asks only for capabilities the client declared')
    ->addTool([MrtrElements::class, 'tamperedState'], name: 'test_input_required_result_tampered_state', description: 'MRTR: completes only when the echoed state verifies')
    // Resources
    ->addResource(static fn () => 'This is the content of the static text resource.', 'test://static-text', 'static-text', 'A static text resource for testing')
    ->addResource(static fn () => fopen('data://image/png;base64,'.Elements::TEST_IMAGE_BASE64, 'r'), 'test://static-binary', 'static-binary', 'A static binary resource (image) for testing')
    ->addResourceTemplate([Elements::class, 'resourceTemplate'], 'test://template/{id}/data', 'template', 'A resource template with parameter substitution', 'application/json')
    // Prompts
    ->addPrompt(static fn () => [['role' => 'user', 'content' => 'This is a simple prompt for testing.']], name: 'test_simple_prompt', description: 'A simple prompt without arguments')
    ->addPrompt([Elements::class, 'promptWithArguments'], name: 'test_prompt_with_arguments', description: 'A prompt with required arguments')
    ->addPrompt([Elements::class, 'promptWithEmbeddedResource'], name: 'test_prompt_with_embedded_resource', description: 'A prompt that includes an embedded resource')
    ->addPrompt([Elements::class, 'promptWithImage'], name: 'test_prompt_with_image', description: 'A prompt that includes image content')
    ->addPrompt([MrtrElements::class, 'prompt'], name: 'test_input_required_result_prompt', description: 'MRTR: a prompt that asks for input first')
    // Fixed so a retry landing on another process still verifies.
    ->setRequestState(str_repeat('conformance-fixture-key-', 2))
    // Lists are the same for everyone here; a read is not.
    ->setCachePolicy(
        CachePolicy::default(60_000)
            ->withMethod('tools/list', 3_600_000, CacheScope::Public)
            ->withMethod('prompts/list', 3_600_000, CacheScope::Public)
            ->withMethod('resources/list', 3_600_000, CacheScope::Public)
            ->withMethod('resources/templates/list', 3_600_000, CacheScope::Public)
            ->withMethod('server/discover', 3_600_000, CacheScope::Public),
    )
    ->buildStateless([ProtocolVersion::V2026_07_28]);

$transport = new StatelessHttpTransport($protocol, logger: $logger);

(new SapiEmitter())->emit($transport->handle($request));