#!/bin/bash
# tests/cli-mode/test-agent-tool-access.sh
# Phase 2 :: Validates agent tool access configuration in CLI mode (Priority 2)

set -euo pipefail

PROJECT_ROOT=$(git rev-parse --show-toplevel)
source "$PROJECT_ROOT/tests/test-utils.sh"

# Test counters - properly validated tests only
PASS_COUNT=0
TOTAL_COUNT=0
FAILED_TESTS=()

pass() { echo "✅ PASS: $1"; PASS_COUNT=$((PASS_COUNT + 1)); TOTAL_COUNT=$((TOTAL_COUNT + 1)); return 0; }
fail() { echo "❌ FAIL: $1"; FAILED_TESTS+=("$1"); TOTAL_COUNT=$((TOTAL_COUNT + 1)); return 0; }

cleanup() {
  log_info "Cleanup complete - smoke test only, no processes spawned"
}
trap cleanup EXIT

test_required_tools_list() {
  log_step "GIVEN required tools for CLI mode agents"

  # WHEN checking tool list definition
  local required_tools=(
    "Bash"
    "Read"
    "Write"
    "Edit"
    "Grep"
    "Glob"
    "Task"
  )

  # THEN verify each tool is documented AND implemented in the codebase
  log_info "Required tools for CLI mode agents (7 tools):"
  local tools_documented=0
  local tools_implemented=0

  for tool in "${required_tools[@]}"; do
    log_info "  - $tool"
    
    # Validate tool is documented in project documentation
    local documented=false
    if grep -qi "$tool" "$PROJECT_ROOT/CLAUDE.md" 2>/dev/null || \
       grep -qi "$tool" "$PROJECT_ROOT/.claude/agents/cfn-dev-team/README.md" 2>/dev/null; then
      documented=true
      tools_documented=$((tools_documented + 1))
    fi

    # Validate tool is implemented in source code
    local implemented=false
    if find "$PROJECT_ROOT/src" -name "*.ts" -type f -exec grep -l "$tool" {} \; 2>/dev/null | head -1 | grep -q .; then
      implemented=true
      tools_implemented=$((tools_implemented + 1))
    fi

    # Only pass if both documented AND implemented
    if [ "$documented" = true ] && [ "$implemented" = true ]; then
      pass "Tool $tool is documented and implemented"
    else
      fail "Tool $tool incomplete - documented: $documented, implemented: $implemented"
    fi
  done

  # Final validation - ensure all required tools are properly implemented
  if [ "$tools_documented" -eq "${#required_tools[@]}" ] && [ "$tools_implemented" -eq "${#required_tools[@]}" ]; then
    log_info "✅ Required tools list validation passed (all ${#required_tools[@]} tools documented and implemented)"
  else
    log_info "⚠️  Required tools incomplete - documented: $tools_documented/${#required_tools[@]}, implemented: $tools_implemented/${#required_tools[@]}"
  fi
}

