registry_test.go

package inventory

import (
	"context"
	"encoding/json"
	"fmt"
	"testing"

	"github.com/modelcontextprotocol/go-sdk/mcp"
	"github.com/stretchr/testify/require"
)

// mustBuild is a test helper that calls Build() and fails the test if an error occurs.
// Use this for tests where Build() is not expected to fail.
func mustBuild(t *testing.T, b *Builder) *Inventory {
	t.Helper()
	inv, err := b.Build()
	require.NoError(t, err)
	return inv
}

// testToolsetMetadata returns a ToolsetMetadata for testing
func testToolsetMetadata(id string) ToolsetMetadata {
	return ToolsetMetadata{
		ID:          ToolsetID(id),
		Description: "Test toolset: " + id,
	}
}

// testToolsetMetadataWithDefault returns a ToolsetMetadata with Default flag for testing
func testToolsetMetadataWithDefault(id string, isDefault bool) ToolsetMetadata {
	return ToolsetMetadata{
		ID:          ToolsetID(id),
		Description: "Test toolset: " + id,
		Default:     isDefault,
	}
}

// mockToolWithDefault creates a mock tool with a default toolset flag
func mockToolWithDefault(name string, toolsetID string, readOnly bool, isDefault bool) ServerTool {
	return NewServerToolFromHandler(
		mcp.Tool{
			Name: name,
			Annotations: &mcp.ToolAnnotations{
				ReadOnlyHint: readOnly,
			},
			InputSchema: json.RawMessage(`{"type":"object","properties":{}}`),
		},
		testToolsetMetadataWithDefault(toolsetID, isDefault),
		func(_ any) mcp.ToolHandler {
			return func(_ context.Context, _ *mcp.CallToolRequest) (*mcp.CallToolResult, error) {
				return nil, nil
			}
		},
	)
}

// mockTool creates a minimal ServerTool for testing
func mockTool(name string, toolsetID string, readOnly bool) ServerTool {
	return NewServerToolFromHandler(
		mcp.Tool{
			Name: name,
			Annotations: &mcp.ToolAnnotations{
				ReadOnlyHint: readOnly,
			},
			InputSchema: json.RawMessage(`{"type":"object","properties":{}}`),
		},
		testToolsetMetadata(toolsetID),
		func(_ any) mcp.ToolHandler {
			return func(_ context.Context, _ *mcp.CallToolRequest) (*mcp.CallToolResult, error) {
				return nil, nil
			}
		},
	)
}

func TestNewRegistryEmpty(t *testing.T) {
	reg := mustBuild(t, NewBuilder())
	if len(reg.AvailableTools(context.Background())) != 0 {
		t.Fatalf("Expected tools to be empty")
	}
	if len(reg.AvailableResourceTemplates(context.Background())) != 0 {
		t.Fatalf("Expected resourceTemplates to be empty")
	}
	if len(reg.AvailablePrompts(context.Background())) != 0 {
		t.Fatalf("Expected prompts to be empty")
	}
}

func TestNewRegistryWithTools(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset1", false),
		mockTool("tool3", "toolset2", true),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools))

	if len(reg.AllTools()) != 3 {
		t.Errorf("Expected 3 tools, got %d", len(reg.AllTools()))
	}
}

func TestAvailableTools_NoFilters(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool_b", "toolset1", true),
		mockTool("tool_a", "toolset1", false),
		mockTool("tool_c", "toolset2", true),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}))
	available := reg.AvailableTools(context.Background())

	if len(available) != 3 {
		t.Fatalf("Expected 3 available tools, got %d", len(available))
	}

	// Verify deterministic sorting: by toolset ID, then tool name
	expectedOrder := []string{"tool_a", "tool_b", "tool_c"}
	for i, tool := range available {
		if tool.Tool.Name != expectedOrder[i] {
			t.Errorf("Tool at index %d: expected %s, got %s", i, expectedOrder[i], tool.Tool.Name)
		}
	}
}

func TestWithReadOnly(t *testing.T) {
	tools := []ServerTool{
		mockTool("read_tool", "toolset1", true),
		mockTool("write_tool", "toolset1", false),
	}

	// Build without read-only - should have both tools
	reg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}))
	allTools := reg.AvailableTools(context.Background())
	if len(allTools) != 2 {
		t.Fatalf("Expected 2 tools without read-only, got %d", len(allTools))
	}

	// Build with read-only - should filter out write tools
	readOnlyReg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithReadOnly(true))
	readOnlyTools := readOnlyReg.AvailableTools(context.Background())
	if len(readOnlyTools) != 1 {
		t.Fatalf("Expected 1 tool in read-only, got %d", len(readOnlyTools))
	}
	if readOnlyTools[0].Tool.Name != "read_tool" {
		t.Errorf("Expected read_tool, got %s", readOnlyTools[0].Tool.Name)
	}
}

func TestWithToolsets(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset2", true),
		mockTool("tool3", "toolset3", true),
	}

	// Build with all toolsets
	allReg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}))
	allTools := allReg.AvailableTools(context.Background())
	if len(allTools) != 3 {
		t.Fatalf("Expected 3 tools without filter, got %d", len(allTools))
	}

	// Build with specific toolsets
	filteredReg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"toolset1", "toolset3"}))
	filteredTools := filteredReg.AvailableTools(context.Background())

	if len(filteredTools) != 2 {
		t.Fatalf("Expected 2 filtered tools, got %d", len(filteredTools))
	}

	// Verify correct tools are included
	toolNames := make(map[string]bool)
	for _, tool := range filteredTools {
		toolNames[tool.Tool.Name] = true
	}
	if !toolNames["tool1"] || !toolNames["tool3"] {
		t.Errorf("Expected tool1 and tool3, got %v", toolNames)
	}
}

func TestWithToolsetsTrimsWhitespace(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset2", true),
	}

	// Whitespace should be trimmed
	filteredReg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{" toolset1 ", "  toolset2  "}))
	filteredTools := filteredReg.AvailableTools(context.Background())

	if len(filteredTools) != 2 {
		t.Fatalf("Expected 2 tools after whitespace trimming, got %d", len(filteredTools))
	}
}

func TestWithToolsetsDeduplicates(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
	}

	// Duplicates should be removed
	filteredReg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"toolset1", "toolset1", " toolset1 "}))
	filteredTools := filteredReg.AvailableTools(context.Background())

	if len(filteredTools) != 1 {
		t.Fatalf("Expected 1 tool after deduplication, got %d", len(filteredTools))
	}
}

func TestWithToolsetsIgnoresEmptyStrings(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
	}

	// Empty strings should be ignored
	filteredReg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"", "toolset1", "  ", ""}))
	filteredTools := filteredReg.AvailableTools(context.Background())

	if len(filteredTools) != 1 {
		t.Fatalf("Expected 1 tool, got %d", len(filteredTools))
	}
}

func TestUnrecognizedToolsets(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset2", true),
	}

	tests := []struct {
		name                 string
		input                []string
		expectedUnrecognized []string
	}{
		{
			name:                 "all valid",
			input:                []string{"toolset1", "toolset2"},
			expectedUnrecognized: nil,
		},
		{
			name:                 "one invalid",
			input:                []string{"toolset1", "invalid_toolset"},
			expectedUnrecognized: []string{"invalid_toolset"},
		},
		{
			name:                 "multiple invalid",
			input:                []string{"typo1", "toolset1", "typo2"},
			expectedUnrecognized: []string{"typo1", "typo2"},
		},
		{
			name:                 "invalid with whitespace trimmed",
			input:                []string{" invalid_tool "},
			expectedUnrecognized: []string{"invalid_tool"},
		},
		{
			name:                 "empty input",
			input:                []string{},
			expectedUnrecognized: nil,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			filtered := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets(tt.input))
			unrecognized := filtered.UnrecognizedToolsets()

			if len(unrecognized) != len(tt.expectedUnrecognized) {
				t.Fatalf("Expected %d unrecognized, got %d: %v",
					len(tt.expectedUnrecognized), len(unrecognized), unrecognized)
			}

			for i, expected := range tt.expectedUnrecognized {
				if unrecognized[i] != expected {
					t.Errorf("Expected unrecognized[%d] = %q, got %q", i, expected, unrecognized[i])
				}
			}
		})
	}
}

func TestBuildErrorsOnUnrecognizedTools(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset2", true),
	}

	deprecatedAliases := map[string]string{
		"old_tool": "tool1",
	}

	tests := []struct {
		name          string
		withTools     []string
		expectError   bool
		errorContains string
	}{
		{
			name:        "all valid",
			withTools:   []string{"tool1", "tool2"},
			expectError: false,
		},
		{
			name:          "one invalid",
			withTools:     []string{"tool1", "blabla"},
			expectError:   true,
			errorContains: "blabla",
		},
		{
			name:          "multiple invalid",
			withTools:     []string{"invalid1", "tool1", "invalid2"},
			expectError:   true,
			errorContains: "invalid1",
		},
		{
			name:        "deprecated alias is valid",
			withTools:   []string{"old_tool"},
			expectError: false,
		},
		{
			name:        "mixed valid and deprecated alias",
			withTools:   []string{"old_tool", "tool2"},
			expectError: false,
		},
		{
			name:        "empty input",
			withTools:   []string{},
			expectError: false,
		},
		{
			name:        "whitespace trimmed from valid tool",
			withTools:   []string{" tool1 ", "  tool2  "},
			expectError: false,
		},
		{
			name:          "whitespace trimmed from invalid tool",
			withTools:     []string{" invalid_tool "},
			expectError:   true,
			errorContains: "invalid_tool",
		},
		{
			name:        "duplicate tools deduplicated",
			withTools:   []string{"tool1", "tool1"},
			expectError: false,
		},
		{
			name:          "duplicate invalid tools deduplicated",
			withTools:     []string{"blabla", "blabla"},
			expectError:   true,
			errorContains: "blabla",
		},
		{
			name:        "mixed whitespace and duplicates",
			withTools:   []string{" tool1 ", "tool1", "  tool1  "},
			expectError: false,
		},
		{
			name:        "empty strings ignored",
			withTools:   []string{"", "tool1", "  ", ""},
			expectError: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			inv, err := NewBuilder().
				SetTools(tools).
				WithDeprecatedAliases(deprecatedAliases).
				WithToolsets([]string{"all"}).
				WithTools(tt.withTools).
				Build()

			if tt.expectError {
				require.Error(t, err, "Expected error for unrecognized tools")
				require.Contains(t, err.Error(), tt.errorContains)
				require.Nil(t, inv)
			} else {
				require.NoError(t, err)
				require.NotNil(t, inv)
			}
		})
	}
}

