"""Command-intent classification shared by transcript analysis and metrics."""

from __future__ import annotations

import re

import shlex

UNKNOWN_COMMAND_PATTERN = re.compile(

    r"(unknown (sub)?command|unrecognized (option|subcommand|argument)|no such (sub)?command"

    r"|is not a git command|unexpected argument|invalid option|unknown option)",

    re.IGNORECASE,

)

def unwrap_shell_command(command: str) -> str:

    try:

        parts = shlex.split(command)

    except ValueError:

        return command

    if len(parts) >= 3 and parts[0] in {"/bin/zsh", "zsh", "/bin/bash", "bash", "sh"} and parts[1] in {"-c", "-lc"}:

        return parts[2]

    return command

# Read-only VCS interrogation commands. A successful info command immediately

# re-asked in the same family ("status, then status with more flags") means

# the first answer did not carry enough information to act on — the cost of

# compact output shows up here, not in the bytes of the first call.

VCS_INFO_FAMILIES = ("status", "diff", "log", "show", "blame", "branch")

# Harnesses and agents routinely invoke VCS binaries by absolute path

# (/usr/bin/git, ../oak/target/release/oak); classification must not depend

# on how the binary was addressed.

_VCS_SUBCOMMAND = re.compile(r"(^|[;&|]\s*|\s)(\S*/)?(git|oak)\s+([\w][\w-]*)")

def _shell_segment_end(command: str, start: int) -> int:

    quote: str | None = None

    escaped = False

    for index in range(start, len(command)):

        char = command[index]

        if escaped:

            escaped = False

            continue

        if char == "\\":

            escaped = True

            continue

        if quote is not None:

            if char == quote:

                quote = None

            continue

        if char in {"'", '"'}:

            quote = char

            continue

        if char in {";", "\n", "|"}:

            return index

        if char == "&":

            return index

    return len(command)

def _quoted_offsets(command: str) -> set[int]:

    quoted: set[int] = set()

    quote: str | None = None

    escaped = False

    for index, char in enumerate(command):

        if escaped:

            if quote is not None:

                quoted.add(index)

            escaped = False

            continue

        if char == "\\":

            if quote is not None:

                quoted.add(index)

            escaped = True

            continue

        if quote is not None:

            quoted.add(index)

            if char == quote:

                quote = None

            continue

        if char in {"'", '"'}:

            quote = char

            quoted.add(index)

    return quoted

def vcs_invocations(command: str) -> list[tuple[str, str]]:

    """VCS invocation shell segment and subcommand for every VCS call in a chain."""

    stripped = unwrap_shell_command(command).strip()

    quoted = _quoted_offsets(stripped)

    invocations: list[tuple[str, str]] = []

    for match in _VCS_SUBCOMMAND.finditer(stripped):

        binary_start = match.start(2) if match.group(2) is not None else match.start(3)

        if binary_start in quoted:

            continue

        segment_start = match.start(2) if match.group(2) is not None else match.start(3)

        segment = stripped[segment_start:_shell_segment_end(stripped, segment_start)].strip()

        invocations.append((segment, match.group(4)))

    return invocations

def vcs_subcommand(command: str) -> str | None:

    """The VCS subcommand of an invocation (any path form), or None if not a VCS call.

    The single classification authority: every consumer that needs to know

    "which VCS operation was this" goes through here, so transcript

    sub-counts can never disagree with classify_command about what is a VCS

    call (the reviewer-found vcs_commands_total=0 vs status_commands=1 rows).

    """

    invocations = vcs_invocations(command)

    return invocations[0][1] if invocations else None

def vcs_subcommands(command: str) -> list[str]:

    """All VCS subcommands in a shell command chain.

    `git add . && git commit ...` is one terminal tool call but two VCS

    invocations; snapshot metrics need to see the commit rather than stopping

    at the first `add`.

    """

    return [subcommand for _, subcommand in vcs_invocations(command)]

def vcs_info_family(command: str) -> str | None:

    """The info-command family of a VCS invocation, or None if not read-only info."""

    subcommand = vcs_subcommand(command)

    return subcommand if subcommand in VCS_INFO_FAMILIES else None

def classify_command(command: str) -> set[str]:

    kinds: set[str] = {"terminal"}

    stripped = unwrap_shell_command(command).strip()

    if vcs_subcommands(stripped):

        kinds.add("vcs")

    # validate[_.]\w* (not the old validate_\b) so validator scripts like

    # validate_configs.py classify as test commands; \b cannot follow "_".

    if re.search(r"\b(unittest|pytest|cargo test|npm test|validate[_.]\w*|test)\b", stripped):

        kinds.add("test")

    if re.search(r"(^|[;&|]\s*)(\S*/)?(rg|grep|find)\b", stripped):

        kinds.add("search")

    if re.search(r"(^|[;&|]\s*)(\S*/)?(cat|sed|head|tail|less)\b|(^|[;&|]\s*)python3? - <<", stripped):

        kinds.add("read")

    if re.search(r"\b(write_text|replace\(|apply_patch|python3? - <<|perl -pi|ruby -pi)\b", stripped):

        kinds.add("edit")

        kinds.add("file_write")

    if re.search(r"(\s--help\b|^(\S*/)?(git|oak)\s+help\b|^man\s|^tldr\s|^help\b)", stripped):

        kinds.add("help")

    return kinds