test_spawn_agent_tool_config() {
  log_step "GIVEN spawn-agent.sh tool configuration"

  # WHEN checking spawn-agent.sh for tool access setup
  local spawn_agent="$PROJECT_ROOT/.claude/skills/cfn-agent-spawning/spawn-agent.sh"

  # THEN verify spawn-agent.sh exists and is executable
  if [[ -f "$spawn_agent" ]]; then
    pass "spawn-agent.sh exists"
    if [[ -x "$spawn_agent" ]]; then
      pass "spawn-agent.sh is executable"
    else
      fail "spawn-agent.sh is not executable"
    fi
  else
    fail "spawn-agent.sh exists"
    return
  fi

  # Verify specific agent execution patterns are present
  local execution_patterns_found=false
  local tool_access_configured=false

  # Check for agent execution commands
  if grep -q "npx\|claude\|exec\|spawn" "$spawn_agent" 2>/dev/null; then
    execution_patterns_found=true
    pass "spawn-agent.sh contains agent execution commands"
  else
    fail "spawn-agent.sh missing agent execution commands"
  fi

  # Check for tool access configuration (environment variables, parameters)
  if grep -q "tool\|TOOL\|ANTHROPIC_API_KEY\|PROVIDER" "$spawn_agent" 2>/dev/null; then
    tool_access_configured=true
    pass "spawn-agent.sh contains tool access configuration"
  else
    fail "spawn-agent.sh missing tool access configuration"
  fi

  # Verify the script actually handles agent arguments
  if grep -q "\$1\|\$@\|args" "$spawn_agent" 2>/dev/null; then
    pass "spawn-agent.sh handles agent arguments"
  else
    fail "spawn-agent.sh does not handle agent arguments"
  fi

  # Final validation
  if [ "$execution_patterns_found" = true ] && [ "$tool_access_configured" = true ]; then
    log_info "✅ spawn-agent.sh tool configuration validation passed"
  else
    log_info "⚠️  spawn-agent.sh has configuration issues"
  fi
}

test_agent_prompt_builder_tool_access() {
  log_step "GIVEN agent prompt builder tool injection"

  # WHEN checking agent-prompt-builder.ts for tool access
  local prompt_builder="$PROJECT_ROOT/src/cli/agent-prompt-builder.ts"

  # THEN verify prompt builder exists and is readable
  if [[ -f "$prompt_builder" ]]; then
    pass "agent-prompt-builder.ts exists"
    if [[ -r "$prompt_builder" ]]; then
      pass "agent-prompt-builder.ts is readable"
    else
      fail "agent-prompt-builder.ts is not readable"
      return
    fi
  else
    fail "agent-prompt-builder.ts exists"
    return
  fi

  # Verify specific tool access injection logic
  local tool_injection_found=false
  local tool_list_handling=false
  local api_tool_formatting=false

  # Check for tool injection functionality
  if grep -q "tools\|tool.*format\|convertTool" "$prompt_builder" 2>/dev/null; then
    tool_injection_found=true
    pass "agent-prompt-builder.ts contains tool injection logic"
  else
    fail "agent-prompt-builder.ts missing tool injection logic"
  fi

  # Check for tool list/array handling
  if grep -q "\.tools\|tools.*length\|Array.*tool" "$prompt_builder" 2>/dev/null; then
    tool_list_handling=true
    pass "agent-prompt-builder.ts handles tool arrays"
  else
    fail "agent-prompt-builder.ts does not handle tool arrays"
  fi

  # Check for API tool formatting (for Anthropic Claude API)
  if grep -q "anthropic\|claude\|api.*tool" "$prompt_builder" 2>/dev/null; then
    api_tool_formatting=true
    pass "agent-prompt-builder.ts formats tools for API"
  else
    fail "agent-prompt-builder.ts missing API tool formatting"
  fi

  # Verify it's actually TypeScript/valid code
  if node -c "$prompt_builder" 2>/dev/null; then
    pass "agent-prompt-builder.ts has valid TypeScript syntax"
  else
    fail "agent-prompt-builder.ts has syntax errors"
  fi

  # Final validation
  if [ "$tool_injection_found" = true ] && [ "$tool_list_handling" = true ] && [ "$api_tool_formatting" = true ]; then
    log_info "✅ agent-prompt-builder.ts tool access validation passed"
  else
    log_info "⚠️  agent-prompt-builder.ts has incomplete tool access implementation"
  fi
}