func TestWithTools(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset1", true),
		mockTool("tool3", "toolset2", true),
	}

	// WithTools adds additional tools that bypass toolset filtering
	// When combined with WithToolsets([]), only the additional tools should be available
	filteredReg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{}).WithTools([]string{"tool1", "tool3"}))
	filteredTools := filteredReg.AvailableTools(context.Background())

	if len(filteredTools) != 2 {
		t.Fatalf("Expected 2 filtered tools, got %d", len(filteredTools))
	}

	toolNames := make(map[string]bool)
	for _, tool := range filteredTools {
		toolNames[tool.Tool.Name] = true
	}
	if !toolNames["tool1"] || !toolNames["tool3"] {
		t.Errorf("Expected tool1 and tool3, got %v", toolNames)
	}
}

func TestChainedFilters(t *testing.T) {
	tools := []ServerTool{
		mockTool("read1", "toolset1", true),
		mockTool("write1", "toolset1", false),
		mockTool("read2", "toolset2", true),
		mockTool("write2", "toolset2", false),
	}

	// Chain read-only and toolset filter
	filtered := mustBuild(t, NewBuilder().SetTools(tools).WithReadOnly(true).WithToolsets([]string{"toolset1"}))
	result := filtered.AvailableTools(context.Background())

	if len(result) != 1 {
		t.Fatalf("Expected 1 tool after chained filters, got %d", len(result))
	}
	if result[0].Tool.Name != "read1" {
		t.Errorf("Expected read1, got %s", result[0].Tool.Name)
	}
}

func TestToolsetIDs(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset_b", true),
		mockTool("tool2", "toolset_a", true),
		mockTool("tool3", "toolset_b", true), // duplicate toolset
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools))
	ids := reg.ToolsetIDs()

	if len(ids) != 2 {
		t.Fatalf("Expected 2 unique toolset IDs, got %d", len(ids))
	}

	// Should be sorted
	if ids[0] != "toolset_a" || ids[1] != "toolset_b" {
		t.Errorf("Expected sorted IDs [toolset_a, toolset_b], got %v", ids)
	}
}

func TestToolsetDescriptions(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset2", true),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools))
	descriptions := reg.ToolsetDescriptions()

	if len(descriptions) != 2 {
		t.Fatalf("Expected 2 descriptions, got %d", len(descriptions))
	}

	if descriptions["toolset1"] != "Test toolset: toolset1" {
		t.Errorf("Wrong description for toolset1: %s", descriptions["toolset1"])
	}
}

func TestToolsForToolset(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset1", true),
		mockTool("tool3", "toolset2", true),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools))
	toolset1Tools := reg.ToolsForToolset("toolset1")

	if len(toolset1Tools) != 2 {
		t.Fatalf("Expected 2 tools for toolset1, got %d", len(toolset1Tools))
	}
}

func TestToolsForToolset_RespectsReadOnly(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool_read", "toolset1", true),
		mockTool("tool_write", "toolset1", false),
	}

	reg := mustBuild(
		t,
		NewBuilder().SetTools(tools).WithToolsets([]string{}).WithReadOnly(true),
	)
	toolset1Tools := reg.ToolsForToolset("toolset1")

	if len(toolset1Tools) != 1 {
		t.Fatalf("Expected 1 read-only tool for toolset1, got %d", len(toolset1Tools))
	}
	if toolset1Tools[0].Tool.Name != "tool_read" {
		t.Fatalf("Expected tool_read, got %q", toolset1Tools[0].Tool.Name)
	}
}

func TestWithDeprecatedAliases(t *testing.T) {
	tools := []ServerTool{
		mockTool("new_name", "toolset1", true),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools).WithDeprecatedAliases(map[string]string{
		"old_name":  "new_name",
		"get_issue": "issue_read",
	}))

	// Test resolving aliases
	resolved, aliasesUsed := reg.ResolveToolAliases([]string{"old_name"})
	if len(resolved) != 1 || resolved[0] != "new_name" {
		t.Errorf("expected alias to resolve to 'new_name', got %v", resolved)
	}
	if len(aliasesUsed) != 1 || aliasesUsed["old_name"] != "new_name" {
		t.Errorf("expected alias mapping, got %v", aliasesUsed)
	}
}

func TestResolveToolAliases(t *testing.T) {
	tools := []ServerTool{
		mockTool("issue_read", "toolset1", true),
		mockTool("some_tool", "toolset1", true),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools).
		WithDeprecatedAliases(map[string]string{
			"get_issue": "issue_read",
		}))

	// Test resolving a mix of aliases and canonical names
	input := []string{"get_issue", "some_tool"}
	resolved, aliasesUsed := reg.ResolveToolAliases(input)

	if len(resolved) != 2 {
		t.Fatalf("expected 2 resolved names, got %d", len(resolved))
	}
	if resolved[0] != "issue_read" {
		t.Errorf("expected 'issue_read', got '%s'", resolved[0])
	}
	if resolved[1] != "some_tool" {
		t.Errorf("expected 'some_tool' (unchanged), got '%s'", resolved[1])
	}

	if len(aliasesUsed) != 1 {
		t.Fatalf("expected 1 alias used, got %d", len(aliasesUsed))
	}
	if aliasesUsed["get_issue"] != "issue_read" {
		t.Errorf("expected aliasesUsed['get_issue'] = 'issue_read', got '%s'", aliasesUsed["get_issue"])
	}
}

func TestFindToolByName(t *testing.T) {
	tools := []ServerTool{
		mockTool("issue_read", "toolset1", true),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools))

	// Find by name
	tool, toolsetID, err := reg.FindToolByName("issue_read")
	if err != nil {
		t.Fatalf("expected no error, got %v", err)
	}
	if tool.Tool.Name != "issue_read" {
		t.Errorf("expected tool name 'issue_read', got '%s'", tool.Tool.Name)
	}
	if toolsetID != "toolset1" {
		t.Errorf("expected toolset ID 'toolset1', got '%s'", toolsetID)
	}

	// Non-existent tool
	_, _, err = reg.FindToolByName("nonexistent")
	if err == nil {
		t.Error("expected error for non-existent tool")
	}
}

func TestWithToolsAdditive(t *testing.T) {
	tools := []ServerTool{
		mockTool("issue_read", "toolset1", true),
		mockTool("issue_write", "toolset1", false),
		mockTool("repo_read", "toolset2", true),
	}

	// Test WithTools bypasses toolset filtering
	// Enable only toolset2, but add issue_read as additional tool
	filtered := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"toolset2"}).WithTools([]string{"issue_read"}))

	available := filtered.AvailableTools(context.Background())
	if len(available) != 2 {
		t.Errorf("expected 2 tools (repo_read from toolset + issue_read additional), got %d", len(available))
	}

	// Verify both tools are present
	toolNames := make(map[string]bool)
	for _, tool := range available {
		toolNames[tool.Tool.Name] = true
	}
	if !toolNames["issue_read"] {
		t.Error("expected issue_read to be included as additional tool")
	}
	if !toolNames["repo_read"] {
		t.Error("expected repo_read to be included from toolset2")
	}

	// Test WithTools respects read-only mode
	readOnlyFiltered := mustBuild(t, NewBuilder().SetTools(tools).WithReadOnly(true).WithTools([]string{"issue_write"}))
	available = readOnlyFiltered.AvailableTools(context.Background())

	// issue_write should be excluded because read-only applies to additional tools too
	for _, tool := range available {
		if tool.Tool.Name == "issue_write" {
			t.Error("expected issue_write to be excluded in read-only mode")
		}
	}

	// Test WithTools with non-existent tool (should error during Build)
	_, err := NewBuilder().SetTools(tools).WithToolsets([]string{}).WithTools([]string{"nonexistent"}).Build()
	require.Error(t, err, "expected error for non-existent tool")
	require.Contains(t, err.Error(), "nonexistent")
}

func TestWithToolsResolvesAliases(t *testing.T) {
	tools := []ServerTool{
		mockTool("issue_read", "toolset1", true),
	}

	// Using deprecated alias should resolve to canonical name
	filtered := mustBuild(t, NewBuilder().SetTools(tools).
		WithDeprecatedAliases(map[string]string{
			"get_issue": "issue_read",
		}).
		WithToolsets([]string{}).
		WithTools([]string{"get_issue"}))
	available := filtered.AvailableTools(context.Background())

	if len(available) != 1 {
		t.Errorf("expected 1 tool, got %d", len(available))
	}
	if available[0].Tool.Name != "issue_read" {
		t.Errorf("expected issue_read, got %s", available[0].Tool.Name)
	}
}

func TestHasToolset(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}))

	if !reg.HasToolset("toolset1") {
		t.Error("expected HasToolset to return true for existing toolset")
	}
	if reg.HasToolset("nonexistent") {
		t.Error("expected HasToolset to return false for non-existent toolset")
	}
}

func TestEnabledToolsetIDs(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset2", true),
	}

	// Without filter, all toolsets are enabled
	reg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}))
	ids := reg.EnabledToolsetIDs()
	if len(ids) != 2 {
		t.Fatalf("Expected 2 enabled toolset IDs, got %d", len(ids))
	}

	// With filter
	filtered := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"toolset1"}))
	filteredIDs := filtered.EnabledToolsetIDs()
	if len(filteredIDs) != 1 {
		t.Fatalf("Expected 1 enabled toolset ID, got %d", len(filteredIDs))
	}
	if filteredIDs[0] != "toolset1" {
		t.Errorf("Expected toolset1, got %s", filteredIDs[0])
	}
}

