<?php
/**
 * The Tools page: tools, agents and extensions.
 *
 * @package MazeAi
 * @since   0.1.0
 */

declare(strict_types=1);

namespace MazeAi\Http\Controllers;

defined('ABSPATH') || exit;

use MazeAi\I18n\StoredMessage;
use Illuminate\MazeAssistant\Http\JsonResponse;
use Illuminate\MazeAssistant\Http\Request;
use Illuminate\MazeAssistant\Routing\Controller;
use MazeAi\I18n\BuiltInText;
use MazeAi\Engines\Agent\AgentRegistry;
use MazeAi\Engines\Policy\RuleBasedPolicy;
use MazeAi\Engines\Policy\RuleCatalogue;
use MazeAi\Kernel\Contracts\PolicyEngine;
use MazeAi\Kernel\Support\ToolContext;
use MazeAi\Platform\Definitions;
use MazeAi\Platform\Extensions;
use MazeAi\Support\Access;
use MazeAi\Support\Settings;
use MazeAi\Tools\Abilities\DefinitionAbilities;
use MazeAi\Tools\AbilityToolRegistry;
use MazeAi\Tools\ToolRegistry;

/**
 * Everything the backend can do and everything extensions added, for people who manage MazeGraph
 * (`routes/manage.php`):
 *
 * - `GET /tools`: every ability and how the chat treats it.
 * - `GET /agents`: the agents and where each comes from.
 * - `GET /policy`: the policy rules in execution order for management integrations.
 * - `GET /extensions`: modules, definitions, context lines and tools added through the Registrar; detailed skipped-item diagnostics require an optional capability.
 * - `GET /definitions/{kind}/{id}`: one definition as JSON.
 * - `DELETE /definitions/{kind}/{id}?action_id=`: delete one of the site's stored definitions, the same way.
 *
 * Deletions are recorded and can be undone from the Activity page.
 *
 * @since 0.1.0
 */
class ToolController extends Controller
{
    public function index(AbilityToolRegistry $tools): JsonResponse
    {
        return $this->ok(['supported' => AbilityToolRegistry::supported(), 'items' => $tools->catalogue()]);
    }

    public function agents(AgentRegistry $agents, Extensions $extensions, Settings $settings): JsonResponse
    {
        $items = [];
        foreach ($agents->all() as $agent) {
            $definition = $extensions->definitions()->get('agent', $agent->id);
            $agentData = $agent->toArray();
            // An agent MazeGraph ships is defined in its manifest or in code; either way its text is MazeGraph's to translate.
            $builtIn = ($definition['source'] ?? '') === Definitions::BUILT_IN || in_array($agent->id, array_map(static fn ($a): string => $a->id, AgentRegistry::builtIn()), true);
            foreach (['name', 'description'] as $key) {
                if (isset($agentData[$key]) && is_string($agentData[$key])) {
                    $agentData[$key] = BuiltInText::of($agentData[$key], $builtIn ? Definitions::BUILT_IN : '');
                }
            }
            $agentData['tools'] = $agents->toolPatterns($agent, $settings->bool('assistant_all_enabled_tools'));
            $items[] = $agentData + [
                'source'       => $definition['source'] ?? (in_array($agent->id, array_map(static fn ($a): string => $a->id, AgentRegistry::builtIn()), true) ? Definitions::BUILT_IN : 'maze_graph_agents'),
                'instructions' => $agent->instructions,
            ];
        }

        return $this->ok(['items' => $items]);
    }

    public function policy(PolicyEngine $policy, Extensions $extensions): JsonResponse
    {
        $rules = $policy instanceof RuleBasedPolicy ? RuleCatalogue::describe($policy->rules(), $extensions->ruleSources()) : [];

        return $this->ok(['items' => $rules]);
    }

    public function extensions(Extensions $extensions): JsonResponse
    {
        $definitions = [];
        foreach (Definitions::KINDS as $kind) {
            foreach ($extensions->definitions()->all($kind) as $item) {
                $definitions[] = [
                    'kind'     => $kind,
                    'id'       => (string) $item['data']['id'],
                    'name'     => BuiltInText::of((string) ($item['data']['name'] ?? $item['data']['text'] ?? $item['data']['reason'] ?? ''), $item['source']),
                    'source'   => $item['source'],
                    'editable' => $item['source'] === Definitions::STORED,
                ];
            }
        }

        return $this->ok([
            'modules'     => $extensions->modules()->describe(),
            'definitions' => $definitions,
            'diagnostics' => current_user_can(Access::VIEW_EXTENSION_DIAGNOSTICS) ? $extensions->definitions()->diagnostics() : [],
            'context'     => $extensions->definitions()->context(),
            'tools'       => $extensions->toolNames(),
            'api_version' => MAZE_GRAPH_API_VERSION,
        ]);
    }

    public function definition(Request $request, Extensions $extensions): JsonResponse
    {
        $kind = (string) $request->route('kind');
        $id   = rawurldecode((string) $request->route('id')) . ($request->route('name') !== null ? '/' . rawurldecode((string) $request->route('name')) : '');
        $item = $extensions->definitions()->get($kind, $id);
        if ($item === null) {
            return $this->notFound(__('There is no such definition.', 'maze-graph'));
        }

        return $this->ok(['definition' => ['kind' => $kind] + $item['data'], 'source' => $item['source'], 'editable' => $item['source'] === Definitions::STORED]);
    }

    public function destroy(Request $request, ToolRegistry $tools): JsonResponse
    {
        $id = rawurldecode((string) $request->route('id')) . ($request->route('name') !== null ? '/' . rawurldecode((string) $request->route('name')) : '');

        return $this->act($tools, $request, DefinitionAbilities::DELETE, ['kind' => (string) $request->route('kind'), 'id' => $id]);
    }

    /**
     * Run a definition tool as the person's own action (decision 045).
     *
     * @param array<string, mixed> $args
     */
    protected function act(ToolRegistry $tools, Request $request, string $tool, array $args): JsonResponse
    {
        $key     = substr((string) preg_replace('/[^A-Za-z0-9-]/', '', (string) $request->input('action_id', '')), 0, 64);
        $outcome = $tools->execute(ToolContext::forPerson($this->userId(), 'definitions:' . ($key !== '' ? $key : wp_generate_uuid4())), $tool, $args);
        if ($outcome->status !== 'ok') {
            return $this->error($outcome->error !== '' ? $outcome->error : __('That did not work.', 'maze-graph'), 422);
        }

        return $this->ok(['result' => $outcome->data, 'change' => $outcome->ui['change'] ?? null, 'summary' => StoredMessage::render((string) ($outcome->ui['summary'] ?? ''))]);
    }
}