from termcolor import colored
import os
from dotenv import load_dotenv
load_dotenv()
import requests
import json
import operator

class OllamaModel:
    def __init__(self, model, system_prompt, temperature=0, stop=None):
        """
        用給定的參數(shù)初始化OllamaModel。
        參數(shù):
        model (str): 要使用的模型名稱。
        system_prompt (str): 要使用的系統(tǒng)提示。
        temperature (float): 模型的溫度設(shè)置。
        stop (str): 模型的停止標(biāo)記。
        """
        self.model_endpoint = "http://localhost:11434/api/generate"
        self.temperature = temperature
        self.model = model
        self.system_prompt = system_prompt
        self.headers = {"Content-Type": "application/json"}
        self.stop = stop

    def generate_text(self, prompt):
        """
        根據(jù)提供的提示從Ollama模型生成響應(yīng)。
        參數(shù):
        prompt (str): 用于生成響應(yīng)的用戶查詢。
        返回:
        dict: 模型的響應(yīng)，以字典形式返回。
        """
        payload = {
            "model": self.model,
            "format": "json",
            "prompt": prompt,
            "system": self.system_prompt,
            "stream": False,
            "temperature": self.temperature,
            "stop": self.stop
        }
        try:
            request_response = requests.post(
                self.model_endpoint,
                headers=self.headers,
                data=json.dumps(payload)
            )
            print("REQUEST RESPONSE", request_response)
            request_response_json = request_response.json()
            response = request_response_json['response']
            response_dict = json.loads(response)
            print(f"\n\nResponse from Ollama model: {response_dict}")
            return response_dict
        except requests.RequestException as e:
            response = {"error": f"Error in invoking model! {str(e)}"}
            return response

def basic_calculator(input_str):
    """
    根據(jù)輸入字符串或字典對兩個數(shù)字執(zhí)行數(shù)值運(yùn)算。
    參數(shù):
    input_str (str或dict): 要么是表示包含'num1'、'num2'和'operation'鍵的字典的JSON字符串，
    要么是直接的字典。例如: '{"num1": 5, "num2": 3, "operation": "add"}'
    或{"num1": 67869, "num2": 9030393, "operation": "divide"}
    返回:
    str: 運(yùn)算的格式化結(jié)果。
    拋出:
    Exception: 如果在運(yùn)算過程中發(fā)生錯誤（例如，除以零）。
    ValueError: 如果請求了不支持的運(yùn)算或輸入無效。
    """
    try:
        if isinstance(input_str, dict):
            input_dict = input_str
        else:
            input_str_clean = input_str.replace("'", "\"")
            input_str_clean = input_str_clean.strip().strip("\"")
            input_dict = json.loads(input_str_clean)
        if not all(key in input_dict for key in ['num1', 'num2', 'operation']):
            return "Error: Input must contain 'num1', 'num2', and 'operation'"
        num1 = float(input_dict['num1'])
        num2 = float(input_dict['num2'])
        operation = input_dict['operation'].lower()
    except (json.JSONDecodeError, KeyError) as e:
        return "Invalid input format. Please provide valid numbers and operation."
    except ValueError as e:
        return "Error: Please provide valid numerical values."
    operations = {
        'add': operator.add,
        'plus': operator.add,
      'subtract': operator.sub,
      'minus': operator.sub,
      'multiply': operator.mul,
        'times': operator.mul,
        'divide': operator.truediv,
        'floor_divide': operator.floordiv,
      'modulus': operator.mod,
        'power': operator.pow,
        'lt': operator.lt,
        'le': operator.le,
        'eq': operator.eq,
        'ne': operator.ne,
        'ge': operator.ge,
        'gt': operator.gt
    }
    if operation not in operations:
        return f"Unsupported operation: '{operation}'. Supported operations are: {', '.join(operations.keys())}"
    try:
        if (operation in ['divide', 'floor_divide','modulus']) and num2 == 0:
            return "Error: Division by zero is not allowed"
        result = operations[operation](num1, num2)
        if isinstance(result, bool):
            result_str = "True" if result else "False"
        elif isinstance(result, float):
            result_str = f"{result:.6f}".rstrip('0').rstrip('.')
        else:
            result_str = str(result)
        return f"The answer is: {result_str}"
    except Exception as e:
        return f"Error during calculation: {str(e)}"