func TestAllTools(t *testing.T) {
	tools := []ServerTool{
		mockTool("read_tool", "toolset1", true),
		mockTool("write_tool", "toolset1", false),
	}

	// Even with read-only filter, AllTools returns everything
	readOnlyReg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithReadOnly(true))

	allTools := readOnlyReg.AllTools()
	if len(allTools) != 2 {
		t.Fatalf("Expected 2 tools from AllTools, got %d", len(allTools))
	}

	// But AvailableTools respects the filter
	availableTools := readOnlyReg.AvailableTools(context.Background())
	if len(availableTools) != 1 {
		t.Fatalf("Expected 1 tool from AvailableTools, got %d", len(availableTools))
	}
}

func TestServerToolIsReadOnly(t *testing.T) {
	readTool := mockTool("read_tool", "toolset1", true)
	writeTool := mockTool("write_tool", "toolset1", false)

	if !readTool.IsReadOnly() {
		t.Error("Expected read tool to be read-only")
	}
	if writeTool.IsReadOnly() {
		t.Error("Expected write tool to not be read-only")
	}
}

// mockResource creates a minimal ServerResourceTemplate for testing
func mockResource(name string, toolsetID string, uriTemplate string) ServerResourceTemplate {
	return NewServerResourceTemplate(
		testToolsetMetadata(toolsetID),
		mcp.ResourceTemplate{
			Name:        name,
			URITemplate: uriTemplate,
		},
		func(_ any) mcp.ResourceHandler {
			return func(_ context.Context, _ *mcp.ReadResourceRequest) (*mcp.ReadResourceResult, error) {
				return nil, nil
			}
		},
	)
}

// mockPrompt creates a minimal ServerPrompt for testing
func mockPrompt(name string, toolsetID string) ServerPrompt {
	return NewServerPrompt(
		testToolsetMetadata(toolsetID),
		mcp.Prompt{Name: name},
		func(_ context.Context, _ *mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
			return nil, nil
		},
	)
}

func TestForMCPRequest_Initialize(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "repos", true),
		mockTool("tool2", "issues", false),
	}
	resources := []ServerResourceTemplate{
		mockResource("res1", "repos", "repo://{owner}/{repo}"),
	}
	prompts := []ServerPrompt{
		mockPrompt("prompt1", "repos"),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools).SetResources(resources).SetPrompts(prompts).WithToolsets([]string{"all"}))
	filtered := reg.ForMCPRequest(MCPMethodInitialize, "")

	// Initialize should return empty - capabilities come from ServerOptions
	if len(filtered.AvailableTools(context.Background())) != 0 {
		t.Errorf("Expected 0 tools for initialize, got %d", len(filtered.AvailableTools(context.Background())))
	}
	if len(filtered.AvailableResourceTemplates(context.Background())) != 0 {
		t.Errorf("Expected 0 resources for initialize, got %d", len(filtered.AvailableResourceTemplates(context.Background())))
	}
	if len(filtered.AvailablePrompts(context.Background())) != 0 {
		t.Errorf("Expected 0 prompts for initialize, got %d", len(filtered.AvailablePrompts(context.Background())))
	}
}

func TestForMCPRequest_ToolsList(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "repos", true),
		mockTool("tool2", "issues", true),
	}
	resources := []ServerResourceTemplate{
		mockResource("res1", "repos", "repo://{owner}/{repo}"),
	}
	prompts := []ServerPrompt{
		mockPrompt("prompt1", "repos"),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools).SetResources(resources).SetPrompts(prompts).WithToolsets([]string{"all"}))
	filtered := reg.ForMCPRequest(MCPMethodToolsList, "")

	// tools/list should return all tools, no resources or prompts
	if len(filtered.AvailableTools(context.Background())) != 2 {
		t.Errorf("Expected 2 tools for tools/list, got %d", len(filtered.AvailableTools(context.Background())))
	}
	if len(filtered.AvailableResourceTemplates(context.Background())) != 0 {
		t.Errorf("Expected 0 resources for tools/list, got %d", len(filtered.AvailableResourceTemplates(context.Background())))
	}
	if len(filtered.AvailablePrompts(context.Background())) != 0 {
		t.Errorf("Expected 0 prompts for tools/list, got %d", len(filtered.AvailablePrompts(context.Background())))
	}
}

func TestForMCPRequest_ToolsCall(t *testing.T) {
	tools := []ServerTool{
		mockTool("get_me", "context", true),
		mockTool("create_issue", "issues", false),
		mockTool("list_repos", "repos", true),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}))
	filtered := reg.ForMCPRequest(MCPMethodToolsCall, "get_me")

	available := filtered.AvailableTools(context.Background())
	if len(available) != 1 {
		t.Fatalf("Expected 1 tool for tools/call with name, got %d", len(available))
	}
	if available[0].Tool.Name != "get_me" {
		t.Errorf("Expected tool name 'get_me', got %q", available[0].Tool.Name)
	}
}

func TestForMCPRequest_ToolsCall_NotFound(t *testing.T) {
	tools := []ServerTool{
		mockTool("get_me", "context", true),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}))
	filtered := reg.ForMCPRequest(MCPMethodToolsCall, "nonexistent")

	if len(filtered.AvailableTools(context.Background())) != 0 {
		t.Errorf("Expected 0 tools for nonexistent tool, got %d", len(filtered.AvailableTools(context.Background())))
	}
}

func TestForMCPRequest_ToolsCall_DeprecatedAlias(t *testing.T) {
	tools := []ServerTool{
		mockTool("get_me", "context", true),
		mockTool("list_commits", "repos", true),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools).
		WithToolsets([]string{"all"}).
		WithDeprecatedAliases(map[string]string{
			"old_get_me": "get_me",
		}))

	// Request using the deprecated alias
	filtered := reg.ForMCPRequest(MCPMethodToolsCall, "old_get_me")

	available := filtered.AvailableTools(context.Background())
	if len(available) != 1 {
		t.Fatalf("Expected 1 tool when using deprecated alias, got %d", len(available))
	}
	if available[0].Tool.Name != "get_me" {
		t.Errorf("Expected canonical name 'get_me', got %q", available[0].Tool.Name)
	}
}

func TestForMCPRequest_ToolsCall_RespectsFilters(t *testing.T) {
	tools := []ServerTool{
		mockTool("create_issue", "issues", false), // write tool
	}

	// Apply read-only filter at build time, then ForMCPRequest
	reg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithReadOnly(true))
	filtered := reg.ForMCPRequest(MCPMethodToolsCall, "create_issue")

	// The tool exists in the filtered group, but AvailableTools respects read-only
	available := filtered.AvailableTools(context.Background())
	if len(available) != 0 {
		t.Errorf("Expected 0 tools - write tool should be filtered by read-only, got %d", len(available))
	}
}

func TestForMCPRequest_ToolsCall_DeprecatedAliasRespectsReadOnly(t *testing.T) {
	tools := []ServerTool{
		mockTool("projects_write", "projects", false),
	}

	reg := mustBuild(
		t,
		NewBuilder().
			SetTools(tools).
			WithToolsets([]string{"all"}).
			WithReadOnly(true).
			WithDeprecatedAliases(map[string]string{
				"add_project_item": "projects_write",
			}),
	)

	filtered := reg.ForMCPRequest(MCPMethodToolsCall, "add_project_item")
	available := filtered.AvailableTools(context.Background())

	if len(available) != 0 {
		t.Fatalf("Expected 0 tools - deprecated alias should still respect read-only, got %d", len(available))
	}
}

func TestForMCPRequest_ResourcesList(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "repos", true),
	}
	resources := []ServerResourceTemplate{
		mockResource("res1", "repos", "repo://{owner}/{repo}"),
		mockResource("res2", "repos", "branch://{owner}/{repo}/{branch}"),
	}
	prompts := []ServerPrompt{
		mockPrompt("prompt1", "repos"),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools).SetResources(resources).SetPrompts(prompts).WithToolsets([]string{"all"}))
	filtered := reg.ForMCPRequest(MCPMethodResourcesList, "")

	if len(filtered.AvailableTools(context.Background())) != 0 {
		t.Errorf("Expected 0 tools for resources/list, got %d", len(filtered.AvailableTools(context.Background())))
	}
	if len(filtered.AvailableResourceTemplates(context.Background())) != 2 {
		t.Errorf("Expected 2 resources for resources/list, got %d", len(filtered.AvailableResourceTemplates(context.Background())))
	}
	if len(filtered.AvailablePrompts(context.Background())) != 0 {
		t.Errorf("Expected 0 prompts for resources/list, got %d", len(filtered.AvailablePrompts(context.Background())))
	}
}

func TestForMCPRequest_ResourcesRead(t *testing.T) {
	resources := []ServerResourceTemplate{
		mockResource("res1", "repos", "repo://{owner}/{repo}"),
		mockResource("res2", "repos", "branch://{owner}/{repo}/{branch}"),
	}

	reg := mustBuild(t, NewBuilder().SetResources(resources).WithToolsets([]string{"all"}))
	// Pass a concrete URI - all resources remain registered, SDK handles matching
	filtered := reg.ForMCPRequest(MCPMethodResourcesRead, "repo://owner/repo")

	// All resources should be available - SDK handles URI template matching internally
	available := filtered.AvailableResourceTemplates(context.Background())
	if len(available) != 2 {
		t.Fatalf("Expected 2 resources for resources/read (SDK handles matching), got %d", len(available))
	}
}
func TestForMCPRequest_PromptsList(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "repos", true),
	}
	resources := []ServerResourceTemplate{
		mockResource("res1", "repos", "repo://{owner}/{repo}"),
	}
	prompts := []ServerPrompt{
		mockPrompt("prompt1", "repos"),
		mockPrompt("prompt2", "issues"),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools).SetResources(resources).SetPrompts(prompts).WithToolsets([]string{"all"}))
	filtered := reg.ForMCPRequest(MCPMethodPromptsList, "")

	if len(filtered.AvailableTools(context.Background())) != 0 {
		t.Errorf("Expected 0 tools for prompts/list, got %d", len(filtered.AvailableTools(context.Background())))
	}
	if len(filtered.AvailableResourceTemplates(context.Background())) != 0 {
		t.Errorf("Expected 0 resources for prompts/list, got %d", len(filtered.AvailableResourceTemplates(context.Background())))
	}
	if len(filtered.AvailablePrompts(context.Background())) != 2 {
		t.Errorf("Expected 2 prompts for prompts/list, got %d", len(filtered.AvailablePrompts(context.Background())))
	}
}

