from __future__ import annotations

import json
import os
import re
import shlex
import subprocess
import sys
from pathlib import Path
from typing import Any

from .types import ToolResult


DANGEROUS_PYTHON_PATTERNS = (
    "rm -",
    "rmtree",
    "unlink",
    "remove(",
    "removedirs",
    "rmdir",
    "os.system",
    "os.popen",
    "subprocess",
    "shutil",
    "send2trash",
    "__import__",
    "eval(",
    "exec(",
    "compile(",
    "socket",
    "httpx",
    "requests",
    "urllib",
)
ABSOLUTE_PATH_LITERAL = re.compile(r"[\"']/(?:[^\"']*)[\"']")


def execute_actions(
    actions: list[dict[str, Any]],
    workspace: Path,
    *,
    args: Any,
    step: int,
) -> tuple[list[dict[str, Any]], str, bool, str | None]:
    action_events: list[dict[str, Any]] = []
    observations: list[str] = []
    final_answer: str | None = None
    is_final = False

    for index, action in enumerate(actions, start=1):
        result = execute_action(action, workspace, args=args, step=step)
        action_name = str(action.get("action") or action.get("tool") or "<missing>")
        action_events.append(
            {
                "index": index,
                "action": action,
                "observation": result.observation,
                "is_final": result.is_final,
            }
        )
        observations.append(f"Tool result {index} ({action_name}):\n{result.observation}")
        if result.is_final:
            is_final = True
            final_answer = result.final_answer
            break

    return action_events, "\n\n".join(observations), is_final, final_answer


def execute_action(action: dict[str, Any], workspace: Path, *, args: Any, step: int) -> ToolResult:
    action_name = str(action.get("action", "")).strip()
    try:
        if action_name in {"list_dir", "ls"}:
            path = str(action.get("path") or ".")
            if bool(action.get("recursive", False)):
                return ToolResult(list_dir_recursive(workspace, path, limit=args.list_limit))
            return ToolResult(list_dir(workspace, path, limit=args.list_limit))
        if action_name in {"read_file", "read"}:
            return ToolResult(read_file(workspace, require_path_like(action), limit=args.read_limit))
        if action_name in {"write_file", "write"}:
            return ToolResult(write_file(workspace, require_path_like(action), require_string(action, "content")))
        if action_name in {"edit_file", "edit"}:
            return ToolResult(
                edit_file(
                    workspace,
                    require_path_like(action),
                    require_string(action, "old_text"),
                    require_string(action, "new_text"),
                    replace_all=bool(action.get("replace_all", False)),
                )
            )
        if action_name == "apply_patch":
            changes = action.get("changes")
            if not isinstance(changes, list):
                return ToolResult("Error: 'changes' must be a list.")
            return ToolResult(apply_workspace_patch(workspace, changes))
        if action_name == "grep":
            return ToolResult(
                grep_workspace(
                    workspace,
                    require_string(action, "pattern"),
                    action.get("glob"),
                    limit=args.list_limit,
                )
            )
        if action_name == "find":
            return ToolResult(find_workspace_files(workspace, action.get("pattern"), limit=args.list_limit))
        if action_name in {"memory_search", "memory_get", "memory_append"}:
            return ToolResult("Error: memory is disabled in this local no-memory runner.")
        if action_name in {"exec", "execute_dangerous_command"}:
            return ToolResult(execute_workspace_command(workspace, str(action.get("command", ""))))
        if action_name == "ask_human_for_confirmation":
            command = str(action.get("command", ""))
            return ToolResult(f"Human response: Reject (auto). Command not approved: {command}")
        if action_name == "mkdir":
            return ToolResult(make_dir(workspace, require_string(action, "path")))
        if action_name == "run_python":
            if not args.allow_python_tool:
                return ToolResult("Error: run_python is disabled. Use read/write/edit/apply_patch actions instead.")
            return ToolResult(run_python(workspace, require_string(action, "code"), step=step, timeout=args.python_timeout))
        if action_name == "finish":
            return ToolResult(
                observation="Finished.",
                is_final=True,
                final_answer=str(action.get("answer") or ""),
            )
        if not action_name:
            return ToolResult("Error: missing action field.")
        return ToolResult(f"Error: Unknown tool '{action_name}'.")
    except Exception as exc:
        return ToolResult(f"Error while executing {action_name or '<missing>'}: {type(exc).__name__}: {exc}")


def require_string(action: dict[str, Any], key: str) -> str:
    value = action.get(key)
    if not isinstance(value, str):
        raise ValueError(f"field {key!r} must be a string")
    return value


def require_path_like(action: dict[str, Any]) -> str:
    value = action.get("path", action.get("filename"))
    if not isinstance(value, str):
        raise ValueError("field 'path' must be a string")
    return value


def resolve_workspace_path(workspace: Path, relative_path: str) -> Path:
    raw_path = relative_path.strip() or "."
    candidate_path = Path(raw_path)
    if candidate_path.is_absolute():
        raise ValueError(f"absolute paths are not allowed: {relative_path}")
    if any(part == ".." for part in candidate_path.parts):
        raise ValueError(f"parent path '..' is not allowed: {relative_path}")
    resolved = (workspace / candidate_path).resolve()
    workspace_resolved = workspace.resolve()
    if resolved != workspace_resolved and workspace_resolved not in resolved.parents:
        raise ValueError(f"path escapes workspace: {relative_path}")
    return resolved