def reverse_string(input_string):
    """
    反轉(zhuǎn)給定的字符串。
    參數(shù):
    input_string (str): 要反轉(zhuǎn)的字符串。
    返回:
    str: 反轉(zhuǎn)后的字符串。
    """
    if not isinstance(input_string, str):
        return "Error: Input must be a string"
    reversed_string = input_string[::-1]
    result = f"The reversed string is: {reversed_string}"
    return result

class ToolBox:
    def __init__(self):
        self.tools_dict = {}

    def store(self, functions_list):
        """
        存儲列表中每個函數(shù)的名稱和文檔字符串。
        參數(shù):
        functions_list (list): 要存儲的函數(shù)對象列表。
        返回:
        dict: 以函數(shù)名稱為鍵，其文檔字符串為值的字典。
        """
        for func in functions_list:
            self.tools_dict[func.__name__] = func.__doc__
        return self.tools_dict

    def tools(self):
        """
        將store方法中創(chuàng)建的字典轉(zhuǎn)換為文本字符串返回。
        返回:
        str: 存儲的函數(shù)及其文檔字符串的字典，以文本字符串形式返回。
        """
        tools_str = ""
        for name, doc in self.tools_dict.items():
            tools_str += f"{name}: \"{doc}\"\n"
        return tools_str.strip()

agent_system_prompt_template = """
你是一個智能AI助手，可以使用特定的工具。你的回復(fù)必須始終采用以下JSON格式：
{
    "tool_choice": "name_of_the_tool",
    "tool_input": "inputs_to_the_tool"
}
工具及使用場景：
1. basic_calculator：用于任何數(shù)學(xué)計算
    - 輸入格式: {{"num1": number, "num2": number, "operation": "add/subtract/multiply/divide"}}
    - 支持的運(yùn)算: add/plus, subtract/minus, multiply/times, divide
    - 示例輸入和輸出:
        - 輸入: "Calculate 15 plus 7"
        - 輸出: {{"tool_choice": "basic_calculator", "tool_input": {{"num1": 15, "num2": 7, "operation": "add"}}}}
        - 輸入: "What is 100 divided by 5?"
        - 輸出: {{"tool_choice": "basic_calculator", "tool_input": {{"num1": 100, "num2": 5, "operation": "divide"}}}}
2. reverse_string：用于任何涉及反轉(zhuǎn)文本的請求
    - 輸入格式: 僅需反轉(zhuǎn)的文本字符串
    - 當(dāng)用戶提到“reverse”、“backwards”或要求反轉(zhuǎn)文本時，始終使用此工具
    - 示例輸入和輸出:
        - 輸入: "Reverse of 'Howwwww'?"
        - 輸出: {{"tool_choice": "reverse_string", "tool_input": "Howwwww"}}
        - 輸入: "What is the reverse of Python?"
        - 輸出: {{"tool_choice": "reverse_string", "tool_input": "Python"}}
3. no tool：用于一般對話和問題
    - 示例輸入和輸出:
        - 輸入: "Who are you?"
        - 輸出: {{"tool_choice": "no tool", "tool_input": "I am an AI assistant that can help you with calculations, reverse text, and answer questions. I can perform mathematical operations and reverse strings. How can I help you today?"}}
        - 輸入: "How are you?"
        - 輸出: {{"tool_choice": "no tool", "tool_input": "I'm functioning well, thank you for asking! I'm here to help you with calculations, text reversal, or answer any questions you might have."}}
嚴(yán)格規(guī)則：
1. 對于關(guān)于身份、能力或感受的問題：
    - 始終使用“no tool”
    - 提供完整、友好的回復(fù)
    - 提及你的能力
2. 對于任何文本反轉(zhuǎn)請求：
    - 始終使用“reverse_string”
    - 僅提取要反轉(zhuǎn)的文本
    - 去除引號、“reverse of”和其他多余文本
3. 對于任何數(shù)學(xué)運(yùn)算：
    - 始終使用“basic_calculator”
    - 提取數(shù)字和運(yùn)算
    - 將文本形式的數(shù)字轉(zhuǎn)換為數(shù)字
以下是你的工具列表及其描述：
{tool_descriptions}
記住：你的回復(fù)必須始終是包含“tool_choice”和“tool_input”字段的有效JSON。
"""