func TestForMCPRequest_PromptsGet(t *testing.T) {
	prompts := []ServerPrompt{
		mockPrompt("prompt1", "repos"),
		mockPrompt("prompt2", "issues"),
	}

	reg := mustBuild(t, NewBuilder().SetPrompts(prompts).WithToolsets([]string{"all"}))
	filtered := reg.ForMCPRequest(MCPMethodPromptsGet, "prompt1")

	available := filtered.AvailablePrompts(context.Background())
	if len(available) != 1 {
		t.Fatalf("Expected 1 prompt for prompts/get, got %d", len(available))
	}
	if available[0].Prompt.Name != "prompt1" {
		t.Errorf("Expected prompt name 'prompt1', got %q", available[0].Prompt.Name)
	}
}

func TestForMCPRequest_UnknownMethod(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "repos", true),
	}
	resources := []ServerResourceTemplate{
		mockResource("res1", "repos", "repo://{owner}/{repo}"),
	}
	prompts := []ServerPrompt{
		mockPrompt("prompt1", "repos"),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools).SetResources(resources).SetPrompts(prompts).WithToolsets([]string{"all"}))
	filtered := reg.ForMCPRequest("unknown/method", "")

	// Unknown methods should return empty
	if len(filtered.AvailableTools(context.Background())) != 0 {
		t.Errorf("Expected 0 tools for unknown method, got %d", len(filtered.AvailableTools(context.Background())))
	}
	if len(filtered.AvailableResourceTemplates(context.Background())) != 0 {
		t.Errorf("Expected 0 resources for unknown method, got %d", len(filtered.AvailableResourceTemplates(context.Background())))
	}
	if len(filtered.AvailablePrompts(context.Background())) != 0 {
		t.Errorf("Expected 0 prompts for unknown method, got %d", len(filtered.AvailablePrompts(context.Background())))
	}
}

func TestForMCPRequest_DoesNotMutateOriginal(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "repos", true),
		mockTool("tool2", "issues", true),
	}
	resources := []ServerResourceTemplate{
		mockResource("res1", "repos", "repo://{owner}/{repo}"),
	}
	prompts := []ServerPrompt{
		mockPrompt("prompt1", "repos"),
	}

	original := mustBuild(t, NewBuilder().SetTools(tools).SetResources(resources).SetPrompts(prompts).WithToolsets([]string{"all"}))
	filtered := original.ForMCPRequest(MCPMethodToolsCall, "tool1")

	// Original should be unchanged
	if len(original.AvailableTools(context.Background())) != 2 {
		t.Errorf("Original was mutated! Expected 2 tools, got %d", len(original.AvailableTools(context.Background())))
	}
	if len(original.AvailableResourceTemplates(context.Background())) != 1 {
		t.Errorf("Original was mutated! Expected 1 resource, got %d", len(original.AvailableResourceTemplates(context.Background())))
	}
	if len(original.AvailablePrompts(context.Background())) != 1 {
		t.Errorf("Original was mutated! Expected 1 prompt, got %d", len(original.AvailablePrompts(context.Background())))
	}

	// Filtered should have only the requested tool
	if len(filtered.AvailableTools(context.Background())) != 1 {
		t.Errorf("Expected 1 tool in filtered, got %d", len(filtered.AvailableTools(context.Background())))
	}
	if len(filtered.AvailableResourceTemplates(context.Background())) != 0 {
		t.Errorf("Expected 0 resources in filtered, got %d", len(filtered.AvailableResourceTemplates(context.Background())))
	}
	if len(filtered.AvailablePrompts(context.Background())) != 0 {
		t.Errorf("Expected 0 prompts in filtered, got %d", len(filtered.AvailablePrompts(context.Background())))
	}
}

func TestForMCPRequest_ChainedWithOtherFilters(t *testing.T) {
	tools := []ServerTool{
		mockToolWithDefault("get_me", "context", true, true),        // default toolset
		mockToolWithDefault("create_issue", "issues", false, false), // not default
		mockToolWithDefault("list_repos", "repos", true, true),      // default toolset
		mockToolWithDefault("delete_repo", "repos", false, true),    // default but write
	}

	// Chain: default toolsets -> read-only -> specific method
	reg := mustBuild(t, NewBuilder().SetTools(tools).
		WithToolsets([]string{"default"}).
		WithReadOnly(true))
	filtered := reg.ForMCPRequest(MCPMethodToolsList, "")

	available := filtered.AvailableTools(context.Background())

	// Should have: get_me (context, read), list_repos (repos, read)
	// Should NOT have: create_issue (issues not in default), delete_repo (write)
	if len(available) != 2 {
		t.Fatalf("Expected 2 tools after filter chain, got %d", len(available))
	}

	toolNames := make(map[string]bool)
	for _, tool := range available {
		toolNames[tool.Tool.Name] = true
	}

	if !toolNames["get_me"] {
		t.Error("Expected get_me to be available")
	}
	if !toolNames["list_repos"] {
		t.Error("Expected list_repos to be available")
	}
	if toolNames["create_issue"] {
		t.Error("create_issue should not be available (toolset not enabled)")
	}
	if toolNames["delete_repo"] {
		t.Error("delete_repo should not be available (write tool in read-only mode)")
	}
}

func TestForMCPRequest_ResourcesTemplatesList(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "repos", true),
	}
	resources := []ServerResourceTemplate{
		mockResource("res1", "repos", "repo://{owner}/{repo}"),
	}

	reg := mustBuild(t, NewBuilder().SetTools(tools).SetResources(resources).WithToolsets([]string{"all"}))
	filtered := reg.ForMCPRequest(MCPMethodResourcesTemplatesList, "")

	// Same behavior as resources/list
	if len(filtered.AvailableTools(context.Background())) != 0 {
		t.Errorf("Expected 0 tools, got %d", len(filtered.AvailableTools(context.Background())))
	}
	if len(filtered.AvailableResourceTemplates(context.Background())) != 1 {
		t.Errorf("Expected 1 resource, got %d", len(filtered.AvailableResourceTemplates(context.Background())))
	}
}

func TestMCPMethodConstants(t *testing.T) {
	// Verify constants match expected MCP method names
	tests := []struct {
		constant string
		expected string
	}{
		{MCPMethodInitialize, "initialize"},
		{MCPMethodToolsList, "tools/list"},
		{MCPMethodToolsCall, "tools/call"},
		{MCPMethodResourcesList, "resources/list"},
		{MCPMethodResourcesRead, "resources/read"},
		{MCPMethodResourcesTemplatesList, "resources/templates/list"},
		{MCPMethodPromptsList, "prompts/list"},
		{MCPMethodPromptsGet, "prompts/get"},
	}

	for _, tt := range tests {
		if tt.constant != tt.expected {
			t.Errorf("Constant mismatch: got %q, expected %q", tt.constant, tt.expected)
		}
	}
}

// mockToolWithFlags creates a ServerTool with feature flags for testing
func mockToolWithFlags(name string, toolsetID string, readOnly bool, enableFlag, disableFlag string) ServerTool {
	tool := mockTool(name, toolsetID, readOnly)
	tool.FeatureFlagEnable = enableFlag
	tool.FeatureFlagDisable = disableFlag
	return tool
}

func TestFeatureFlagEnable(t *testing.T) {
	tools := []ServerTool{
		mockTool("always_available", "toolset1", true),
		mockToolWithFlags("needs_flag", "toolset1", true, "my_feature", ""),
	}

	// Without feature checker, tool with FeatureFlagEnable should be excluded
	reg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}))
	available := reg.AvailableTools(context.Background())
	if len(available) != 1 {
		t.Fatalf("Expected 1 tool without feature checker, got %d", len(available))
	}
	if available[0].Tool.Name != "always_available" {
		t.Errorf("Expected always_available, got %s", available[0].Tool.Name)
	}

	// With feature checker returning false, tool should still be excluded
	checkerFalse := func(_ context.Context, _ string) (bool, error) { return false, nil }
	regFalse := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithFeatureChecker(checkerFalse))
	availableFalse := regFalse.AvailableTools(context.Background())
	if len(availableFalse) != 1 {
		t.Fatalf("Expected 1 tool with false checker, got %d", len(availableFalse))
	}

	// With feature checker returning true for "my_feature", tool should be included
	checkerTrue := func(_ context.Context, flag string) (bool, error) {
		return flag == "my_feature", nil
	}
	regTrue := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithFeatureChecker(checkerTrue))
	availableTrue := regTrue.AvailableTools(context.Background())
	if len(availableTrue) != 2 {
		t.Fatalf("Expected 2 tools with true checker, got %d", len(availableTrue))
	}
}

func TestFeatureFlagDisable(t *testing.T) {
	tools := []ServerTool{
		mockTool("always_available", "toolset1", true),
		mockToolWithFlags("disabled_by_flag", "toolset1", true, "", "kill_switch"),
	}

	// Without feature checker, tool with FeatureFlagDisable should be included (flag is false)
	reg := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}))
	available := reg.AvailableTools(context.Background())
	if len(available) != 2 {
		t.Fatalf("Expected 2 tools without feature checker, got %d", len(available))
	}

	// With feature checker returning true for "kill_switch", tool should be excluded
	checkerTrue := func(_ context.Context, flag string) (bool, error) {
		return flag == "kill_switch", nil
	}
	regFiltered := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithFeatureChecker(checkerTrue))
	availableFiltered := regFiltered.AvailableTools(context.Background())
	if len(availableFiltered) != 1 {
		t.Fatalf("Expected 1 tool with kill_switch enabled, got %d", len(availableFiltered))
	}
	if availableFiltered[0].Tool.Name != "always_available" {
		t.Errorf("Expected always_available, got %s", availableFiltered[0].Tool.Name)
	}
}