test_bash_tool_access() {
  log_step "GIVEN Bash tool access requirement"

  # WHEN checking Bash tool availability
  local tool_name="Bash"

  # THEN verify agents can execute bash commands
  log_info "Validating Bash tool access for coordination and file operations"

  # Check if spawn-agent.sh enables bash execution through shell access
  local spawn_agent_bash_access=false
  if grep -q "bash\|Bash\|sh\|exec\|spawn" "$PROJECT_ROOT/.claude/skills/cfn-agent-spawning/spawn-agent.sh" 2>/dev/null; then
    spawn_agent_bash_access=true
  fi
  
  # Verify coordination scripts actually use bash commands
  local coordination_bash_usage=false
  if find "$PROJECT_ROOT/.claude/skills/cfn-loop-orchestration/" -name "*.sh" -type f -exec grep -l "redis-cli\|bash\|exec" {} \; 2>/dev/null | head -1 | grep -q .; then
    coordination_bash_usage=true
  fi
  
  if [ "$spawn_agent_bash_access" = true ] && [ "$coordination_bash_usage" = true ]; then
    pass "Bash tool access properly configured for coordination"
  else
    fail "Bash tool access insufficient - spawn: $spawn_agent_bash_access, coordination: $coordination_bash_usage"
  fi

  # Verify coordination uses bash commands (Redis CLI)
  if grep -rq "redis-cli" "$PROJECT_ROOT/.claude/skills/cfn-loop-orchestration/" 2>/dev/null; then
    pass "Coordination requires Bash tool for Redis CLI commands"
  else
    fail "Coordination requires Bash tool for Redis CLI commands"
  fi

  log_info "✅ Bash tool access validation passed"
}

test_file_operation_tools() {
  log_step "GIVEN file operation tools (Read, Write, Edit)"

  # WHEN checking file operation tool requirements
  local file_tools=("Read" "Write" "Edit")

  # THEN verify file tools are essential for agent work
  log_info "Validating file operation tools for agent work"

  # Validate file operation tools are actually available to agents
  local tools_documented=0
  local tools_available=0
  
  for tool in "${file_tools[@]}"; do
    # Check if tools are documented in project configuration
    if grep -qi "$tool" "$PROJECT_ROOT/CLAUDE.md" 2>/dev/null || \
       grep -qi "$tool" "$PROJECT_ROOT/.claude/agents/cfn-dev-team/README.md" 2>/dev/null || \
       grep -qi "$tool" "$PROJECT_ROOT/src/cli/agent-definition-parser.ts" 2>/dev/null; then
      ((tools_documented++))
    fi
    
    # Check if tools are implemented in the codebase
    if find "$PROJECT_ROOT/src" -name "*.ts" -type f -exec grep -l "$tool" {} \; 2>/dev/null | head -1 | grep -q .; then
      ((tools_available++))
    fi
  done
  
  if [ "$tools_documented" -eq "${#file_tools[@]}" ] && [ "$tools_available" -eq "${#file_tools[@]}" ]; then
    pass "All file operation tools documented and implemented ($tools_documented/${#file_tools[@]})"
  else
    fail "File operation tools incomplete - documented: $tools_documented/${#file_tools[@]}, available: $tools_available/${#file_tools[@]}"
  fi

  log_info "✅ File operation tools validation passed"
}

test_search_tools() {
  log_step "GIVEN search tools (Grep, Glob)"

  # WHEN checking search tool requirements
  local search_tools=("Grep" "Glob")

  # THEN verify search tools are available
  log_info "Validating search tools for code navigation"

  # Check if CLAUDE.md mentions these tools (case-insensitive)
  if grep -qi "grep" "$PROJECT_ROOT/CLAUDE.md" 2>/dev/null; then
    pass "Search tools documented in CLAUDE.md"
  else
    fail "Search tools documented in CLAUDE.md"
  fi

  # Verify preferred usage patterns
  if grep -iq "grep.*over.*find\|prefer.*grep" "$PROJECT_ROOT/CLAUDE.md" 2>/dev/null; then
    pass "Grep preferred over find (performance requirement)"
  else
    fail "Grep preferred over find (performance requirement)"
  fi

  log_info "✅ Search tools validation passed"
}

