import importlib.metadata

# List the distribution package names
packages = ["langchain", "langchain-community", "langchain-openai", 
            "llama-index", "langgraph","langchain_core"]

for package in packages:
    try:
        version = importlib.metadata.version(package)
        print(f"{package} version: {version}")
    except importlib.metadata.PackageNotFoundError:
        print(f"{package} is not installed in this environment.")

import os
import math
from datetime import datetime

# ── LangChain 1.x Agent API ──────────────────────────────────────────────────
from langchain.agents import create_agent          # NEW in 1.x — replaces AgentExecutor

# ── LLM ──────────────────────────────────────────────────────────────────────
from langchain_openai import ChatOpenAI

# ── Tools ─────────────────────────────────────────────────────────────────────
from langchain_core.tools import tool

# ── Messages (used for input and memory) ──────────────────────────────────────
from langchain_core.messages import HumanMessage, AIMessage

# ── Memory (optional, for multi-turn conversations) ───────────────────────────
from langgraph.checkpoint.memory import MemorySaver

print("✅ All imports successful!")

import os
from dotenv import load_dotenv

# This automatically searches for and loads your .env file
load_dotenv() 

OPENAI_API_KEY = os.environ["OPENAI_API_KEY"] 

llm = ChatOpenAI(
    api_key=OPENAI_API_KEY,
    model="gpt-4o-mini",
    temperature=0     # deterministic output — best for tool-calling agents
)

response = llm.invoke("Hello! Respond with just the word 'Success' if you can read this.")
print("LLM Response:", response.content)

print("LLM ready!")

# ── Tool 1: Calculator 
@tool
def calculator(expression: str) -> str:
    """
    Evaluates a mathematical expression and returns the result.
    Use this for any arithmetic or math calculation.
    Supports: +, -, *, /, ** (power), sqrt(), sin(), cos(), log(), pi, e.
    Examples: '2 + 2', 'sqrt(144)', '3 ** 4', '100 / 7', 'pi * 5 ** 2'
    """
    try:
        safe_env = {k: v for k, v in math.__dict__.items() if not k.startswith('_')}
        result = eval(expression, {"__builtins__": {}}, safe_env)
        return f"Result: {result}"
    except Exception as e:
        return f"Error: {e}"


# ── Tool 2: Word Counter
@tool
def word_counter(text: str) -> str:
    """
    Counts the number of words, characters, and sentences in a given text.
    Use this when the user wants statistics or analysis of a piece of text.
    """
    words = len(text.split())
    chars_with = len(text)
    chars_without = len(text.replace(" ", ""))
    sentences = len([s for s in text.split(".") if s.strip()])
    return (
        f"Words: {words}\n"
        f"Characters (with spaces): {chars_with}\n"
        f"Characters (without spaces): {chars_without}\n"
        f"Approximate sentences: {sentences}"
    )


# ── Tool 3: Date and Time 
@tool
def get_current_datetime(format: str = "full") -> str:
    """
    Returns the current date and/or time.
    Use this when the user asks about today's date, current time, day of week, or year.
    format options:
      'full'  → both date and time (default)
      'date'  → date only
      'time'  → time only
    """
    now = datetime.now()
    if format == "date":
        return now.strftime("Date: %A, %B %d, %Y")
    elif format == "time":
        return now.strftime("Time: %H:%M:%S")
    return now.strftime("Date & Time: %A, %B %d, %Y at %H:%M:%S")


# ── Tool 4: Unit Converter 
@tool
def unit_converter(value: float, from_unit: str, to_unit: str) -> str:
    """
    Converts a value from one unit to another.
    Use this for any unit conversion task.

    Supported categories:
      Temperature : celsius, fahrenheit, kelvin
      Length      : meters, kilometers, miles, feet, inches
      Weight      : grams, kg, kilograms, pounds

    Example call: value=100, from_unit='celsius', to_unit='fahrenheit'
    """
    f = from_unit.lower().strip()
    t = to_unit.lower().strip()

    # Temperature (special-cased)
    temp = {"celsius", "fahrenheit", "kelvin"}
    if f in temp or t in temp:
        try:
            if f == "celsius" and t == "fahrenheit":
                r = value * 9/5 + 32
            elif f == "fahrenheit" and t == "celsius":
                r = (value - 32) * 5/9
            elif f == "celsius" and t == "kelvin":
                r = value + 273.15
            elif f == "kelvin" and t == "celsius":
                r = value - 273.15
            elif f == "fahrenheit" and t == "kelvin":
                r = (value - 32) * 5/9 + 273.15
            elif f == "kelvin" and t == "fahrenheit":
                r = (value - 273.15) * 9/5 + 32
            else:
                return f"Cannot convert {f} to {t}"
            return f"{value} {f} = {round(r, 4)} {t}"
        except Exception as e:
            return str(e)

    # Other units → convert via base unit
    to_base = {
        "meters": 1.0, "kilometers": 1000.0, "miles": 1609.34,
        "feet": 0.3048, "inches": 0.0254,
        "grams": 1.0, "kg": 1000.0, "kilograms": 1000.0, "pounds": 453.592,
    }
    if f in to_base and t in to_base:
        result = value * to_base[f] / to_base[t]
        return f"{value} {f} = {round(result, 6)} {t}"

    return f"Conversion from '{from_unit}' to '{to_unit}' is not supported."


