#  Copyright 2026 zhaoxi826
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.

import importlib.util
import os
import sys
from typing import Callable, Dict, List
import pathlib
from pretor.utils.ray_hook import ray_actor_hook

from pretor.utils.logger import get_logger
logger = get_logger('get_tool')
_tool_cache: Dict[str, Callable] = {}


def _get_tool_func(tool_name: str) -> Callable | None:
    func = _tool_cache.get(tool_name, None)
    if func:
        return func

    app_root = "/app"
    tool_plugin_dir = os.path.join(app_root, "pretor", "plugin", "tool_plugin", tool_name)

    if not os.path.exists(tool_plugin_dir) or not os.path.isdir(tool_plugin_dir):
        logger.error(f"Tool directory not found: {tool_plugin_dir}")
        return None

    init_file = os.path.join(tool_plugin_dir, "__init__.py")
    if not os.path.exists(init_file):
        logger.error(f"Tool init file not found: {init_file}")
        return None

    try:
        module_name = f"pretor.plugin.tool_plugin.{tool_name}"
        spec = importlib.util.spec_from_file_location(module_name, init_file)
        if spec is None or spec.loader is None:
            logger.error(f"Failed to create spec for {module_name}")
            return None

        module = importlib.util.module_from_spec(spec)
        sys.modules[module_name] = module
        spec.loader.exec_module(module)

        func = getattr(module, tool_name, None)

        if not callable(func):
            logger.error(f"Tool function '{tool_name}' not found or not callable in {module_name}")
            return None
        _tool_cache[tool_name] = func
        return func
    except Exception as e:
        logger.error(f"Failed to load module {module_name}: {e}")
        return None

def del_tool_cache(tool_name: str) -> None:
    if tool_name in _tool_cache:
        del _tool_cache[tool_name]

def load_tools_from_list(tool_names: List[str] | None) -> List[Callable]:
    if not tool_names:
        return []

    tool_list = []
    for tool_name in tool_names:
        tool_func = _get_tool_func(tool_name)
        if tool_func:
            tool_list.append(tool_func)

    return tool_list