func TestFeatureFlagBoth(t *testing.T) {
	// Tool that requires "new_feature" AND is disabled by "kill_switch"
	tools := []ServerTool{
		mockToolWithFlags("complex_tool", "toolset1", true, "new_feature", "kill_switch"),
	}

	// Enable flag not set -> excluded
	checker1 := func(_ context.Context, _ string) (bool, error) { return false, nil }
	reg1 := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithFeatureChecker(checker1))
	if len(reg1.AvailableTools(context.Background())) != 0 {
		t.Error("Tool should be excluded when enable flag is false")
	}

	// Enable flag set, disable flag not set -> included
	checker2 := func(_ context.Context, flag string) (bool, error) { return flag == "new_feature", nil }
	reg2 := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithFeatureChecker(checker2))
	if len(reg2.AvailableTools(context.Background())) != 1 {
		t.Error("Tool should be included when enable flag is true and disable flag is false")
	}

	// Enable flag set, disable flag also set -> excluded (disable wins)
	checker3 := func(_ context.Context, _ string) (bool, error) { return true, nil }
	reg3 := mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithFeatureChecker(checker3))
	if len(reg3.AvailableTools(context.Background())) != 0 {
		t.Error("Tool should be excluded when both flags are true (disable wins)")
	}
}

func TestFeatureFlagError(t *testing.T) {
	tools := []ServerTool{
		mockToolWithFlags("needs_flag", "toolset1", true, "my_feature", ""),
	}

	// Checker that returns error should treat as false (tool excluded)
	checkerError := func(_ context.Context, _ string) (bool, error) {
		return false, fmt.Errorf("simulated error")
	}
	reg := mustBuild(t, NewBuilder().SetTools(tools).WithFeatureChecker(checkerError))
	available := reg.AvailableTools(context.Background())
	if len(available) != 0 {
		t.Errorf("Expected 0 tools when checker errors, got %d", len(available))
	}
}

func TestFeatureFlagResources(t *testing.T) {
	resources := []ServerResourceTemplate{
		mockResource("always_available", "toolset1", "uri1"),
		{
			Template:          mcp.ResourceTemplate{Name: "needs_flag", URITemplate: "uri2"},
			Toolset:           testToolsetMetadata("toolset1"),
			FeatureFlagEnable: "my_feature",
		},
	}

	// Without checker, resource with enable flag should be excluded
	reg := mustBuild(t, NewBuilder().SetResources(resources).WithToolsets([]string{"all"}))
	available := reg.AvailableResourceTemplates(context.Background())
	if len(available) != 1 {
		t.Fatalf("Expected 1 resource without checker, got %d", len(available))
	}

	// With checker returning true, both should be included
	checker := func(_ context.Context, _ string) (bool, error) { return true, nil }
	regWithChecker := mustBuild(t, NewBuilder().SetResources(resources).WithToolsets([]string{"all"}).WithFeatureChecker(checker))
	if len(regWithChecker.AvailableResourceTemplates(context.Background())) != 2 {
		t.Errorf("Expected 2 resources with checker, got %d", len(regWithChecker.AvailableResourceTemplates(context.Background())))
	}
}

func TestFeatureFlagPrompts(t *testing.T) {
	prompts := []ServerPrompt{
		mockPrompt("always_available", "toolset1"),
		{
			Prompt:            mcp.Prompt{Name: "needs_flag"},
			Toolset:           testToolsetMetadata("toolset1"),
			FeatureFlagEnable: "my_feature",
		},
	}

	// Without checker, prompt with enable flag should be excluded
	reg := mustBuild(t, NewBuilder().SetPrompts(prompts).WithToolsets([]string{"all"}))
	available := reg.AvailablePrompts(context.Background())
	if len(available) != 1 {
		t.Fatalf("Expected 1 prompt without checker, got %d", len(available))
	}

	// With checker returning true, both should be included
	checker := func(_ context.Context, _ string) (bool, error) { return true, nil }
	regWithChecker := mustBuild(t, NewBuilder().SetPrompts(prompts).WithToolsets([]string{"all"}).WithFeatureChecker(checker))
	if len(regWithChecker.AvailablePrompts(context.Background())) != 2 {
		t.Errorf("Expected 2 prompts with checker, got %d", len(regWithChecker.AvailablePrompts(context.Background())))
	}
}

func TestServerToolHasHandler(t *testing.T) {
	// Tool with handler
	toolWithHandler := mockTool("has_handler", "toolset1", true)
	if !toolWithHandler.HasHandler() {
		t.Error("Expected HasHandler() to return true for tool with handler")
	}

	// Tool without handler
	toolWithoutHandler := ServerTool{
		Tool:    mcp.Tool{Name: "no_handler"},
		Toolset: testToolsetMetadata("toolset1"),
	}
	if toolWithoutHandler.HasHandler() {
		t.Error("Expected HasHandler() to return false for tool without handler")
	}
}

func TestServerToolHandlerPanicOnNil(t *testing.T) {
	tool := ServerTool{
		Tool:    mcp.Tool{Name: "no_handler"},
		Toolset: testToolsetMetadata("toolset1"),
	}

	defer func() {
		if r := recover(); r == nil {
			t.Error("Expected Handler() to panic when HandlerFunc is nil")
		}
	}()

	tool.Handler(nil)
}

// Tests for Enabled function on ServerTool
func TestServerToolEnabled(t *testing.T) {
	tests := []struct {
		name           string
		enabledFunc    func(ctx context.Context) (bool, error)
		expectedCount  int
		expectInResult bool
	}{
		{
			name:           "nil Enabled function - tool included",
			enabledFunc:    nil,
			expectedCount:  1,
			expectInResult: true,
		},
		{
			name: "Enabled returns true - tool included",
			enabledFunc: func(_ context.Context) (bool, error) {
				return true, nil
			},
			expectedCount:  1,
			expectInResult: true,
		},
		{
			name: "Enabled returns false - tool excluded",
			enabledFunc: func(_ context.Context) (bool, error) {
				return false, nil
			},
			expectedCount:  0,
			expectInResult: false,
		},
		{
			name: "Enabled returns error - tool excluded",
			enabledFunc: func(_ context.Context) (bool, error) {
				return false, fmt.Errorf("simulated error")
			},
			expectedCount:  0,
			expectInResult: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tool := mockTool("test_tool", "toolset1", true)
			tool.Enabled = tt.enabledFunc

			reg := mustBuild(t, NewBuilder().SetTools([]ServerTool{tool}).WithToolsets([]string{"all"}))
			available := reg.AvailableTools(context.Background())

			if len(available) != tt.expectedCount {
				t.Errorf("Expected %d tools, got %d", tt.expectedCount, len(available))
			}

			found := false
			for _, t := range available {
				if t.Tool.Name == "test_tool" {
					found = true
					break
				}
			}
			if found != tt.expectInResult {
				t.Errorf("Expected tool in result: %v, got: %v", tt.expectInResult, found)
			}
		})
	}
}

func TestServerToolEnabledWithContext(t *testing.T) {
	type contextKey string
	const userKey contextKey = "user"

	// Tool that checks context for user
	tool := mockTool("context_aware_tool", "toolset1", true)
	tool.Enabled = func(ctx context.Context) (bool, error) {
		user := ctx.Value(userKey)
		return user != nil && user.(string) == "authorized", nil
	}

	reg := mustBuild(t, NewBuilder().SetTools([]ServerTool{tool}).WithToolsets([]string{"all"}))

	// Without user in context - tool should be excluded
	available := reg.AvailableTools(context.Background())
	if len(available) != 0 {
		t.Errorf("Expected 0 tools without user, got %d", len(available))
	}

	// With authorized user - tool should be included
	ctxWithUser := context.WithValue(context.Background(), userKey, "authorized")
	availableWithUser := reg.AvailableTools(ctxWithUser)
	if len(availableWithUser) != 1 {
		t.Errorf("Expected 1 tool with authorized user, got %d", len(availableWithUser))
	}

	// With unauthorized user - tool should be excluded
	ctxWithBadUser := context.WithValue(context.Background(), userKey, "unauthorized")
	availableWithBadUser := reg.AvailableTools(ctxWithBadUser)
	if len(availableWithBadUser) != 0 {
		t.Errorf("Expected 0 tools with unauthorized user, got %d", len(availableWithBadUser))
	}
}

// Tests for WithFilter builder method
func TestBuilderWithFilter(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset1", true),
		mockTool("tool3", "toolset1", true),
	}

	// Filter that excludes tool2
	filter := func(_ context.Context, tool *ServerTool) (bool, error) {
		return tool.Tool.Name != "tool2", nil
	}

	reg := mustBuild(t, NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}).
		WithFilter(filter))

	available := reg.AvailableTools(context.Background())
	if len(available) != 2 {
		t.Fatalf("Expected 2 tools after filter, got %d", len(available))
	}

	for _, tool := range available {
		if tool.Tool.Name == "tool2" {
			t.Error("tool2 should have been filtered out")
		}
	}
}

func TestBuilderWithMultipleFilters(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset1", true),
		mockTool("tool3", "toolset1", true),
		mockTool("tool4", "toolset1", true),
	}

	// First filter excludes tool2
	filter1 := func(_ context.Context, tool *ServerTool) (bool, error) {
		return tool.Tool.Name != "tool2", nil
	}

	// Second filter excludes tool3
	filter2 := func(_ context.Context, tool *ServerTool) (bool, error) {
		return tool.Tool.Name != "tool3", nil
	}

	reg := mustBuild(t, NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}).
		WithFilter(filter1).
		WithFilter(filter2))

	available := reg.AvailableTools(context.Background())
	if len(available) != 2 {
		t.Fatalf("Expected 2 tools after multiple filters, got %d", len(available))
	}

	toolNames := make(map[string]bool)
	for _, tool := range available {
		toolNames[tool.Tool.Name] = true
	}

	if !toolNames["tool1"] || !toolNames["tool4"] {
		t.Error("Expected tool1 and tool4 to be available")
	}
	if toolNames["tool2"] || toolNames["tool3"] {
		t.Error("tool2 and tool3 should have been filtered out")
	}
}