# ── Collect tools
tools = [calculator, word_counter, get_current_datetime, unit_converter]

print("✅ Tools defined:")
for t in tools:
    print(f"   • {t.name}")

SYSTEM_PROMPT = """You are a helpful assistant with access to tools.
Always use a tool when the question involves math, dates, unit conversion, or text analysis.
Think step by step. Never guess a number — calculate it."""

# create_agent builds the agent graph automatically
# It handles the Thought → Action → Observation loop internally
agent = create_agent(
    model=llm,
    tools=tools,
    system_prompt=SYSTEM_PROMPT
)

print("Agent created! Type:", type(agent).__name__)
print("   .invoke() and .stream() are both available.")

def ask(question: str, config: dict = None) -> str:
    """
    Send a single question to the agent and return the final answer.
    config is used for memory (thread_id) — see Step 8.
    """
    kwargs = {"messages": [HumanMessage(content=question)]}
    result = agent.invoke(kwargs, config=config)
    # The last message in the output is always the final AI response
    return result["messages"][-1].content

print("Helper ready!")

answer = ask("What is the square root of 1764? Then square that result.")
print("🤖", answer)

answer = ask("What is today's date and what day of the week is it?")
print("🤖", answer)

answer = ask("Convert 37 degrees Celsius to Fahrenheit. Is that a fever?")
print("🤖", answer)

answer = ask(
    "If I invest 5000 dollars at 8% annual compound interest for 10 years, "
    "how much will I have? Also, what year will that be?"
)
print("🤖", answer)

sample = (
    "Artificial intelligence is transforming industries worldwide. "
    "From healthcare to finance, companies are adopting machine learning rapidly. "
    "Researchers continue pushing the boundaries of what is possible with neural networks."
)
answer = ask(f"Count the words and characters in this text: '{sample}'")
print("🤖", answer)

def ask_verbose(question: str):
    """Ask the agent and print every intermediate step."""
    print(f"❓ Question: {question}")
    print("=" * 60)

    step_num = 0
    final_answer = ""

    for chunk in agent.stream(
        {"messages": [HumanMessage(content=question)]},
        stream_mode="updates"
    ):
        for node_name, node_output in chunk.items():
            messages = node_output.get("messages", [])
            for msg in messages:
                # Tool call requests (agent deciding which tool to use)
                if hasattr(msg, "tool_calls") and msg.tool_calls:
                    step_num += 1
                    for tc in msg.tool_calls:
                        print(f"\n🔧 Step {step_num} — Tool Call")
                        print(f"   Tool  : {tc['name']}")
                        print(f"   Input : {tc['args']}")

                # Tool results (observation)
                elif hasattr(msg, "name") and msg.name is not None:
                    print(f"   Result: {msg.content}")

                # Final AI text response
                elif hasattr(msg, "content") and msg.content and not hasattr(msg, "tool_calls"):
                    final_answer = msg.content

    print("\n" + "=" * 60)
    print("FINAL ANSWER:", final_answer)
    print("=" * 60)


# Try it out
ask_verbose(
    "A room is 5 meters by 4 meters. "
    "What is its area in square meters, and convert that to square feet? "
    "(1 meter = 3.28084 feet)"
)

# Create a fresh agent WITH memory
memory = MemorySaver()

agent_with_memory = create_agent(
    model=llm,
    tools=tools,
    system_prompt=SYSTEM_PROMPT,
    checkpointer=memory      # ← this enables multi-turn memory
)

# Each "conversation" is identified by a thread_id
SESSION_CONFIG = {"configurable": {"thread_id": "student-session-1"}}

def chat(question: str) -> str:
    """Chat with the memory-enabled agent."""
    result = agent_with_memory.invoke(
        {"messages": [HumanMessage(content=question)]},
        config=SESSION_CONFIG
    )
    return result["messages"][-1].content

print("Memory-enabled agent ready!")

# Turn 1
r1 = chat("What is 250 miles in kilometers?")
print("🤖", r1)

# Turn 2 — refers to the previous answer; agent should REMEMBER '250 miles'
r2 = chat("Now convert that same distance to feet.")
print("🤖", r2)

# Turn 3 — chains off the previous context
r3 = chat("If I drive at 100 km/h, how many hours to cover that distance?")
print("🤖", r3)

# No tool needed — LLM answers from knowledge
print("── Case 1: No tool needed ──")
print(ask("What is the capital of France?"))

# Chained reasoning across tools
print("── Case 2: Multi-step chained reasoning ──")
print(ask(
    "Find 15% of 340. Then convert that number from USD to INR "
    "using an exchange rate of 83 (i.e. multiply by 83)."
))