/**
 * Unit tests for Matcher Engine
 */

import { describe, it, expect, beforeEach } from "vitest";
import { Matcher, type TaskAnalysis, type RuleMatchResult } from "../../src/core/matcher.js";
import type { RoutingRule } from "../../src/config/index.js";

describe("Matcher Engine", () => {
  let matcher: Matcher;

  // Sample routing rules for testing
  const mockRules: RoutingRule[] = [
    {
      id: "file-read",
      name: "File Read",
      enabled: true,
      priority: 10,
      match: {
        queryPatterns: ["read", "file", "show", "display", "view", "cat"],
        capabilities: ["file_read"],
      },
      preferredTools: ["read"],
    },
    {
      id: "code-search",
      name: "Code Search",
      enabled: true,
      priority: 9,
      match: {
        queryPatterns: ["search", "find", "grep", "trace", "locate", "where is"],
        capabilities: ["code_search", "code_analysis"],
      },
      preferredTools: ["search", "grep"],
    },
    {
      id: "web-search",
      name: "Web Search",
      enabled: true,
      priority: 8,
      match: {
        queryPatterns: ["search web", "google", "online", "latest", "news"],
        capabilities: ["web_search"],
      },
      preferredTools: ["web_search", "fetch_content"],
    },
    {
      id: "execution",
      name: "Command Execution",
      enabled: true,
      priority: 10,
      match: {
        queryPatterns: ["run", "execute", "command", "npm", "git", "build", "test"],
        capabilities: ["bash_exec"],
      },
      preferredTools: ["bash"],
    },
    {
      id: "disabled-rule",
      name: "Disabled Rule",
      enabled: false,
      priority: 10,
      match: {
        queryPatterns: ["should not match"],
      },
      preferredTools: ["bash"],
    },
  ];

  beforeEach(() => {
    matcher = new Matcher();
  });

  describe("Task Analysis", () => {
    it("should analyze simple queries", () => {
      const analysis = matcher.analyzeTask("Show the file");
      
      expect(["simple", "moderate"]).toContain(analysis.complexity);
      expect(analysis.inferredCapabilities).toContain("file_read");
    });

    it("should analyze moderate queries", () => {
      const analysis = matcher.analyzeTask("Analyze how the authentication function works");
      
      expect(["moderate", "complex"]).toContain(analysis.complexity);
      expect(analysis.inferredCapabilities.length).toBeGreaterThan(0);
    });

    it("should analyze complex queries", () => {
      const analysis = matcher.analyzeTask("Implement a new caching mechanism for the API");
      
      expect(["complex", "expert", "moderate"]).toContain(analysis.complexity);
      expect(analysis.keywords.length).toBeGreaterThan(0);
    });

    it("should analyze expert-level queries", () => {
      const analysis = matcher.analyzeTask("Debug and trace the multi-step authentication flow");
      
      expect(analysis.complexity).toBe("expert");
      expect(analysis.complexityScore).toBeGreaterThan(0.5);
    });

    it("should infer code analysis capabilities", () => {
      const analysis = matcher.analyzeTask("How is the login function implemented?");
      
      expect(analysis.inferredCapabilities).toContain("code_analysis");
    });

    it("should infer web search capabilities", () => {
      const analysis = matcher.analyzeTask("Search for the latest news about AI");
      
      expect(analysis.inferredCapabilities).toContain("web_search");
    });

    it("should detect parallel execution requirements", () => {
      const analysis = matcher.analyzeTask("Run these tests in parallel");
      
      expect(analysis.requiresParallel).toBe(true);
    });

    it("should detect confirmation requirements", () => {
      const analysis = matcher.analyzeTask("Delete all the critical files");
      
      expect(analysis.requiresConfirmation).toBe(true);
    });

    it("should estimate duration based on complexity", () => {
      const simple = matcher.analyzeTask("Show file");
      const expert = matcher.analyzeTask("Debug the complex authentication flow");
      
      expect(simple.estimatedDuration).toBeLessThan(expert.estimatedDuration);
    });

    it("should calculate confidence based on query quality", () => {
      const short = matcher.analyzeTask("Run");
      const detailed = matcher.analyzeTask("Execute the build command with npm");
      
      expect(detailed.confidence).toBeGreaterThanOrEqual(short.confidence);
    });
  });

  describe("Pattern Matching", () => {
    it("should match patterns in queries", () => {
      const result = matcher.testPattern("Show me the config file", "show");
      expect(result).toBe(true);
    });

    it("should match regex patterns", () => {
      const result = matcher.testPattern("Read the README", "read|show|display");
      expect(result).toBe(true);
    });

    it("should handle case-insensitive matching", () => {
      const result = matcher.testPattern("SEARCH for code", "search");
      expect(result).toBe(true);
    });

    it("should return false for non-matching patterns", () => {
      const result = matcher.testPattern("Show me the file", "execute");
      expect(result).toBe(false);
    });

    it("should extract matched groups", () => {
      const groups = matcher.extractGroups("find class User", "find (\\w+)");
      expect(groups).toContain("class");
    });

    it("should score patterns correctly", () => {
      const score = matcher.scorePatterns("read the file", ["read", "file", "write"]);
      expect(score).toBe(2);
    });
  });

  describe("Rule Matching", () => {
    it("should match rules by pattern", () => {
      const matches = matcher.matchRules("Read the config file", mockRules);
      
      expect(matches.length).toBeGreaterThan(0);
      expect(matches[0].id).toBe("file-read");
    });

    it("should sort matches by priority", () => {
      const matches = matcher.matchRules("Run the build command", mockRules);
      
      expect(matches.length).toBeGreaterThan(0);
      // Execution rule has priority 10, should be first
      expect(matches[0].priority).toBeGreaterThanOrEqual(matches[1]?.priority ?? 0);
    });

    it("should skip disabled rules", () => {
      const matches = matcher.matchRules("This should not match anything", mockRules);
      
      expect(matches.some(r => r.id === "disabled-rule")).toBe(false);
    });

    it("should match rules with multiple patterns", () => {
      const matches = matcher.matchRules("Search for the function", mockRules);
      
      expect(matches.some(r => r.id === "code-search")).toBe(true);
    });

    it("should return detailed match results", () => {
      const result = matcher.matchRule("Read the file", mockRules[0]);
      
      expect(result.matched).toBe(true);
      expect(result.matchScore).toBeGreaterThan(0);
      expect(result.matchedPatterns.length).toBeGreaterThan(0);
    });

    it("should provide detailed match results", () => {
      const details = matcher.matchRulesDetailed("Run the npm build", mockRules);
      
      expect(details.matches.length).toBeGreaterThan(0);
      expect(details.bestMatch).toBeDefined();
      expect(details.totalScore).toBeGreaterThan(0);
      expect(details.capabilityCoverage).toBeGreaterThan(0);
    });

    it("should handle empty rules array", () => {
      const matches = matcher.matchRules("Some query", []);
      
      expect(matches).toEqual([]);
    });

    it("should handle rules without patterns (priority-only)", () => {
      const rulesNoPatterns: RoutingRule[] = [
        {
          id: "priority-only",
          name: "Priority Only",
          enabled: true,
          priority: 7,
          match: {},
          preferredTools: ["search"],
        },
      ];

      const matches = matcher.matchRules("Any query", rulesNoPatterns);
      
      expect(matches.length).toBe(1);
      expect(matches[0].id).toBe("priority-only");
    });
  });

  describe("Tool Suggestions", () => {
    it("should suggest relevant tools based on query", () => {
      const tools = ["read", "search", "bash", "write"];
      
      const suggestions = matcher.suggestTools("Read the code file", tools);
      
      expect(suggestions.length).toBeGreaterThanOrEqual(0); // May be empty if no direct matches
    });

    it("should prioritize code tools for code queries", () => {
      const tools = ["read", "search", "bash", "write"];
      
      const suggestions = matcher.suggestTools("Search for the function implementation", tools);
      
      // Should return array (may be empty if no keyword matches)
      expect(Array.isArray(suggestions)).toBe(true);
    });

    it("should return empty array for no matches", () => {
      const tools = ["read", "search", "bash"];
      
      const suggestions = matcher.suggestTools("xyzabc not a real query", tools);
      
      // Should return empty if no keywords match
      expect(Array.isArray(suggestions)).toBe(true);
    });
  });

  describe("Capability Checks", () => {
    it("should check if query requires specific capability", () => {
      expect(matcher.requiresCapability("Read the file", "file_read")).toBe(true);
      expect(matcher.requiresCapability("Run the command", "file_read")).toBe(false);
    });

    it("should check code analysis capability", () => {
      expect(matcher.requiresCapability("Analyze the class", "code_analysis")).toBe(true);
    });

    it("should check bash execution capability", () => {
      expect(matcher.requiresCapability("Run npm install", "bash_exec")).toBe(true);
    });
  });

  describe("Weighted Scoring", () => {
    it("should calculate weighted scores", () => {
      const score = matcher.calculateWeightedScore({
        patternScore: 10,
        capabilityScore: 8,
        priorityScore: 9,
      });

      expect(score).toBeGreaterThan(0);
      expect(score).toBeLessThanOrEqual(10);
    });

    it("should respect custom weights", () => {
      const withPatternWeight = matcher.calculateWeightedScore({
        patternScore: 10,
        capabilityScore: 5,
        priorityScore: 5,
        weights: { pattern: 0.8, capability: 0.1, priority: 0.1 },
      });

      expect(withPatternWeight).toBeGreaterThan(8);
    });
  });

  describe("Edge Cases", () => {
    it("should handle empty queries", () => {
      const analysis = matcher.analyzeTask("");
      expect(analysis.complexity).toBeDefined();
    });

    it("should handle queries with only stop words", () => {
      const analysis = matcher.analyzeTask("the a is");
      expect(analysis.keywords.length).toBe(0);
    });

    it("should handle special characters in patterns", () => {
      const result = matcher.testPattern("What is the $PATH?", "path");
      expect(result).toBe(true);
    });

    it("should handle unicode characters", () => {
      // Unicode normalization may not work perfectly, just verify it doesn't crash
      const result = matcher.testPattern("Hello World", "hello");
      expect(result).toBe(true);
    });

    it("should create matcher with options", () => {
      const customMatcher = new Matcher({
        enableFuzzyMatching: false,
        fuzzyThreshold: 0.9,
      });
      
      expect(customMatcher).toBeDefined();
    });
  });
});