def relative_workspace_path(workspace: Path, path: Path) -> str:
    workspace_resolved = workspace.resolve()
    path_resolved = path.resolve()
    if path_resolved == workspace_resolved:
        return "."
    return path_resolved.relative_to(workspace_resolved).as_posix()


def json_dumps(payload: Any) -> str:
    return json.dumps(payload, ensure_ascii=False, indent=2)


def list_dir(workspace: Path, relative_path: str, *, limit: int) -> str:
    path = resolve_workspace_path(workspace, relative_path)
    if not path.exists():
        return "Error: path not found."
    if path.is_file():
        return json_dumps(
            {
                "path": relative_workspace_path(workspace, path),
                "entries": [
                    {
                        "path": relative_workspace_path(workspace, path),
                        "type": "file",
                    }
                ],
                "truncated": False,
            }
        )

    entries = []
    truncated = False
    for index, child in enumerate(sorted(path.iterdir())):
        if index >= limit:
            truncated = True
            break
        entries.append(
            {
                "path": relative_workspace_path(workspace, child),
                "type": "dir" if child.is_dir() else "file",
            }
        )
    return json_dumps(
        {
            "path": relative_workspace_path(workspace, path),
            "entries": entries,
            "truncated": truncated,
        }
    )


def list_dir_recursive(workspace: Path, relative_path: str, *, limit: int) -> str:
    path = resolve_workspace_path(workspace, relative_path)
    if not path.exists():
        return "Error: path not found."
    if path.is_file():
        return list_dir(workspace, relative_path, limit=limit)

    entries = []
    truncated = False
    for index, child in enumerate(sorted(path.rglob("*"))):
        if index >= limit:
            truncated = True
            break
        entries.append(
            {
                "path": relative_workspace_path(workspace, child),
                "type": "dir" if child.is_dir() else "file",
            }
        )
    return json_dumps(
        {
            "path": relative_workspace_path(workspace, path),
            "entries": entries,
            "truncated": truncated,
        }
    )


def read_file(workspace: Path, relative_path: str, *, limit: int) -> str:
    path = resolve_workspace_path(workspace, relative_path)
    if not path.exists():
        return f"Error: file does not exist: {relative_path}"
    if not path.is_file():
        return f"Error: path is not a file: {relative_path}"
    content = path.read_text(encoding="utf-8", errors="replace")
    if len(content) > limit:
        return content[:limit] + f"\n... truncated after {limit} characters"
    return content


def write_file(workspace: Path, relative_path: str, content: str) -> str:
    path = resolve_workspace_path(workspace, relative_path)
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(content, encoding="utf-8")
    return "Success: File written."


def edit_file(
    workspace: Path,
    relative_path: str,
    old_text: str,
    new_text: str,
    *,
    replace_all: bool,
) -> str:
    path = resolve_workspace_path(workspace, relative_path)
    content = path.read_text(encoding="utf-8")
    occurrences = content.count(old_text)
    if occurrences == 0:
        return "Error: target text not found."
    if not replace_all and occurrences != 1:
        return "Error: target text matched multiple locations. Pass replace_all=true or provide more specific old_text."
    updated = content.replace(old_text, new_text) if replace_all else content.replace(old_text, new_text, 1)
    path.write_text(updated, encoding="utf-8")
    changed = occurrences if replace_all else 1
    return f"Success: Applied {changed} edit(s)."


def make_dir(workspace: Path, relative_path: str) -> str:
    path = resolve_workspace_path(workspace, relative_path)
    path.mkdir(parents=True, exist_ok=True)
    return f"Success: directory exists: {relative_path}."


def apply_workspace_patch(workspace: Path, changes: list[Any]) -> str:
    if not changes:
        return "Error: no changes provided."
    results: list[str] = []
    for index, change in enumerate(changes, start=1):
        if not isinstance(change, dict):
            return f"Error: change #{index} must be an object."
        try:
            result = edit_file(
                workspace,
                require_path_like(change),
                require_string(change, "old_text"),
                require_string(change, "new_text"),
                replace_all=bool(change.get("replace_all", False)),
            )
        except Exception as exc:
            return f"Error: {type(exc).__name__}: {exc} (change #{index})"
        if result.startswith("Error:"):
            return f"{result} (change #{index})"
        results.append(f"change #{index}: {result}")
    return "Success: Patch applied.\n" + "\n".join(results)


def validate_glob_pattern(raw_pattern: str) -> str | None:
    glob_path = Path(raw_pattern)
    if glob_path.is_absolute() or any(part == ".." for part in glob_path.parts):
        return "glob must stay inside the workspace"
    return None