class Agent:
    def __init__(self, tools, model_service, model_name, stop=None):
        """
        用工具列表和模型初始化智能體。
        參數(shù):
        tools (list): 工具函數(shù)列表。
        model_service (class): 具有g(shù)enerate_text方法的模型服務(wù)類。
        model_name (str): 要使用的模型名稱。
        """
        self.tools = tools
        self.model_service = model_service
        self.model_name = model_name
        self.stop = stop

    def prepare_tools(self):
        """
        將工具存儲在工具箱中并返回其描述。
        返回:
        str: 存儲在工具箱中的工具的描述。
        """
        toolbox = ToolBox()
        toolbox.store(self.tools)
        tool_descriptions = toolbox.tools()
        return tool_descriptions

    def think(self, prompt):
        """
        使用系統(tǒng)提示模板和工具描述在模型上運(yùn)行g(shù)enerate_text方法。
        參數(shù):
        prompt (str): 用于生成響應(yīng)的用戶查詢。
        返回:
        dict: 模型的響應(yīng)，以字典形式返回。
        """
        tool_descriptions = self.prepare_tools()
        agent_system_prompt = agent_system_prompt_template.format(tool_descriptions=tool_descriptions)
        if self.model_service == OllamaModel:
            model_instance = self.model_service(
                model=self.model_name,
                system_prompt=agent_system_prompt,
                temperature=0,
                stop=self.stop
            )
        else:
            model_instance = self.model_service(
                model=self.model_name,
                system_prompt=agent_system_prompt,
                temperature=0
            )
        agent_response_dict = model_instance.generate_text(prompt)
        return agent_response_dict

    def work(self, prompt):
        """
        解析think方法返回的字典并執(zhí)行相應(yīng)的工具。
        參數(shù):
        prompt (str): 用于生成響應(yīng)的用戶查詢。
        返回:
        執(zhí)行相應(yīng)工具的響應(yīng)，如果未找到匹配的工具，則返回tool_input。
        """
        agent_response_dict = self.think(prompt)
        tool_choice = agent_response_dict.get("tool_choice")
        tool_input = agent_response_dict.get("tool_input")
        for tool in self.tools:
            if tool.__name__ == tool_choice:
                response = tool(tool_input)
                print(colored(response, 'cyan'))
                return
        print(colored(tool_input, 'cyan'))
        return

if __name__ == "__main__":
    """
    使用此智能體的說明：
    你可以嘗試的示例查詢：
    1. 計算器運(yùn)算:
        - "Calculate 15 plus 7"
        - "What is 100 divided by 5?"
        - "Multiply 23 and 4"
    2. 字符串反轉(zhuǎn):
        - "Reverse the word 'hello world'"
        - "Can you reverse 'Python Programming'?"
    3. 一般問題（將得到直接回復(fù)）:
        - "Who are you?"
        - "What can you help me with?"
    Ollama命令（在終端中運(yùn)行這些命令）:
        - 查看可用模型:    'ollama list'
        - 查看正在運(yùn)行的模型:      'ps aux | grep ollama'
        - 列出模型標(biāo)簽:          'curl http://localhost:11434/api/tags'
        - 拉取新模型:         'ollama pull mistral'
        - 運(yùn)行模型服務(wù)器:         'ollama serve'
    """
    tools = [basic_calculator, reverse_string]
    model_service = OllamaModel
    model_name = "llama2"
    stop = "<|eot_id|>"
    agent = Agent(tools=tools, model_service=model_service, model_name=model_name, stop=stop)
    print("\nWelcome to the AI Agent! Type 'exit' to quit.")
    print("You can ask me to:")
    print("1. Perform calculations (e.g., 'Calculate 15 plus 7')")
    print("2. Reverse strings (e.g., 'Reverse hello world')")
    print("3. Answer general questions\n")
    while True:
        prompt = input("Ask me anything: ")
        if prompt.lower() == "exit":
            break
        agent.work(prompt)