from dotenv import load_dotenv
import os
import openai
import time
import json
import sys
import requests

# Load environment variables from .env file
load_dotenv()


def get_work_text(url, section_num):
    # Define the API endpoint
    api_url = "http://172.104.23.176/dbadmin/aiapi_worktext.php?"
    
    # Define your query parameters
    params = {
        'url': url,
        'section': section_num
    }
    
    # Make the HTTP GET request to the PHP API
    response = requests.get(api_url, params=params)
    
    # Check if the request was successful
    if response.status_code == 200:
        # Parse the JSON response
        work_text = response.json()
        return work_text
    else:
        # Handle errors (you may want to add more robust error handling)
        print("Error fetching work text:", response.status_code)
        return None

# Set your OpenAI API key
openai.api_key = os.getenv('OPENAI_API_KEY')


# Define tools
tools_list=[{
    "type": "function",
    "function": {
    "name": "get_work_text",
    "description": "Get the text of a section of exposition by url and section number",
    "parameters": {
        "type": "object",
        "properties": {
        "url": {"type": "string", "description": "the url of the exposition work"},
        "section": {"type": "string", "description": "the section number"}
        },
        "required": ["url", "section"]
    }   
    }
},
]

def create_thread(input):
    # Step 1: Retrieve the assistant
    assistant = client.beta.assistants.retrieve("asst_XfcBJIjJvnXK7w1jtnHhVNc3")

    # Step 2: Create a Thread
    thread = client.beta.threads.create()

    # Step 3: Add a Message to a Thread
    message = client.beta.threads.messages.create(
        thread_id=thread.id,
        role="user",
        content=input # Here is the new message
    )

    # Step 4: Run the Assistant
    run = client.beta.threads.runs.create(
        thread_id=thread.id,
        assistant_id=assistant.id,
    )

    # print(run.model_dump_json(indent=4))

    while True:
        # Wait for 5 seconds
        time.sleep(5)

        # Retrieve the run status
        run_status = client.beta.threads.runs.retrieve(
            thread_id=thread.id,
            run_id=run.id
        )
        # print(run_status.model_dump_json(indent=4))

        # If run is completed, get messages
        if run_status.status == 'completed':
            messages = client.beta.threads.messages.list(
                thread_id=thread.id
            )

            message_history = []
            # Loop through messages and print content based on role
            for msg in messages.data:
                role = msg.role
                content = msg.content[0].text.value
                message_history.append(f"{role.capitalize()}: {content}")

            return message_history
        elif run_status.status == 'requires_action':
            print("Function Calling")
            required_actions = run_status.required_action.submit_tool_outputs.model_dump()
            print(required_actions)
            tool_outputs = []
            import json
            for action in required_actions["tool_calls"]:
                func_name = action['function']['name']
                arguments = json.loads(action['function']['arguments'])
                
                if func_name == "get_work_text":
                    output = get_work_text(url=arguments['url'],section_num=arguments['section'])
                    output_text = output['text']
                    tool_outputs.append({
                        "tool_call_id": action['id'],
                        "output": output_text
                    })
                    print (output)
                else:
                    raise ValueError(f"Unknown function: {func_name}") 
            print("Submitting outputs back to the Assistant...")
            client.beta.threads.runs.submit_tool_outputs(
                thread_id=thread.id,
                run_id=run.id,
                tool_outputs=tool_outputs
            )
        elif run_status.status == 'in_progress':
            print("Waiting for the Assistant to process...")
            time.sleep(5)
        elif run_status.status == 'queued':
            print("Waiting for the Assistant to process... Thinking takes time.")
            time.sleep(5)
        elif run_status.status == 'failed':
            print("Run Failed. The OpenAI assistants API is still in beta.")
        else:
            
            print(last_error)
            return ("Hmm, the run seems to have expired or failed.")

# Code Start ---------------

# Initialize the client
client = openai.OpenAI()

# Input from system arguments
user_question = sys.argv[1]
create_thread(user_question)