test_task_tool_access() {
  log_step "GIVEN Task tool for agent spawning"

  # WHEN checking Task tool availability
  local tool_name="Task"

  # THEN verify Task tool is documented for agent spawning
  log_info "Validating Task tool for sub-agent spawning"

  # Check if Task spawning is mentioned in coordination
  if grep -q "Task(" "$PROJECT_ROOT/CLAUDE.md" 2>/dev/null; then
    pass "Task tool documented for agent spawning"
  else
    fail "Task tool documented for agent spawning"
  fi

  # Verify CLI mode uses proper spawning mechanism (not Task tool directly)
  local cli_spawning_mechanism=false
  local spawn_script_exists=false
  
  # Check for CLI spawning documentation
  if grep -q "spawn-agent\|CLI.*agent\|npx.*claude" "$PROJECT_ROOT/.claude/commands/cfn-loop-cli.md" 2>/dev/null; then
    cli_spawning_mechanism=true
  fi
  
  # Check for spawn script existence and functionality
  if [[ -f "$PROJECT_ROOT/.claude/skills/cfn-agent-spawning/spawn-agent.sh" ]] && \
     grep -q "agent\|spawn\|execute" "$PROJECT_ROOT/.claude/skills/cfn-agent-spawning/spawn-agent.sh" 2>/dev/null; then
    spawn_script_exists=true
  fi
  
  if [ "$cli_spawning_mechanism" = true ] && [ "$spawn_script_exists" = true ]; then
    pass "CLI mode spawning properly configured"
  else
    fail "CLI mode spawning defective - documentation: $cli_spawning_mechanism, script: $spawn_script_exists"
  fi

  log_info "✅ Task tool access validation passed"
}

