<?php
// SPDX-License-Identifier: GPL-3.0-or-later
declare(strict_types=1);

namespace Aiwend\Mcp;

/**
 * The server-side allowlist of tools that COULD be offered. Built-in tools are added first; tools of other plugins are accepted only if they
 * implement McpTool, are read-only, have a valid unique name and a schema this catalog can describe. A duplicate name is refused (the first
 * registration wins, so another plugin can never replace a built-in tool), and every refusal is recorded so the administrator screen can
 * show it. Nothing here decides what a client may call: the administrator's list and the policy check do (see McpServer and ToolRunner).
 */
final class ToolCatalog
{
    public const NAME_PATTERN = '/^[a-z][a-z0-9_]{2,63}$/';

    /** @var array<string, McpTool> */
    private array $tools = [];
    /** @var array<string, true> */
    private array $builtin = [];
    /** @var list<array{name:string, reason:string}> */
    private array $refused = [];

    /** @param bool $builtin true only for the tools Aiwend itself ships; everything else is another plugin's code and is treated as untrusted */
    public function add(McpTool $tool, bool $builtin = false): bool
    {
        $name = $tool->name();
        if (preg_match(self::NAME_PATTERN, $name) !== 1) {
            return $this->refuse($name, 'invalid_name');
        }
        if (isset($this->tools[$name])) {
            return $this->refuse($name, 'name_taken');
        }
        if ($tool->mutates()) {
            return $this->refuse($name, 'state_changing_tools_not_offered');
        }
        if (!$builtin && ($tool->operation() !== 'mcp.read' || count($tool->schema()) > 10 || mb_strlen($tool->description()) > 500 || mb_strlen($tool->title()) > 100)) {
            return $this->refuse($name, 'outside_the_third_party_contract');
        }
        if (self::inputSchema($tool->schema()) === null) {
            return $this->refuse($name, 'unsupported_schema');
        }
        $this->tools[$name] = $tool;
        if ($builtin) {
            $this->builtin[$name] = true;
        }
        return true;
    }

    public function isBuiltin(string $name): bool
    {
        return isset($this->builtin[$name]);
    }

    /** @return array<string, McpTool> sorted by name */
    public function all(): array
    {
        $tools = $this->tools;
        ksort($tools);
        return $tools;
    }

    public function get(string $name): ?McpTool
    {
        return $this->tools[$name] ?? null;
    }

    /** @return list<array{name:string, reason:string}> */
    public function refused(): array
    {
        return $this->refused;
    }

    /**
     * JSON Schema (draft 2020-12 subset) for the arguments of a tool, or null if its schema uses something this catalog cannot describe.
     *
     * @param array<string, array<string, mixed>> $schema
     * @return array<string, mixed>|null
     */
    public static function inputSchema(array $schema): ?array
    {
        $properties = [];
        $required = [];
        foreach ($schema as $key => $rule) {
            $type = $rule['type'] ?? '';
            if (!is_string($key) || !in_array($type, ['int', 'string'], true)) {
                return null;
            }
            $p = ['type' => $type === 'int' ? 'integer' : 'string'];
            if ($type === 'int') {
                isset($rule['min']) && $p['minimum'] = (int) $rule['min'];
                isset($rule['max']) && $p['maximum'] = (int) $rule['max'];
            } else {
                $p['maxLength'] = (int) ($rule['max'] ?? 500);
                if (isset($rule['enum'])) {
                    $p['enum'] = array_values((array) $rule['enum']);
                }
            }
            if (isset($rule['description'])) {
                $p['description'] = (string) $rule['description'];
            }
            $properties[$key] = $p;
            if (empty($rule['optional'])) {
                $required[] = $key;
            }
        }
        $out = ['type' => 'object', 'properties' => $properties === [] ? new \stdClass() : $properties, 'additionalProperties' => false];
        if ($required !== []) {
            $out['required'] = $required;
        }
        return $out;
    }

    private function refuse(string $name, string $reason): bool
    {
        $this->refused[] = ['name' => mb_substr($name, 0, 64), 'reason' => $reason];
        return false;
    }
}