import warnings; warnings.filterwarnings("ignore")
import numpy as np
np.random.seed(42)
# Suppress warnings so output stays clean for beginners.

import os
from openai import OpenAI

API_key = os.environ["OPENAI_API_KEY"]
client = OpenAI()

# We import the API key from your environment.
# Then we create an OpenAI client instance.

def add(a, b):
    """Add two numbers and return the sum."""
    return a + b

# This simple function adds two numbers.
# We will let the AI call it for us!

function_schema = {
    "name": "add",
    "description": "Add two numbers.",
    "parameters": {
        "type": "object",
        "properties": {
            "a": {"type": "number"},
            "b": {"type": "number"}
        },
        "required": ["a", "b"]
    }
}

# This schema tells the model about the function and its arguments.

messages = [
    {"role": "user", "content": "What is three plus five?"}
]

# The user message is a simple math question.
# The model will decide if it wants to call our add function.

response = client.chat.completions.create(
    model="gpt-4.1",
    messages=messages,
    functions=[function_schema],
    function_call="auto"
)

# The model gets your message and your function schema.
# It can decide to output a function call if it thinks your code helps.

choice = response.choices[0]
if hasattr(choice, 'message') and hasattr(choice.message, 'function_call') and choice.message.function_call:
    fn_args = choice.message.function_call.arguments
    import json
    args = json.loads(fn_args)
    result = add(**args)
    print(f"Function called! Result: {result}")
else:
    print("No function call detected.")

# This block runs the function using arguments from the models output.
# It checks if function_call appears, parses arguments, runs your code, and shows the result.

num1 = input("Enter a number: ")
num2 = input("Enter another number: ")
prompt = f"Please add {num1} and {num2}."
user_msg = [{"role": "user", "content": prompt}]

# We collect numbers as strings from the user.
# Then, build a message for the AI to interpret and call the function.

response2 = client.chat.completions.create(
    model="gpt-4.1",
    messages=user_msg,
    functions=[function_schema],
    function_call="auto"
)

choice2 = response2.choices[0]
if hasattr(choice2, 'message') and hasattr(choice2.message, 'function_call') and choice2.message.function_call:
    fn_args2 = choice2.message.function_call.arguments
    import json
    args2 = json.loads(fn_args2)
    res2 = add(**args2)
    print(f"The answer is: {res2}")
else:
    print("No function call performed by the model.")

# We send your new message to the model.
# If it suggests a function call, we run it and show the answer.

forced_response = client.chat.completions.create(
    model="gpt-4.1",
    messages=messages,
    functions=[function_schema],
    function_call={"name": "add"}
)

# This forces the model to call the add function, even if it was unsure.

def greet(name):
    """Return a greeting for the given name."""
    return f"Hello, {name}!"

greet_schema = {
    "name": "greet",
    "description": "Create a personalized greeting.",
    "parameters": {
        "type": "object",
        "properties": {
            "name": {"type": "string"}
        },
        "required": ["name"]
    }
}

# This shows a new function and schema for greetings.
# You can let the model handle more than just math.

greet_msg = [
    {"role": "user", "content": "Say hello to Jamie."}
]

greet_resp = client.chat.completions.create(
    model="gpt-4.1",
    messages=greet_msg,
    functions=[greet_schema],
    function_call="auto"
)

g_choice = greet_resp.choices[0]
if hasattr(g_choice, 'message') and hasattr(g_choice.message, 'function_call') and g_choice.message.function_call:
    g_args = json.loads(g_choice.message.function_call.arguments)
    print(greet(**g_args))
else:
    print("No greeting function called.")

# The AI will now use the greet function if the prompt requests it.
# You will see a personal greeting rendered by your code and the AI working together!

chat_input = input("Ask anything for the chatbot: ")
chat_msg = [{"role": "user", "content": chat_input}]

combo_resp = client.chat.completions.create(
    model="gpt-4.1",
    messages=chat_msg,
    functions=[function_schema, greet_schema],
    function_call="auto"
)

combo_choice = combo_resp.choices[0]
if hasattr(combo_choice, 'message') and hasattr(combo_choice.message, 'function_call') and combo_choice.message.function_call:
    import json
    c_args = json.loads(combo_choice.message.function_call.arguments)
    fn_name = combo_choice.message.function_call.name
    if fn_name == "add":
        res = add(**c_args)
        print(f"Chatbot math result: {res}")
    elif fn_name == "greet":
        res = greet(**c_args)
        print(f"Chatbot greeting: {res}")
    else:
        print(f"Function {fn_name} not recognized.")
else:
    print("Model did not call a custom function.")

# Type a math question like 'What is 10 plus 22?' or ask for a greeting.
# The model will decide which of your functions to call and you see the output.