from typing import Literal
from pydantic import BaseModel, Field

class RouterOutput(BaseModel):
    """Structured output schema for the Router Agent decision."""
    output: Literal["GitHub", "Medium", "none"] = Field(
        description="The target destination node: 'GitHub' or 'Medium'. If neither is supported, use 'none'."
    )
    user_handle: str = Field(
        description="The extracted user profile handle corresponding to the destination."
    )

from typing import TypedDict, Optional
from langchain_openai import ChatOpenAI

class SharedState(TypedDict):
    query: str                      # Raw input query from the user
    user_handle: Optional[str]      # Handle extracted by the router
    destination: Optional[str]      # Selected target node string
    profile_summary: Optional[str]  # Generated markdown profile summary
    model: Optional[ChatOpenAI]     # Instantiated LLM reference

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

def build_model(state: SharedState) -> SharedState:
    """Node: Instantiates the LLM instance and stores it in the shared state."""
    llm = ChatOpenAI(model="gpt-4o", temperature=0)
    return {"model": llm}

def router_agent(state: SharedState) -> SharedState:
    """
    Node: Analyzes user query, classifies destination, and extracts user handle.
    Enforces output compliance with RouterOutput schema.
    """
    model = state["model"]
    
    # Enforce structured output parsing matching Pydantic schema
    structured_model = model.with_structured_output(RouterOutput)
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", (
            "You are an expert social media profile assistant.\n"
            "Based on the user query, determine whether to process their GitHub or Medium profile.\n"
            "Ensure your response strictly matches the RouterOutput schema."
        )),
        ("human", "{query}")
    ])
    
    chain = prompt | structured_model
    decision: RouterOutput = chain.invoke({"query": state["query"]})
    
    # Write extraction results to shared graph state
    return {
        "destination": decision.output,
        "user_handle": decision.user_handle
    }

from langchain_community.document_loaders import WebBaseLoader

def read_github_profile(user_handle: str) -> str:
    """Helper: Fetches raw page content from a GitHub user profile."""
    url = f"https://github.com/{user_handle}"
    loader = WebBaseLoader(url)
    docs = loader.load()
    combined_content = "\n".join([doc.page_content for doc in docs])
    return combined_content

def read_medium_profile(user_handle: str) -> str:
    """Helper: Fetches raw page content from a Medium user profile."""
    url = f"https://{user_handle}.medium.com"
    loader = WebBaseLoader(url)
    docs = loader.load()
    combined_content = "\n".join([doc.page_content for doc in docs])
    return combined_content

from langchain_core.prompts import ChatPromptTemplate

def summarize_github_profile(state: SharedState) -> SharedState:
    """Node: Extracts and summarizes GitHub profile content using a platform-specific prompt."""
    user_handle = state["user_handle"]
    model = state["model"]
    
    # Fetch raw unstructured context
    raw_content = read_github_profile(user_handle)
    
    # Specialized prompt localized to GitHub features
    prompt = ChatPromptTemplate.from_messages([
        ("system", (
            "You are an expert technical recruiter and open-source analyst.\n"
            "Summarize the following GitHub profile content in a concise, structured manner.\n"
            "Highlight key details: Name, Organization, Followers, Location, Contact Info, "
            "Key Skills, Top Projects, and Open-Source Contributions."
        )),
        ("human", "Profile Content:\n{content}")
    ])
    
    chain = prompt | model
    response = chain.invoke({"content": raw_content})
    
    return {"profile_summary": response.content}

def summarize_medium_profile(state: SharedState) -> SharedState:
    """Node: Extracts and summarizes Medium profile content using a writing-centric prompt."""
    user_handle = state["user_handle"]
    model = state["model"]
    
    # Fetch raw unstructured context
    raw_content = read_medium_profile(user_handle)
    
    # Specialized prompt localized to Medium publication metrics
    prompt = ChatPromptTemplate.from_messages([
        ("system", (
            "You are an expert editorial analyst.\n"
            "Summarize the following Medium profile content in a concise, structured manner.\n"
            "Highlight key details: Name, Followers, Posted Articles/Topics, and Profile Description."
        )),
        ("human", "Profile Content:\n{content}")
    ])
    
    chain = prompt | model
    response = chain.invoke({"content": raw_content})
    
    return {"profile_summary": response.content}

from langgraph.graph import END

def route_destination(state: SharedState) -> str:
    """
    Conditional Edge Decision Logic:
    Evaluates state['destination'] to determine the target graph node.
    """
    dest = state.get("destination")
    
    if dest == "GitHub":
        return "summarize_github_profile"
    elif dest == "Medium":
        return "summarize_medium_profile"
    else:
        # Fallback for unsupported domains (e.g. LinkedIn)
        return END

from langgraph.graph import StateGraph, START, END

def build_profile_summarizer_graph():
    builder = StateGraph(SharedState)
    
    # Register Graph Nodes
    builder.add_node("build_model", build_model)
    builder.add_node("router_agent", router_agent)
    builder.add_node("summarize_github_profile", summarize_github_profile)
    builder.add_node("summarize_medium_profile", summarize_medium_profile)
    
    # Establish Standard Edges
    builder.add_edge(START, "build_model")
    builder.add_edge("build_model", "router_agent")
    
    # Establish Conditional Edge from Router Agent
    builder.add_conditional_edges(
        "router_agent",
        route_destination,
        {
            "summarize_github_profile": "summarize_github_profile",
            "summarize_medium_profile": "summarize_medium_profile",
            END: END
        }
    )
    
    # Terminal Edges from Processing Nodes to Graph Exit
    builder.add_edge("summarize_github_profile", END)
    builder.add_edge("summarize_medium_profile", END)
    
    return builder.compile()

graph = build_profile_summarizer_graph()

input_state = {
    "query": "Can you summarize the GitHub profile for handle sorofP97?"
}

result = graph.invoke(input_state)

print(f"Destination Decision: {result['destination']}")
print(f"User Handle: {result['user_handle']}")
print(f"Profile Summary:\n{result['profile_summary']}")

Destination Decision: GitHub
User Handle: sorofP97
Profile Summary:
- Name: Sorov Pratik
- Username: sorofP97
- Organization: Google
- Previous Experience: GeeksforGeeks
- Followers: 171
- Key Skills: AI Engineering, Python, System Design
- Projects: LangChain Agents, LLM Workflows

input_state = {
    "query": "Please read and summarize the Medium profile for user SRBPTK97."
}

result = graph.invoke(input_state)

print(f"Destination Decision: {result['destination']}")
print(f"User Handle: {result['user_handle']}")
print(f"Profile Summary:\n{result['profile_summary']}")

Destination Decision: Medium
User Handle: SRBPTK97
Profile Summary:
- Name: Sorov Pratik
- Profile Type: Medium Author
- Followers: 250+
- Key Articles Posted:
  1. Principles of Clean Coding
  2. My Google Interview Experience
  3. System Design for AI Developers

input_state = {
    "query": "Summarize the LinkedIn profile for handle sorof-pratik."
}

result = graph.invoke(input_state)

if result.get("destination") == "none" or not result.get("profile_summary"):
    print("Execution Result: No suitable profile processor found for this request.")

Destination Decision: none
Execution Result: No suitable profile processor found for this request.