import os
import time
import random
import logging
import importlib.util
from pathlib import Path
import threading

# Set up logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# Define directories
ROOT_DIR = Path(__file__).parent / "app"
AGENTS_DIR = ROOT_DIR / "agents"
TOOLS_DIR = ROOT_DIR / "tools"
TOOLKIT_DIR = ROOT_DIR / "toolkit"
AGENT_POOL_DIR = ROOT_DIR / "agent_pool"

# Create directories
AGENTS_DIR.mkdir(parents=True, exist_ok=True)
TOOLS_DIR.mkdir(parents=True, exist_ok=True)
TOOLKIT_DIR.mkdir(parents=True, exist_ok=True)
AGENT_POOL_DIR.mkdir(parents=True, exist_ok=True)

def generate_agent(agent_name: str) -> str:
    logger.info(f"Generating agent: {agent_name}")
    agent_code = f"""
class {agent_name}:
    def __init__(self):
        self.name = '{agent_name}'

    def run(self):
        print("Running {agent_name}...")
"""
    agent_path = AGENTS_DIR / f"{agent_name}.py"
    with open(agent_path, 'w') as f:
        f.write(agent_code)
    
    with open(AGENT_POOL_DIR / "agent_pool.txt", 'a') as f:
        f.write(f"{agent_name}\n")
    
    return agent_path

def generate_tool(tool_name: str) -> str:
    logger.info(f"Generating tool: {tool_name}")
    tool_code = f"""
def {tool_name}():
    print("Executing tool: {tool_name}")
"""
    tool_path = TOOLS_DIR / f"{tool_name}.py"
    with open(tool_path, 'w') as f:
        f.write(tool_code)
    
    with open(TOOLKIT_DIR / "toolkit.txt", 'a') as f:
        f.write(f"{tool_name}\n")
    
    return tool_path

def get_agents():
    agent_pool = AGENT_POOL_DIR / "agent_pool.txt"
    if not agent_pool.exists():
        return []
    with open(agent_pool, 'r') as f:
        return [line.strip() for line in f.readlines()]

def get_tools():
    toolkit = TOOLKIT_DIR / "toolkit.txt"
    if not toolkit.exists():
        return []
    with open(toolkit, 'r') as f:
        return [line.strip() for line in f.readlines()]

def display_agents():
    agents = get_agents()
    print("\n=== Agent Catalog ===")
    for idx, agent in enumerate(agents, 1):
        print(f"{idx}. {agent}")
    print("=====================")
    return agents

def display_tools():
    tools = get_tools()
    print("\n=== Tool Inventory ===")
    for idx, tool in enumerate(tools, 1):
        print(f"{idx}. {tool}")
    print("======================")
    return tools

def summon_agent(agent_name):
    agent_file = AGENTS_DIR / f"{agent_name}.py"
    if not agent_file.exists():
        print(f"Agent {agent_name} not found!")
        return
    
    try:
        spec = importlib.util.spec_from_file_location(agent_name, agent_file)
        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)
        agent_class = getattr(module, agent_name)
        agent_instance = agent_class()
        agent_instance.run()
    except Exception as e:
        print(f"Error summoning agent: {str(e)}")

def summon_tool(tool_name):
    tool_file = TOOLS_DIR / f"{tool_name}.py"
    if not tool_file.exists():
        print(f"Tool {tool_name} not found!")
        return
    
    try:
        spec = importlib.util.spec_from_file_location(tool_name, tool_file)
        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)
        tool_func = getattr(module, tool_name)
        tool_func()
    except Exception as e:
        print(f"Error executing tool: {str(e)}")

def user_interface():
    while True:
        print("\nMain Menu:")
        print("1. List Agents")
        print("2. List Tools")
        print("3. Summon Agent")
        print("4. Execute Tool")
        print("5. Exit")
        
        choice = input("Select an option (1-5): ").strip()
        
        if choice == '1':
            display_agents()
        elif choice == '2':
            display_tools()
        elif choice == '3':
            agents = get_agents()
            if not agents:
                print("No agents available!")
                continue
            display_agents()
            try:
                num = int(input("Enter agent number: "))
                if 1 <= num <= len(agents):
                    summon_agent(agents[num-1])
                else:
                    print("Invalid number!")
            except ValueError:
                print("Please enter a valid number!")
        elif choice == '4':
            tools = get_tools()
            if not tools:
                print("No tools available!")
                continue
            display_tools()
            try:
                num = int(input("Enter tool number: "))
                if 1 <= num <= len(tools):
                    summon_tool(tools[num-1])
                else:
                    print("Invalid number!")
            except ValueError:
                print("Please enter a valid number!")
        elif choice == '5':
            os._exit(0)
        else:
            print("Invalid option!")

def main():
    logger.info("Starting autonomous generation system...")
    ui_thread = threading.Thread(target=user_interface, daemon=True)
    ui_thread.start()
    
    while True:
        if random.choice([True, False]):
            agent_name = f"Agent{random.randint(1, 1000)}"
            generate_agent(agent_name)
        else:
            tool_name = f"Tool{random.randint(1, 1000)}"
            generate_tool(tool_name)
        time.sleep(5)

if __name__ == "__main__":
    main()