test_tool_permissions_in_spawn() {
  log_step "GIVEN tool permission configuration in spawn-agent.sh"

  # WHEN checking tool permissions setup
  local spawn_agent="$PROJECT_ROOT/.claude/skills/cfn-agent-spawning/spawn-agent.sh"

  # THEN verify no tool restrictions are in place
  log_info "Validating tool permissions are not restricted"

  # Check if there are any tool restrictions
  if grep -q "disable.*tool\|restrict.*tool\|tool.*permission" "$spawn_agent" 2>/dev/null; then
    fail "Tool permissions should not be restricted in spawn-agent.sh"
  else
    pass "No tool restrictions found in spawn-agent.sh"
  fi

  # Verify agents have full tool access by checking agent definitions
  local required_tools_count=7
  local tools_found=0
  
  # Check agent definition files for tool configuration
  if find "$PROJECT_ROOT/.claude/agents" -name "*.md" -type f -exec grep -l "tools:" {} \; 2>/dev/null | head -1 | grep -q .; then
    # Count actual tools mentioned in agent definitions
    local tool_count=$(grep -h "tools:" "$PROJECT_ROOT/.claude/agents"/*.md 2>/dev/null | grep -o "\[.*\]" | grep -o "," | wc -l || echo 0)
    tools_found=$((tool_count + 1))  # +1 because grep -o "," gives count of commas, not tools
  fi
  
  # Also check in agent-executor.ts for tool handling
  if grep -q "tools.*length\|convertToolNames" "$PROJECT_ROOT/src/cli/agent-executor.ts" 2>/dev/null; then
    tools_found=$((tools_found + 1))
  fi
  
  if [ "$tools_found" -ge "$required_tools_count" ]; then
    pass "Tool access verified ($tools_found tools available)"
  else
    fail "Insufficient tool access - found $tools_found, expected $required_tools_count"
  fi

  log_info "✅ Tool permissions validation passed"
}

test_coordination_tool_requirements() {
  log_step "GIVEN coordination protocol tool requirements"

  # WHEN checking coordination protocol dependencies
  local coordination_dir="$PROJECT_ROOT/.claude/skills/cfn-redis-coordination"

  # THEN verify coordination skill directory exists
  if [[ -d "$coordination_dir" ]]; then
    pass "Coordination skill directory exists"

    # Check for Redis coordination scripts that actually use bash commands
    local bash_coordination_found=false
    local redis_coordination_found=false
    
    # Look for bash scripts in coordination
    if find "$coordination_dir" -name "*.sh" -type f -exec grep -l "redis-cli\|redis\|bash" {} \; 2>/dev/null | head -1 | grep -q .; then
      bash_coordination_found=true
    fi
    
    # Look for Redis usage patterns
    if find "$coordination_dir" -name "*.sh" -type f -exec grep -l "redis-cli\|lPush\|BLPOP" {} \; 2>/dev/null | head -1 | grep -q .; then
      redis_coordination_found=true
    fi
    
    if [ "$bash_coordination_found" = true ] && [ "$redis_coordination_found" = true ]; then
      pass "Coordination protocol properly configured with Redis and Bash"
    else
      fail "Coordination protocol incomplete - bash: $bash_coordination_found, redis: $redis_coordination_found"
    fi
  else
    fail "Coordination skill directory exists"
  fi

  log_info "✅ Coordination tool requirements validation passed"
}

test_pre_edit_backup_tool_requirements() {
  log_step "GIVEN pre-edit backup hook tool requirements"

  # WHEN checking pre-edit backup requirements
  local pre_edit_hook="$PROJECT_ROOT/.claude/hooks/cfn-invoke-pre-edit.sh"

  # THEN verify backup hook exists
  if [[ -f "$pre_edit_hook" ]]; then
    pass "Pre-edit backup hook exists"
  else
    fail "Pre-edit backup hook exists"
    return
  fi

  # Verify CLAUDE.md documents pre-edit backup requirement
  if grep -q "Pre-Edit Backup" "$PROJECT_ROOT/CLAUDE.md" 2>/dev/null; then
    pass "Pre-edit backup documented in CLAUDE.md"
  else
    fail "Pre-edit backup documented in CLAUDE.md"
  fi

  # Verify agents need Bash tool to invoke backup hook
  if grep -q "cfn-invoke-pre-edit.sh" "$PROJECT_ROOT/CLAUDE.md" 2>/dev/null; then
    pass "Pre-edit hook requires Bash tool for invocation"
  else
    fail "Pre-edit hook requires Bash tool for invocation"
  fi

  log_info "✅ Pre-edit backup tool requirements validation passed"
}

# Execute tests
test_required_tools_list
test_spawn_agent_tool_config
test_agent_prompt_builder_tool_access
test_bash_tool_access
test_file_operation_tools
test_search_tools
test_task_tool_access
test_tool_permissions_in_spawn
test_coordination_tool_requirements
test_pre_edit_backup_tool_requirements

# Test summary
echo ""
log_step "Test Summary"
PASS_RATE=$(awk "BEGIN {printf \"%.0f\", ($PASS_COUNT / $TOTAL_COUNT * 100)}")
echo -e "${GREEN}Total Tests: $TOTAL_COUNT${NC}"
echo -e "${GREEN}Passed: $PASS_COUNT${NC}"
if [[ $TOTAL_COUNT -ne $PASS_COUNT ]]; then
  echo -e "${RED}Failed: $((TOTAL_COUNT - PASS_COUNT))${NC}"
fi
echo -e "${GREEN}Pass Rate: ${PASS_RATE}%${NC}"

if [[ $PASS_COUNT -eq $TOTAL_COUNT ]]; then
  echo ""
  echo -e "${GREEN}✅ All agent tool access tests PASSED${NC}"
  echo ""
  log_info "Validation complete: Agent tool access configuration is correct"
  log_info "All 7 required tools validated: Bash, Read, Write, Edit, Grep, Glob, Task"
  log_info "Tool permissions properly configured in spawn-agent.sh"
  log_info "Coordination and pre-edit backup hooks require Bash tool"
  exit 0
else
  echo ""
  echo -e "${RED}❌ Some tests failed${NC}"
  exit 1
fi