graph.py

import requests
import os
from dotenv import load_dotenv


from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage


from crawler import Crawler
from models import ReviewAnalysis, State
from prompts import RecommendationPrompts
from chroma_cache import Cache





REVIEW_KEYWORDS = ["review", "verdict", "critics", "analysis", "rating"]
REVIEW_DOMAINS = ["ign.com", "rottentomatoes.com", "metacritic.com", "theverge.com", "polygon.com", "gamespot.com", "filmcompanion.in"]
SUMMARY_DOMAINS = ["wikipedia.org", "imdb.com", "fandom.com", "rottentomatoes.com", "metacritic.com"]




class Graph:

    def __init__(self):
        load_dotenv
        self.crawler = Crawler()
        self.llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.1)
        self.prompts = RecommendationPrompts()
        self.graph = self._build_graph()
        self.cache = Cache()






    def _build_graph(self):
        graph = StateGraph(State)

        graph.add_node("check_cache_step", self.search_cache)
        graph.add_node("router", self.router)
        graph.add_node("search_media_step", self.search_media)
        graph.add_node("search_analyze_step", self.search_reviews)
        graph.add_node("recommend_step", self.recommendation_step)
     

        graph.set_entry_point("check_cache_step")
        graph.add_edge("check_cache_step", "router")

        graph.add_conditional_edges(
            "router",
            lambda state: state.next,
            path_map={"cache_hit": END, "cache_miss" : "search_media_step"}
        )
        graph.add_edge("search_media_step", "search_analyze_step")
        graph.add_edge("search_analyze_step", "recommend_step")
        graph.add_edge("recommend_step", END)

        return graph.compile()
    

    def search_cache(self, state: State):

        cached_summary = self.cache.semantic_lookup(state.title)

        if cached_summary:
            print(f"[Semantic Cache HIT] Summary and Analysis for '{state.title}'" )    
            stored_summary = cached_summary[0]['summary']
            stored_analysis = cached_summary[0]['analysis']

            return {"summary": stored_summary, "analysis": stored_analysis}
        
        print(f"[Semantic Cache MISS] Summary for '{state.title}'")     

        return {}
    
    
    def router(self, state: State):
        if state.summary and state.analysis:
            return {"next": "cache_hit"}
        
        return {"next": "cache_miss"}

    
    async def search_media(self, state: State):

        
        search_query = f"{state.title}"

        headers = {
            "X-API-KEY": os.getenv("SERPER_API_KEY"),
            "Content-Type": "application/json"
        }
        payload = {"q": search_query}

        response = requests.post("https://google.serper.dev/search", headers=headers, json=payload)
        response.raise_for_status()
        data = response.json()


        for result in data.get("organic", []):
            url = result.get("link", "").lower()
            if any(domain in url for domain in SUMMARY_DOMAINS):
                search_link = result["link"]
                break


        scraped = await self.crawler.scrape_review_pages(search_link)

        messages = [
            SystemMessage(content=self.prompts.SUMMARY_SYSTEM),
            HumanMessage(content=self.prompts.summary_analysis_user(state.title, scraped))
        ]

        response = self.llm.invoke(messages)

        return {"summary": response.content}




    async def search_reviews(self, state: State):

        search_query = f"{state.title} reviews"
        results = []


        headers = {
            "X-API-KEY": os.getenv("SERPER_API_KEY"),
            "Content-Type": "application/json"
        }
        payload = {"q": search_query}

        try:
            response = requests.post("https://google.serper.dev/search", headers=headers, json=payload)
            response.raise_for_status()
            data = response.json()


            filtered_links = []
            for item in data.get("organic", []):
                url = item.get("link", "").lower()
                snippet = (item.get("snippet") or "").lower()

                if "youtube.com" in url or "youtu.be" in url:
                    continue

                if any(k in url for k in REVIEW_KEYWORDS) or any(k in snippet for k in REVIEW_KEYWORDS) or any(domain in url for domain in REVIEW_DOMAINS):
                    filtered_links.append(item.get("link"))

                if len(filtered_links) >= 6:
                    break            

            # Top 3 organic results
            for url in filtered_links:
                scraped = await self.crawler.scrape_review_pages(url)
                if scraped:
                    results.append({
                        "url": url,
                        "content": scraped
                    })

        except Exception as e:
            print(f"[Serper Error] {e}")   



        reviews = []
        for result in results:

            analysis = self.analyze_reviews(state.title, result['content'])
            reviews.append(analysis)

        return {"reviews": reviews}





    def analyze_reviews(self, name: str, content: str) -> ReviewAnalysis:

        structured_llm = self.llm.with_structured_output(ReviewAnalysis)

        messages = [
            SystemMessage(content=self.prompts.REVIEW_ANALYSIS_SYSTEM),
            HumanMessage(content=self.prompts.review_analysis_user(name, content))
        ]

        try:
            analysis = structured_llm.invoke(messages)
            return analysis
        except Exception as e:
            print(e)
            return ReviewAnalysis(
                title="Unknown",
                platform="Unknown",
                average_rating="",
                original_rating="",
                summary="",
                sentiment=None,
                pros="",
                cons="",
                website=""
            )
        

    def recommendation_step(self, state: State):

        title = state.title
        summary = state.summary
        reviews = state.reviews

        messages = [
            SystemMessage(content=self.prompts.RECOMMENDATION_SYSTEM),
            HumanMessage(content=self.prompts.recommendation_user(title, reviews))
        ]

        response = self.llm.invoke(messages)

        self.cache.store_review(title=title, summary=summary, analysis=response.content)

        return {"analysis": response.content}
    
    async def run(self, query: str) -> State:
        initial_state = State(title=query)
        final_state = await self.graph.ainvoke(initial_state)
        return State(**final_state)