func TestBuilderFilterError(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
	}

	// Filter that returns an error
	filter := func(_ context.Context, _ *ServerTool) (bool, error) {
		return false, fmt.Errorf("filter error")
	}

	reg := mustBuild(t, NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}).
		WithFilter(filter))

	available := reg.AvailableTools(context.Background())
	if len(available) != 0 {
		t.Errorf("Expected 0 tools when filter returns error, got %d", len(available))
	}
}

func TestBuilderFilterWithContext(t *testing.T) {
	type contextKey string
	const scopeKey contextKey = "scope"

	tools := []ServerTool{
		mockTool("public_tool", "toolset1", true),
		mockTool("private_tool", "toolset1", true),
	}

	// Filter that checks context for scope
	filter := func(ctx context.Context, tool *ServerTool) (bool, error) {
		scope := ctx.Value(scopeKey)
		if scope == "public" && tool.Tool.Name == "private_tool" {
			return false, nil
		}
		return true, nil
	}

	reg := mustBuild(t, NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}).
		WithFilter(filter))

	// With public scope - private_tool should be excluded
	ctxPublic := context.WithValue(context.Background(), scopeKey, "public")
	availablePublic := reg.AvailableTools(ctxPublic)
	if len(availablePublic) != 1 {
		t.Fatalf("Expected 1 tool with public scope, got %d", len(availablePublic))
	}
	if availablePublic[0].Tool.Name != "public_tool" {
		t.Error("Expected only public_tool to be available")
	}

	// With private scope - both tools should be available
	ctxPrivate := context.WithValue(context.Background(), scopeKey, "private")
	availablePrivate := reg.AvailableTools(ctxPrivate)
	if len(availablePrivate) != 2 {
		t.Errorf("Expected 2 tools with private scope, got %d", len(availablePrivate))
	}
}

// Tests for interaction between Enabled, feature flags, and filters
func TestEnabledAndFeatureFlagInteraction(t *testing.T) {
	// Tool with both Enabled function and feature flag
	tool := mockToolWithFlags("complex_tool", "toolset1", true, "my_feature", "")
	tool.Enabled = func(_ context.Context) (bool, error) {
		return true, nil
	}

	// Feature flag not enabled - tool should be excluded despite Enabled returning true
	reg1 := mustBuild(t, NewBuilder().
		SetTools([]ServerTool{tool}).
		WithToolsets([]string{"all"}))
	available1 := reg1.AvailableTools(context.Background())
	if len(available1) != 0 {
		t.Error("Tool should be excluded when feature flag is not enabled")
	}

	// Feature flag enabled - tool should be included
	checker := func(_ context.Context, flag string) (bool, error) {
		return flag == "my_feature", nil
	}
	reg2 := mustBuild(t, NewBuilder().
		SetTools([]ServerTool{tool}).
		WithToolsets([]string{"all"}).
		WithFeatureChecker(checker))
	available2 := reg2.AvailableTools(context.Background())
	if len(available2) != 1 {
		t.Error("Tool should be included when both Enabled and feature flag pass")
	}

	// Enabled returns false - tool should be excluded despite feature flag
	tool.Enabled = func(_ context.Context) (bool, error) {
		return false, nil
	}
	reg3 := mustBuild(t, NewBuilder().
		SetTools([]ServerTool{tool}).
		WithToolsets([]string{"all"}).
		WithFeatureChecker(checker))
	available3 := reg3.AvailableTools(context.Background())
	if len(available3) != 0 {
		t.Error("Tool should be excluded when Enabled returns false")
	}
}

func TestEnabledAndBuilderFilterInteraction(t *testing.T) {
	tool := mockTool("test_tool", "toolset1", true)
	tool.Enabled = func(_ context.Context) (bool, error) {
		return true, nil
	}

	// Filter that excludes the tool
	filter := func(_ context.Context, _ *ServerTool) (bool, error) {
		return false, nil
	}

	reg := mustBuild(t, NewBuilder().
		SetTools([]ServerTool{tool}).
		WithToolsets([]string{"all"}).
		WithFilter(filter))

	available := reg.AvailableTools(context.Background())
	if len(available) != 0 {
		t.Error("Tool should be excluded when filter returns false, despite Enabled returning true")
	}
}

func TestAllFiltersInteraction(t *testing.T) {
	// Tool with Enabled, feature flag, and subject to builder filter
	tool := mockToolWithFlags("complex_tool", "toolset1", true, "my_feature", "")
	tool.Enabled = func(_ context.Context) (bool, error) {
		return true, nil
	}

	filter := func(_ context.Context, _ *ServerTool) (bool, error) {
		return true, nil
	}

	checker := func(_ context.Context, flag string) (bool, error) {
		return flag == "my_feature", nil
	}

	// All conditions pass - tool should be included
	reg := mustBuild(t, NewBuilder().
		SetTools([]ServerTool{tool}).
		WithToolsets([]string{"all"}).
		WithFeatureChecker(checker).
		WithFilter(filter))

	available := reg.AvailableTools(context.Background())
	if len(available) != 1 {
		t.Error("Tool should be included when all filters pass")
	}

	// Change filter to return false - tool should be excluded
	filterFalse := func(_ context.Context, _ *ServerTool) (bool, error) {
		return false, nil
	}

	reg2 := mustBuild(t, NewBuilder().
		SetTools([]ServerTool{tool}).
		WithToolsets([]string{"all"}).
		WithFeatureChecker(checker).
		WithFilter(filterFalse))

	available2 := reg2.AvailableTools(context.Background())
	if len(available2) != 0 {
		t.Error("Tool should be excluded when any filter fails")
	}
}

// Test FilteredTools method
func TestFilteredTools(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset1", true),
	}

	filter := func(_ context.Context, tool *ServerTool) (bool, error) {
		return tool.Tool.Name == "tool1", nil
	}

	reg := mustBuild(t, NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}).
		WithFilter(filter))

	filtered, err := reg.FilteredTools(context.Background())
	if err != nil {
		t.Fatalf("FilteredTools returned error: %v", err)
	}

	if len(filtered) != 1 {
		t.Fatalf("Expected 1 filtered tool, got %d", len(filtered))
	}

	if filtered[0].Tool.Name != "tool1" {
		t.Errorf("Expected tool1, got %s", filtered[0].Tool.Name)
	}
}

func TestFilteredToolsMatchesAvailableTools(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset1", false),
		mockTool("tool3", "toolset2", true),
	}

	reg := mustBuild(t, NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"toolset1"}).
		WithReadOnly(true))

	ctx := context.Background()
	filtered, err := reg.FilteredTools(ctx)
	if err != nil {
		t.Fatalf("FilteredTools returned error: %v", err)
	}

	available := reg.AvailableTools(ctx)

	// Both methods should return the same results
	if len(filtered) != len(available) {
		t.Errorf("FilteredTools and AvailableTools returned different counts: %d vs %d",
			len(filtered), len(available))
	}

	for i := range filtered {
		if filtered[i].Tool.Name != available[i].Tool.Name {
			t.Errorf("Tool at index %d differs: FilteredTools=%s, AvailableTools=%s",
				i, filtered[i].Tool.Name, available[i].Tool.Name)
		}
	}
}

func TestFilteringOrder(t *testing.T) {
	// Test that filters are applied in the correct order:
	// 1. Tool.Enabled
	// 2. Feature flags
	// 3. Read-only
	// 4. Builder filters
	// 5. Toolset/additional tools

	callOrder := []string{}

	tool := mockToolWithFlags("test_tool", "toolset1", false, "my_feature", "")
	tool.Enabled = func(_ context.Context) (bool, error) {
		callOrder = append(callOrder, "Enabled")
		return true, nil
	}

	filter := func(_ context.Context, _ *ServerTool) (bool, error) {
		callOrder = append(callOrder, "Filter")
		return true, nil
	}

	checker := func(_ context.Context, _ string) (bool, error) {
		callOrder = append(callOrder, "FeatureFlag")
		return true, nil
	}

	reg := mustBuild(t, NewBuilder().
		SetTools([]ServerTool{tool}).
		WithToolsets([]string{"all"}).
		WithReadOnly(true). // This will exclude the tool (it's not read-only)
		WithFeatureChecker(checker).
		WithFilter(filter))

	_ = reg.AvailableTools(context.Background())

	// Expected order: Enabled, FeatureFlag, ReadOnly (stops here because it's write tool)
	expectedOrder := []string{"Enabled", "FeatureFlag"}
	if len(callOrder) != len(expectedOrder) {
		t.Errorf("Expected %d checks, got %d: %v", len(expectedOrder), len(callOrder), callOrder)
	}

	for i, expected := range expectedOrder {
		if i >= len(callOrder) || callOrder[i] != expected {
			t.Errorf("At position %d: expected %s, got %v", i, expected, callOrder)
		}
	}
}