def find_workspace_files(workspace: Path, pattern: Any, *, limit: int) -> str:
    raw_pattern = str(pattern or "**/*").strip() or "**/*"
    validation_error = validate_glob_pattern(raw_pattern)
    if validation_error is not None:
        return f"Error: {validation_error}."

    files = []
    truncated = False
    for index, path in enumerate(sorted(path for path in workspace.glob(raw_pattern) if path.is_file())):
        if index >= limit:
            truncated = True
            break
        files.append(relative_workspace_path(workspace, path))
    return json_dumps({"files": files, "truncated": truncated})


def grep_workspace(workspace: Path, pattern: str, glob_pattern: Any, *, limit: int) -> str:
    try:
        regex = re.compile(pattern)
    except re.error as exc:
        return f"Error: invalid regex: {exc}"

    raw_glob = str(glob_pattern or "**/*").strip() or "**/*"
    validation_error = validate_glob_pattern(raw_glob)
    if validation_error is not None:
        return f"Error: {validation_error}."

    matches: list[dict[str, Any]] = []
    truncated = False
    for path in sorted(path for path in workspace.glob(raw_glob) if path.is_file()):
        try:
            text = path.read_text(encoding="utf-8", errors="replace")
        except OSError:
            continue
        relative = relative_workspace_path(workspace, path)
        for line_number, line in enumerate(text.splitlines(), start=1):
            if not regex.search(line):
                continue
            if len(matches) >= limit:
                truncated = True
                return json_dumps({"matches": matches, "truncated": truncated})
            matches.append({"path": relative, "line": line_number, "text": line})
    return json_dumps({"matches": matches, "truncated": truncated})


def execute_workspace_command(workspace: Path, command: str) -> str:
    raw = command.strip()
    if not raw:
        return "Error: Empty command"
    try:
        argv = shlex.split(raw)
    except ValueError as exc:
        return f"Error: Invalid command syntax: {exc}"
    if not argv:
        return "Error: Empty command"

    name = argv[0]
    if name == "pwd" and len(argv) == 1:
        return str(workspace.resolve())
    if name == "ls":
        target = "."
        recursive = False
        for argument in argv[1:]:
            if argument in {"-R", "--recursive"}:
                recursive = True
                continue
            if argument.startswith("-"):
                continue
            target = argument
        if recursive:
            return list_dir_recursive(workspace, target, limit=500)
        return list_dir(workspace, target, limit=500)
    return "Error: Permission denied. Non-read-only exec commands are rejected by this local runner. Use read/write/edit/apply_patch tools instead."


def run_python(workspace: Path, code: str, *, step: int, timeout: float) -> str:
    safety_error = validate_python_tool_code(code)
    if safety_error is not None:
        return f"Error: blocked unsafe Python code: {safety_error}"

    script_path = workspace / f".vllm_nanoclaw_step_{step}.py"
    script_path.write_text(code, encoding="utf-8")
    try:
        try:
            process = subprocess.run(
                [sys.executable, str(script_path.name)],
                cwd=workspace,
                text=True,
                capture_output=True,
                env=workspace_subprocess_env(workspace),
                timeout=timeout,
                check=False,
            )
        except subprocess.TimeoutExpired as exc:
            stdout = exc.stdout or ""
            stderr = exc.stderr or ""
            output_parts = []
            if stdout:
                output_parts.append(str(stdout).strip())
            if stderr:
                output_parts.append(f"[stderr]\n{str(stderr).strip()}")
            output = "\n\n".join(output_parts) if output_parts else "(no output)"
            return f"Error: Python timed out after {timeout:g}s\n{output}"
    finally:
        try:
            script_path.unlink()
        except FileNotFoundError:
            pass

    output_parts = []
    if process.stdout.strip():
        output_parts.append(process.stdout.strip())
    if process.stderr.strip():
        output_parts.append(f"[stderr]\n{process.stderr.strip()}")
    output = "\n\n".join(output_parts) if output_parts else "(no output)"
    if process.returncode != 0:
        return f"Error: Python exited with code {process.returncode}\n{output}"
    return output


def validate_python_tool_code(code: str) -> str | None:
    lowered = code.lower()
    if ".." in code:
        return "parent-directory path '..' is not allowed"
    absolute_match = ABSOLUTE_PATH_LITERAL.search(code)
    if absolute_match:
        return f"absolute path literal is not allowed: {absolute_match.group(0)}"
    for pattern in DANGEROUS_PYTHON_PATTERNS:
        if pattern in lowered:
            return f"forbidden pattern {pattern!r}"
    return None


def workspace_subprocess_env(workspace: Path) -> dict[str, str]:
    workspace_resolved = workspace.resolve()
    home_dir = workspace_resolved / ".runner_home"
    tmp_dir = workspace_resolved / ".runner_tmp"
    home_dir.mkdir(parents=True, exist_ok=True)
    tmp_dir.mkdir(parents=True, exist_ok=True)

    env = dict(os.environ)
    env["HOME"] = str(home_dir)
    env["TMPDIR"] = str(tmp_dir)
    env["TEMP"] = str(tmp_dir)
    env["TMP"] = str(tmp_dir)
    env["PWD"] = str(workspace_resolved)
    env["PYTHONNOUSERSITE"] = "1"
    env["NANOCLAW_WORKSPACE"] = str(workspace_resolved)
    return env