"""Search tools: search_files (content search) and find_files (glob)."""

from __future__ import annotations

import fnmatch
import re
from pathlib import Path
from typing import Any

from ycode.errors import ToolError
from ycode.tools.base import Tool, ToolContext, ToolResult
from ycode.tools.filesystem import iter_files

MAX_FILE_BYTES = 1_000_000


def _matches_glob(rel: str, pattern: str | None) -> bool:
    if not pattern:
        return True
    name = rel.rsplit("/", 1)[-1]
    patterns = [p.strip() for p in pattern.split(",") if p.strip()]
    return any(
        fnmatch.fnmatch(rel, p) or fnmatch.fnmatch(name, p) or fnmatch.fnmatch(rel, f"**/{p}") for p in patterns
    )


class SearchFilesTool(Tool):
    name = "search_files"
    description = (
        "Search file contents with a regular expression (Python syntax). Returns matching "
        "lines as path:line: text. Use `glob` (e.g. '*.py' or 'src/**/*.ts') to narrow files."
    )
    parameters = {
        "type": "object",
        "properties": {
            "pattern": {"type": "string", "description": "Regular expression to search for."},
            "path": {"type": "string", "description": "Directory to search (default project root)."},
            "glob": {"type": "string", "description": "Filename filter, comma-separated globs."},
            "case_sensitive": {"type": "boolean", "description": "Default false."},
            "max_results": {"type": "integer", "description": "Default 100."},
        },
        "required": ["pattern"],
    }

    def describe(self, args: dict[str, Any]) -> str:
        where = f" in {args['glob']}" if args.get("glob") else ""
        return f"Searching for /{args.get('pattern', '')}/{where}"

    def run(self, args: dict[str, Any], ctx: ToolContext) -> ToolResult:
        root = ctx.permissions.paths.resolve(args.get("path") or ".")
        if not root.exists():
            raise ToolError(f"Path not found: {args.get('path')}")
        flags = 0 if args.get("case_sensitive") else re.IGNORECASE
        try:
            regex = re.compile(args["pattern"], flags)
        except re.error as exc:
            raise ToolError(f"invalid regular expression: {exc}") from None
        limit = min(max(int(args.get("max_results") or 100), 1), 1000)
        files = [root] if root.is_file() else iter_files(root, ctx.ignore_dirs)
        results: list[str] = []
        files_matched = 0
        for file in files:
            rel = ctx.permissions.paths.relative(file)
            if not _matches_glob(rel, args.get("glob")):
                continue
            try:
                if file.stat().st_size > MAX_FILE_BYTES:
                    continue
                data = file.read_bytes()
            except OSError:
                continue
            if b"\x00" in data[:8192]:
                continue
            hit = False
            for lineno, line in enumerate(data.decode("utf-8", errors="replace").splitlines(), 1):
                if regex.search(line):
                    hit = True
                    results.append(f"{rel}:{lineno}: {line.strip()[:300]}")
                    if len(results) >= limit:
                        break
            files_matched += hit
            if len(results) >= limit:
                break
        if not results:
            return ToolResult(content="No matches found.", summary="No matches")
        suffix = f"\n[Stopped after {limit} results; refine the pattern.]" if len(results) >= limit else ""
        return ToolResult(
            content="\n".join(results) + suffix,
            summary=f"{len(results)} matches in {files_matched} files",
        )


class FindFilesTool(Tool):
    name = "find_files"
    description = "Find files by name/glob pattern (e.g. '*.test.ts', 'package.json', 'src/**/auth*')."
    parameters = {
        "type": "object",
        "properties": {
            "pattern": {"type": "string", "description": "Glob pattern (comma-separated for several)."},
            "path": {"type": "string", "description": "Directory to search (default project root)."},
            "max_results": {"type": "integer", "description": "Default 200."},
        },
        "required": ["pattern"],
    }

    def describe(self, args: dict[str, Any]) -> str:
        return f"Finding files matching {args.get('pattern', '')}"

    def run(self, args: dict[str, Any], ctx: ToolContext) -> ToolResult:
        root = ctx.permissions.paths.resolve(args.get("path") or ".")
        if not root.is_dir():
            raise ToolError(f"Directory not found: {args.get('path')}")
        limit = min(max(int(args.get("max_results") or 200), 1), 2000)
        found: list[str] = []
        for file in iter_files(root, ctx.ignore_dirs):
            rel = ctx.permissions.paths.relative(file)
            if _matches_glob(rel, args["pattern"]):
                found.append(rel)
                if len(found) >= limit:
                    break
        if not found:
            return ToolResult(content="No files found.", summary="No files found")
        return ToolResult(content="\n".join(found), summary=f"Found {len(found)} files")


def list_project_files(root: Path, ignore_dirs: tuple[str, ...], limit: int = 2000) -> list[str]:
    out: list[str] = []
    for file in iter_files(root, ignore_dirs):
        out.append(file.relative_to(root).as_posix())
        if len(out) >= limit:
            break
    return out