func TestForMCPRequest_ToolsCall_FeatureFlaggedVariants(t *testing.T) {
	// Simulate the get_job_logs scenario: two tools with the same name but different feature flags
	// - "get_job_logs" with FeatureFlagDisable (available when flag is OFF)
	// - "get_job_logs" with FeatureFlagEnable (available when flag is ON)
	tools := []ServerTool{
		mockToolWithFlags("get_job_logs", "actions", true, "", "consolidated_flag"), // disabled when flag is ON
		mockToolWithFlags("get_job_logs", "actions", true, "consolidated_flag", ""), // enabled when flag is ON
		mockTool("other_tool", "actions", true),
	}

	// Test 1: Flag is OFF - first tool variant should be available
	regFlagOff := mustBuild(t, NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}))
	filteredOff := regFlagOff.ForMCPRequest(MCPMethodToolsCall, "get_job_logs")
	availableOff := filteredOff.AvailableTools(context.Background())
	if len(availableOff) != 1 {
		t.Fatalf("Flag OFF: Expected 1 tool, got %d", len(availableOff))
	}
	if availableOff[0].FeatureFlagDisable != "consolidated_flag" {
		t.Errorf("Flag OFF: Expected tool with FeatureFlagDisable, got FeatureFlagEnable=%q, FeatureFlagDisable=%q",
			availableOff[0].FeatureFlagEnable, availableOff[0].FeatureFlagDisable)
	}

	// Test 2: Flag is ON - second tool variant should be available
	checker := func(_ context.Context, flag string) (bool, error) {
		return flag == "consolidated_flag", nil
	}
	regFlagOn := mustBuild(t, NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}).
		WithFeatureChecker(checker))
	filteredOn := regFlagOn.ForMCPRequest(MCPMethodToolsCall, "get_job_logs")
	availableOn := filteredOn.AvailableTools(context.Background())
	if len(availableOn) != 1 {
		t.Fatalf("Flag ON: Expected 1 tool, got %d", len(availableOn))
	}
	if availableOn[0].FeatureFlagEnable != "consolidated_flag" {
		t.Errorf("Flag ON: Expected tool with FeatureFlagEnable, got FeatureFlagEnable=%q, FeatureFlagDisable=%q",
			availableOn[0].FeatureFlagEnable, availableOn[0].FeatureFlagDisable)
	}
}

// TestWithTools_DeprecatedAliasAndFeatureFlag tests that deprecated aliases work correctly
// when the old tool is controlled by a feature flag. This covers the scenario where:
// - Old tool "old_tool" has FeatureFlagDisable="my_flag" (available when flag is OFF)
// - New tool "new_tool" has FeatureFlagEnable="my_flag" (available when flag is ON)
// - Deprecated alias maps "old_tool" -> "new_tool"
// - User specifies --tools=old_tool
// Expected behavior:
// - Flag OFF: old_tool should be available (not the new_tool via alias)
// - Flag ON: new_tool should be available (via alias resolution)
func TestWithTools_DeprecatedAliasAndFeatureFlag(t *testing.T) {
	oldTool := mockToolWithFlags("old_tool", "actions", true, "", "my_flag")
	newTool := mockToolWithFlags("new_tool", "actions", true, "my_flag", "")
	tools := []ServerTool{oldTool, newTool}

	deprecatedAliases := map[string]string{
		"old_tool": "new_tool",
	}

	// Test 1: Flag OFF - old_tool should be available via direct name match
	// (not via alias resolution to new_tool, since old_tool still exists)
	regFlagOff := mustBuild(t, NewBuilder().
		SetTools(tools).
		WithDeprecatedAliases(deprecatedAliases).
		WithToolsets([]string{}).        // No toolsets enabled
		WithTools([]string{"old_tool"})) // Explicitly request old tool
	availableOff := regFlagOff.AvailableTools(context.Background())
	if len(availableOff) != 1 {
		t.Fatalf("Flag OFF: Expected 1 tool, got %d", len(availableOff))
	}
	if availableOff[0].Tool.Name != "old_tool" {
		t.Errorf("Flag OFF: Expected old_tool, got %s", availableOff[0].Tool.Name)
	}

	// Test 2: Flag ON - new_tool should be available via alias resolution
	checker := func(_ context.Context, flag string) (bool, error) {
		return flag == "my_flag", nil
	}
	regFlagOn := mustBuild(t, NewBuilder().
		SetTools(tools).
		WithDeprecatedAliases(deprecatedAliases).
		WithToolsets([]string{}).        // No toolsets enabled
		WithTools([]string{"old_tool"}). // Request old tool name
		WithFeatureChecker(checker))
	availableOn := regFlagOn.AvailableTools(context.Background())
	if len(availableOn) != 1 {
		t.Fatalf("Flag ON: Expected 1 tool, got %d", len(availableOn))
	}
	if availableOn[0].Tool.Name != "new_tool" {
		t.Errorf("Flag ON: Expected new_tool (via alias), got %s", availableOn[0].Tool.Name)
	}
}

// mockToolWithMeta creates a ServerTool with Meta for testing insiders mode
func mockToolWithMeta(name string, toolsetID string, meta map[string]any) ServerTool {
	return NewServerToolFromHandler(
		mcp.Tool{
			Name: name,
			Annotations: &mcp.ToolAnnotations{
				ReadOnlyHint: true,
			},
			InputSchema: json.RawMessage(`{"type":"object","properties":{}}`),
			Meta:        meta,
		},
		testToolsetMetadata(toolsetID),
		func(_ any) mcp.ToolHandler {
			return func(_ context.Context, _ *mcp.CallToolRequest) (*mcp.CallToolResult, error) {
				return nil, nil
			}
		},
	)
}

func TestWithInsidersMode_DisabledStripsUIMetadata(t *testing.T) {
	toolWithUI := mockToolWithMeta("tool_with_ui", "toolset1", map[string]any{
		"ui":          map[string]any{"html": "<div>hello</div>"},
		"description": "kept",
	})

	// Default: insiders mode is disabled - UI meta should be stripped
	reg := mustBuild(t, NewBuilder().SetTools([]ServerTool{toolWithUI}).WithToolsets([]string{"all"}))
	available := reg.AvailableTools(context.Background())

	require.Len(t, available, 1)
	// UI metadata should be stripped
	if available[0].Tool.Meta["ui"] != nil {
		t.Errorf("Expected 'ui' meta to be stripped, but it was present")
	}
	// Other metadata should be preserved
	if available[0].Tool.Meta["description"] != "kept" {
		t.Errorf("Expected 'description' meta to be preserved, got %v", available[0].Tool.Meta["description"])
	}
}

func TestWithInsidersMode_EnabledPreservesUIMetadata(t *testing.T) {
	uiData := map[string]any{"html": "<div>hello</div>"}
	toolWithUI := mockToolWithMeta("tool_with_ui", "toolset1", map[string]any{
		"ui":          uiData,
		"description": "kept",
	})

	// Insiders mode enabled - UI meta should be preserved
	reg := mustBuild(t, NewBuilder().
		SetTools([]ServerTool{toolWithUI}).
		WithToolsets([]string{"all"}).
		WithInsidersMode(true))
	available := reg.AvailableTools(context.Background())

	require.Len(t, available, 1)
	// UI metadata should be preserved
	if available[0].Tool.Meta["ui"] == nil {
		t.Errorf("Expected 'ui' meta to be preserved in insiders mode")
	}
	// Other metadata should also be preserved
	if available[0].Tool.Meta["description"] != "kept" {
		t.Errorf("Expected 'description' meta to be preserved, got %v", available[0].Tool.Meta["description"])
	}
}

func TestWithInsidersMode_EnabledPreservesInsidersOnlyTools(t *testing.T) {
	normalTool := mockTool("normal", "toolset1", true)
	insidersTool := mockTool("insiders_only", "toolset1", true)
	insidersTool.InsidersOnly = true

	// With insiders mode enabled, both tools should be available
	reg := mustBuild(t, NewBuilder().
		SetTools([]ServerTool{normalTool, insidersTool}).
		WithToolsets([]string{"all"}).
		WithInsidersMode(true))
	available := reg.AvailableTools(context.Background())

	require.Len(t, available, 2)
	names := []string{available[0].Tool.Name, available[1].Tool.Name}
	require.Contains(t, names, "normal")
	require.Contains(t, names, "insiders_only")
}

func TestWithInsidersMode_DisabledRemovesInsidersOnlyTools(t *testing.T) {
	normalTool := mockTool("normal", "toolset1", true)
	insidersTool := mockTool("insiders_only", "toolset1", true)
	insidersTool.InsidersOnly = true

	// With insiders mode disabled, insiders-only tool should be removed
	reg := mustBuild(t, NewBuilder().
		SetTools([]ServerTool{normalTool, insidersTool}).
		WithToolsets([]string{"all"}).
		WithInsidersMode(false))
	available := reg.AvailableTools(context.Background())

	require.Len(t, available, 1)
	require.Equal(t, "normal", available[0].Tool.Name)
}

func TestWithInsidersMode_ToolsWithoutUIMetaUnaffected(t *testing.T) {
	toolNoUI := mockToolWithMeta("tool_no_ui", "toolset1", map[string]any{
		"description": "kept",
		"version":     "1.0",
	})
	toolNilMeta := mockTool("tool_nil_meta", "toolset1", true)

	// Test with insiders disabled
	reg := mustBuild(t, NewBuilder().
		SetTools([]ServerTool{toolNoUI, toolNilMeta}).
		WithToolsets([]string{"all"}))
	available := reg.AvailableTools(context.Background())

	require.Len(t, available, 2)

	// Find toolNoUI
	var foundNoUI, foundNilMeta *ServerTool
	for i := range available {
		switch available[i].Tool.Name {
		case "tool_no_ui":
			foundNoUI = &available[i]
		case "tool_nil_meta":
			foundNilMeta = &available[i]
		}
	}

	require.NotNil(t, foundNoUI)
	require.NotNil(t, foundNilMeta)

	// toolNoUI should have its metadata preserved
	if foundNoUI.Tool.Meta["description"] != "kept" || foundNoUI.Tool.Meta["version"] != "1.0" {
		t.Errorf("Expected toolNoUI meta to be unchanged, got %v", foundNoUI.Tool.Meta)
	}

	// toolNilMeta should still have nil meta
	if foundNilMeta.Tool.Meta != nil {
		t.Errorf("Expected toolNilMeta to have nil meta, got %v", foundNilMeta.Tool.Meta)
	}
}

func TestWithInsidersMode_UIOnlyMetaBecomesNil(t *testing.T) {
	// Tool with ONLY ui metadata - should become nil after stripping
	toolUIOnly := mockToolWithMeta("tool_ui_only", "toolset1", map[string]any{
		"ui": map[string]any{"html": "<div>hello</div>"},
	})

	reg := mustBuild(t, NewBuilder().
		SetTools([]ServerTool{toolUIOnly}).
		WithToolsets([]string{"all"}))
	available := reg.AvailableTools(context.Background())

	require.Len(t, available, 1)
	// Meta should be nil since ui was the only key
	if available[0].Tool.Meta != nil {
		t.Errorf("Expected Meta to be nil after stripping only key, got %v", available[0].Tool.Meta)
	}
}

