registry_test.go

package inventory

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

	"github.com/modelcontextprotocol/go-sdk/mcp"
)

// 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 := NewBuilder().Build()
	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 := NewBuilder().SetTools(tools).Build()

	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithReadOnly(true).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"toolset1", "toolset3"}).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{" toolset1 ", "  toolset2  "}).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"toolset1", "toolset1", " toolset1 "}).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"", "toolset1", "  ", ""}).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets(tt.input).Build()
			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 TestUnrecognizedTools(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
		expectedUnrecognized []string
	}{
		{
			name:                 "all valid",
			withTools:            []string{"tool1", "tool2"},
			expectedUnrecognized: nil,
		},
		{
			name:                 "one invalid",
			withTools:            []string{"tool1", "blabla"},
			expectedUnrecognized: []string{"blabla"},
		},
		{
			name:                 "multiple invalid",
			withTools:            []string{"invalid1", "tool1", "invalid2"},
			expectedUnrecognized: []string{"invalid1", "invalid2"},
		},
		{
			name:                 "deprecated alias is valid",
			withTools:            []string{"old_tool"},
			expectedUnrecognized: nil,
		},
		{
			name:                 "mixed valid and deprecated alias",
			withTools:            []string{"old_tool", "tool2"},
			expectedUnrecognized: nil,
		},
		{
			name:                 "empty input",
			withTools:            []string{},
			expectedUnrecognized: nil,
		},
	}

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

			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 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 := NewBuilder().SetTools(tools).WithToolsets([]string{}).WithTools([]string{"tool1", "tool3"}).Build()
	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 := NewBuilder().SetTools(tools).WithReadOnly(true).WithToolsets([]string{"toolset1"}).Build()
	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 := NewBuilder().SetTools(tools).Build()
	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 := NewBuilder().SetTools(tools).Build()
	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 := NewBuilder().SetTools(tools).Build()
	toolset1Tools := reg.ToolsForToolset("toolset1")

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

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

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

	// 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 := NewBuilder().SetTools(tools).
		WithDeprecatedAliases(map[string]string{
			"get_issue": "issue_read",
		}).Build()

	// 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 := NewBuilder().SetTools(tools).Build()

	// 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 := NewBuilder().SetTools(tools).WithToolsets([]string{"toolset2"}).WithTools([]string{"issue_read"}).Build()

	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 := NewBuilder().SetTools(tools).WithReadOnly(true).WithTools([]string{"issue_write"}).Build()
	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 not error, just won't match anything)
	nonexistent := NewBuilder().SetTools(tools).WithToolsets([]string{}).WithTools([]string{"nonexistent"}).Build()
	available = nonexistent.AvailableTools(context.Background())
	if len(available) != 0 {
		t.Errorf("expected 0 tools for non-existent additional tool, got %d", len(available))
	}
}

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

	// Using deprecated alias should resolve to canonical name
	filtered := NewBuilder().SetTools(tools).
		WithDeprecatedAliases(map[string]string{
			"get_issue": "issue_read",
		}).
		WithToolsets([]string{}).
		WithTools([]string{"get_issue"}).
		Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).Build()

	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).Build()
	ids := reg.EnabledToolsetIDs()
	if len(ids) != 2 {
		t.Fatalf("Expected 2 enabled toolset IDs, got %d", len(ids))
	}

	// With filter
	filtered := NewBuilder().SetTools(tools).WithToolsets([]string{"toolset1"}).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithReadOnly(true).Build()

	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 := NewBuilder().SetTools(tools).SetResources(resources).SetPrompts(prompts).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetTools(tools).SetResources(resources).SetPrompts(prompts).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetTools(tools).
		WithToolsets([]string{"all"}).
		WithDeprecatedAliases(map[string]string{
			"old_get_me": "get_me",
		}).Build()

	// 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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithReadOnly(true).Build()
	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_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 := NewBuilder().SetTools(tools).SetResources(resources).SetPrompts(prompts).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetResources(resources).WithToolsets([]string{"all"}).Build()
	filtered := reg.ForMCPRequest(MCPMethodResourcesRead, "repo://{owner}/{repo}")

	available := filtered.AvailableResourceTemplates(context.Background())
	if len(available) != 1 {
		t.Fatalf("Expected 1 resource for resources/read, got %d", len(available))
	}
	if available[0].Template.URITemplate != "repo://{owner}/{repo}" {
		t.Errorf("Expected URI template 'repo://{owner}/{repo}', got %q", available[0].Template.URITemplate)
	}
}

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 := NewBuilder().SetTools(tools).SetResources(resources).SetPrompts(prompts).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetPrompts(prompts).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetTools(tools).SetResources(resources).SetPrompts(prompts).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetTools(tools).SetResources(resources).SetPrompts(prompts).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetTools(tools).
		WithToolsets([]string{"default"}).
		WithReadOnly(true).
		Build()
	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 := NewBuilder().SetTools(tools).SetResources(resources).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithFeatureChecker(checkerFalse).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithFeatureChecker(checkerTrue).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithFeatureChecker(checkerTrue).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithFeatureChecker(checker1).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithFeatureChecker(checker2).Build()
	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 := NewBuilder().SetTools(tools).WithToolsets([]string{"all"}).WithFeatureChecker(checker3).Build()
	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 := NewBuilder().SetTools(tools).WithFeatureChecker(checkerError).Build()
	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 := NewBuilder().SetResources(resources).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetResources(resources).WithToolsets([]string{"all"}).WithFeatureChecker(checker).Build()
	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 := NewBuilder().SetPrompts(prompts).WithToolsets([]string{"all"}).Build()
	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 := NewBuilder().SetPrompts(prompts).WithToolsets([]string{"all"}).WithFeatureChecker(checker).Build()
	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 := NewBuilder().SetTools([]ServerTool{tool}).WithToolsets([]string{"all"}).Build()
			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 := NewBuilder().SetTools([]ServerTool{tool}).WithToolsets([]string{"all"}).Build()

	// 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 := NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}).
		WithFilter(filter).
		Build()

	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 := NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}).
		WithFilter(filter1).
		WithFilter(filter2).
		Build()

	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 := NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}).
		WithFilter(filter).
		Build()

	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 := NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}).
		WithFilter(filter).
		Build()

	// 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 := NewBuilder().
		SetTools([]ServerTool{tool}).
		WithToolsets([]string{"all"}).
		Build()
	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 := NewBuilder().
		SetTools([]ServerTool{tool}).
		WithToolsets([]string{"all"}).
		WithFeatureChecker(checker).
		Build()
	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 := NewBuilder().
		SetTools([]ServerTool{tool}).
		WithToolsets([]string{"all"}).
		WithFeatureChecker(checker).
		Build()
	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 := NewBuilder().
		SetTools([]ServerTool{tool}).
		WithToolsets([]string{"all"}).
		WithFilter(filter).
		Build()

	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 := NewBuilder().
		SetTools([]ServerTool{tool}).
		WithToolsets([]string{"all"}).
		WithFeatureChecker(checker).
		WithFilter(filter).
		Build()

	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 := NewBuilder().
		SetTools([]ServerTool{tool}).
		WithToolsets([]string{"all"}).
		WithFeatureChecker(checker).
		WithFilter(filterFalse).
		Build()

	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 := NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}).
		WithFilter(filter).
		Build()

	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 := NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"toolset1"}).
		WithReadOnly(true).
		Build()

	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 := NewBuilder().
		SetTools([]ServerTool{tool}).
		WithToolsets([]string{"all"}).
		WithReadOnly(true). // This will exclude the tool (it's not read-only)
		WithFeatureChecker(checker).
		WithFilter(filter).
		Build()

	_ = 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 := NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}).
		Build()
	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 := NewBuilder().
		SetTools(tools).
		WithToolsets([]string{"all"}).
		WithFeatureChecker(checker).
		Build()
	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 := NewBuilder().
		SetTools(tools).
		WithDeprecatedAliases(deprecatedAliases).
		WithToolsets([]string{}).        // No toolsets enabled
		WithTools([]string{"old_tool"}). // Explicitly request old tool
		Build()
	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 := NewBuilder().
		SetTools(tools).
		WithDeprecatedAliases(deprecatedAliases).
		WithToolsets([]string{}).        // No toolsets enabled
		WithTools([]string{"old_tool"}). // Request old tool name
		WithFeatureChecker(checker).
		Build()
	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)
	}
}