func TestStripInsidersMetaFromTool(t *testing.T) {
	tests := []struct {
		name         string
		meta         map[string]any
		expectChange bool
		expectedMeta map[string]any // nil means Meta should be nil
	}{
		{
			name:         "nil meta - no change",
			meta:         nil,
			expectChange: false,
		},
		{
			name:         "no insiders keys - no change",
			meta:         map[string]any{"description": "test", "version": "1.0"},
			expectChange: false,
		},
		{
			name:         "ui key only - becomes nil",
			meta:         map[string]any{"ui": "data"},
			expectChange: true,
			expectedMeta: nil,
		},
		{
			name:         "ui key with other keys - ui stripped",
			meta:         map[string]any{"ui": "data", "description": "kept"},
			expectChange: true,
			expectedMeta: map[string]any{"description": "kept"},
		},
		{
			name:         "ui is nil value - no change (nil value means key not present)",
			meta:         map[string]any{"ui": nil, "description": "kept"},
			expectChange: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tool := mockToolWithMeta("test", "toolset1", tt.meta)
			result := stripInsidersMetaFromTool(tool)

			if tt.expectChange {
				require.NotNil(t, result, "expected change but got nil")
				if tt.expectedMeta == nil {
					require.Nil(t, result.Tool.Meta, "expected Meta to be nil")
				} else {
					// Compare values by key since types may differ (map[string]any vs mcp.Meta)
					for k, v := range tt.expectedMeta {
						require.Equal(t, v, result.Tool.Meta[k], "key %s should match", k)
					}
					require.Len(t, result.Tool.Meta, len(tt.expectedMeta))
				}
			} else {
				require.Nil(t, result, "expected no change but got result")
			}
		})
	}
}

func TestStripInsidersFeatures(t *testing.T) {
	tools := []ServerTool{
		mockToolWithMeta("tool1", "toolset1", map[string]any{"ui": "data"}),
		mockToolWithMeta("tool2", "toolset1", map[string]any{"description": "kept"}),
		mockTool("tool3", "toolset1", true), // nil meta
	}

	result := stripInsidersFeatures(tools)

	require.Len(t, result, 3)

	// tool1: ui should be stripped, meta becomes nil
	require.Nil(t, result[0].Tool.Meta, "tool1 meta should be nil after stripping ui")

	// tool2: unchanged (compare by key since types differ)
	require.Equal(t, "kept", result[1].Tool.Meta["description"])
	require.Len(t, result[1].Tool.Meta, 1)

	// tool3: unchanged (nil)
	require.Nil(t, result[2].Tool.Meta)
}

func TestStripInsidersFeatures_RemovesInsidersOnlyTools(t *testing.T) {
	// Create tools: one normal, one insiders-only, one normal
	normalTool1 := mockTool("normal1", "toolset1", true)
	insidersTool := mockTool("insiders_only", "toolset1", true)
	insidersTool.InsidersOnly = true
	normalTool2 := mockTool("normal2", "toolset1", true)

	tools := []ServerTool{normalTool1, insidersTool, normalTool2}

	result := stripInsidersFeatures(tools)

	// Should only have 2 tools (insiders-only tool filtered out)
	require.Len(t, result, 2)
	require.Equal(t, "normal1", result[0].Tool.Name)
	require.Equal(t, "normal2", result[1].Tool.Name)
}

func TestInsidersOnlyMetaKeys_FutureAdditions(t *testing.T) {
	// This test verifies the mechanism works for multiple keys
	// If we add new experimental keys to insidersOnlyMetaKeys, they should be stripped

	// Save original and restore after test
	originalKeys := insidersOnlyMetaKeys
	defer func() { insidersOnlyMetaKeys = originalKeys }()

	// Add a hypothetical future experimental key
	insidersOnlyMetaKeys = []string{"ui", "experimental_feature", "beta"}

	tool := mockToolWithMeta("test", "toolset1", map[string]any{
		"ui":                   "ui data",
		"experimental_feature": "exp data",
		"beta":                 "beta data",
		"description":          "kept",
	})

	result := stripInsidersMetaFromTool(tool)

	require.NotNil(t, result)
	require.NotNil(t, result.Tool.Meta)
	require.Nil(t, result.Tool.Meta["ui"], "ui should be stripped")
	require.Nil(t, result.Tool.Meta["experimental_feature"], "experimental_feature should be stripped")
	require.Nil(t, result.Tool.Meta["beta"], "beta should be stripped")
	require.Equal(t, "kept", result.Tool.Meta["description"], "description should be preserved")
}

func TestWithInsidersMode_DoesNotMutateOriginalTools(t *testing.T) {
	originalMeta := map[string]any{"ui": "data", "description": "kept"}
	tool := mockToolWithMeta("test", "toolset1", originalMeta)
	tools := []ServerTool{tool}

	// Build with insiders disabled - should strip ui
	_ = mustBuild(t, NewBuilder().SetTools(tools).WithToolsets([]string{"all"}))

	// Original tool should be unchanged
	require.Equal(t, "data", tools[0].Tool.Meta["ui"], "original tool should not be mutated")
	require.Equal(t, "kept", tools[0].Tool.Meta["description"], "original tool should not be mutated")
}

func TestWithExcludeTools(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset1", true),
		mockTool("tool3", "toolset2", true),
	}

	tests := []struct {
		name            string
		excluded        []string
		toolsets        []string
		expectedNames   []string
		unexpectedNames []string
	}{
		{
			name:            "single tool excluded",
			excluded:        []string{"tool2"},
			toolsets:        []string{"all"},
			expectedNames:   []string{"tool1", "tool3"},
			unexpectedNames: []string{"tool2"},
		},
		{
			name:            "multiple tools excluded",
			excluded:        []string{"tool1", "tool3"},
			toolsets:        []string{"all"},
			expectedNames:   []string{"tool2"},
			unexpectedNames: []string{"tool1", "tool3"},
		},
		{
			name:            "empty excluded list is a no-op",
			excluded:        []string{},
			toolsets:        []string{"all"},
			expectedNames:   []string{"tool1", "tool2", "tool3"},
			unexpectedNames: nil,
		},
		{
			name:            "nil excluded list is a no-op",
			excluded:        nil,
			toolsets:        []string{"all"},
			expectedNames:   []string{"tool1", "tool2", "tool3"},
			unexpectedNames: nil,
		},
		{
			name:            "excluding non-existent tool is a no-op",
			excluded:        []string{"nonexistent"},
			toolsets:        []string{"all"},
			expectedNames:   []string{"tool1", "tool2", "tool3"},
			unexpectedNames: nil,
		},
		{
			name:            "exclude all tools",
			excluded:        []string{"tool1", "tool2", "tool3"},
			toolsets:        []string{"all"},
			expectedNames:   nil,
			unexpectedNames: []string{"tool1", "tool2", "tool3"},
		},
		{
			name:            "whitespace is trimmed",
			excluded:        []string{" tool2 ", "  tool3  "},
			toolsets:        []string{"all"},
			expectedNames:   []string{"tool1"},
			unexpectedNames: []string{"tool2", "tool3"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			reg := mustBuild(t, NewBuilder().
				SetTools(tools).
				WithToolsets(tt.toolsets).
				WithExcludeTools(tt.excluded))

			available := reg.AvailableTools(context.Background())
			names := make(map[string]bool)
			for _, tool := range available {
				names[tool.Tool.Name] = true
			}

			for _, expected := range tt.expectedNames {
				require.True(t, names[expected], "tool %q should be available", expected)
			}
			for _, unexpected := range tt.unexpectedNames {
				require.False(t, names[unexpected], "tool %q should be excluded", unexpected)
			}
		})
	}
}

func TestWithExcludeTools_OverridesAdditionalTools(t *testing.T) {
	tools := []ServerTool{
		mockTool("tool1", "toolset1", true),
		mockTool("tool2", "toolset1", true),
		mockTool("tool3", "toolset2", true),
	}

	// tool3 is explicitly enabled via WithTools, but also excluded
	// excluded should win because builder filters run before additional tools check
	reg := mustBuild(t, NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"toolset1"}).
		WithTools([]string{"tool3"}).
		WithExcludeTools([]string{"tool3"}))

	available := reg.AvailableTools(context.Background())
	names := make(map[string]bool)
	for _, tool := range available {
		names[tool.Tool.Name] = true
	}

	require.True(t, names["tool1"], "tool1 should be available")
	require.True(t, names["tool2"], "tool2 should be available")
	require.False(t, names["tool3"], "tool3 should be excluded even though explicitly added via WithTools")
}

func TestWithExcludeTools_CombinesWithReadOnly(t *testing.T) {
	tools := []ServerTool{
		mockTool("read_tool", "toolset1", true),
		mockTool("write_tool", "toolset1", false),
		mockTool("another_read", "toolset1", true),
	}

	// read-only excludes write_tool, exclude-tools excludes read_tool
	reg := mustBuild(t, NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}).
		WithReadOnly(true).
		WithExcludeTools([]string{"read_tool"}))

	available := reg.AvailableTools(context.Background())
	require.Len(t, available, 1)
	require.Equal(t, "another_read", available[0].Tool.Name)
}

func TestCreateExcludeToolsFilter(t *testing.T) {
	filter := CreateExcludeToolsFilter([]string{"blocked_tool"})

	blockedTool := mockTool("blocked_tool", "toolset1", true)
	allowedTool := mockTool("allowed_tool", "toolset1", true)

	allowed, err := filter(context.Background(), &blockedTool)
	require.NoError(t, err)
	require.False(t, allowed, "blocked_tool should be excluded")

	allowed, err = filter(context.Background(), &allowedTool)
	require.NoError(t, err)
	require.True(t, allowed, "allowed_tool should be included")
}