Grab APIfood.grab.com ↗

"""
GrabFood Indonesia API Client
Search restaurants and retrieve full menu listings from GrabFood Indonesia.
Get your API key from: https://parse.bot/settings
"""

import os
import requests
from typing import Optional, Any, Dict, List


class ParseClient:
    """Client for interacting with the GrabFood Indonesia API via Parse.bot."""

    def __init__(self, api_key: Optional[str] = None):
        """Initialize the Parse API client.

        Args:
            api_key: API key for authentication. If not provided, reads from PARSE_API_KEY env var.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "8c488b01-45f9-416b-a0f2-11dd465bf552"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")
        if not self.api_key:
            raise ValueError("API key must be provided or set in PARSE_API_KEY environment variable")

    def _call(self, endpoint: str, method: str = "POST", **params) -> Dict[str, Any]:
        """Make an API call to the Parse.bot scraper.

        Args:
            endpoint: The endpoint name (e.g., 'search_restaurants')
            method: HTTP method ('GET' or 'POST')
            **params: Parameters to pass to the endpoint

        Returns:
            The JSON response from the API

        Raises:
            requests.exceptions.RequestException: If the API call fails
        """
        url = f"{self.base_url}/scraper/{self.scraper_id}/{endpoint}"
        headers = {
            "X-API-Key": self.api_key,
            "Content-Type": "application/json"
        }

        if method.upper() == "GET":
            response = requests.get(url, headers=headers, params=params)
        else:
            response = requests.post(url, headers=headers, json=params)

        response.raise_for_status()
        return response.json()

    def search_restaurants(
        self,
        guest_token: str,
        latlng: str = "-6.1767352,106.826504",
        keyword: str = "",
        offset: int = 0,
        page_size: int = 32,
        country_code: str = "ID"
    ) -> Dict[str, Any]:
        """Search for GrabFood restaurants by location and optional keyword.

        Args:
            guest_token: Guest authentication token from browser sessionStorage
            latlng: Latitude,longitude for location-based search
            keyword: Search keyword to filter restaurants
            offset: Pagination offset
            page_size: Number of results per page
            country_code: Country code (default: ID for Indonesia)

        Returns:
            Dictionary containing total_count, offset, page_size, and restaurants list
        """
        return self._call(
            "search_restaurants",
            method="GET",
            guest_token=guest_token,
            latlng=latlng,
            keyword=keyword,
            offset=offset,
            page_size=page_size,
            country_code=country_code
        )

    def get_merchant_menu(
        self,
        guest_token: str,
        merchant_id: str,
        latlng: str = "-6.1767352,106.826504"
    ) -> Dict[str, Any]:
        """Get the full menu for a specific GrabFood merchant/restaurant.

        Args:
            guest_token: Guest authentication token from browser sessionStorage
            merchant_id: Merchant ID from search results
            latlng: Latitude,longitude for location context

        Returns:
            Dictionary containing merchant info and menu_items list
        """
        return self._call(
            "get_merchant_menu",
            method="GET",
            guest_token=guest_token,
            merchant_id=merchant_id,
            latlng=latlng
        )


def format_price(price_str: str) -> float:
    """Convert price display string to numeric value for comparison."""
    return float(price_str.replace("Rp", "").replace(".", "").strip())


def analyze_restaurant_menu(client: ParseClient, guest_token: str, restaurant: Dict[str, Any]) -> None:
    """Analyze and display menu analysis for a single restaurant."""
    print(f"\n{'='*80}")
    print(f"📊 MENU ANALYSIS: {restaurant['name']}")
    print(f"{'='*80}")

    menu_data = client.get_merchant_menu(
        guest_token=guest_token,
        merchant_id=restaurant['id']
    )

    # Basic info
    print(f"📍 Location: {menu_data['address']}")
    print(f"🍽️  Cuisine: {menu_data['cuisine']}")
    print(f"📋 Total Menu Items: {menu_data['total_menu_items']}")

    # Availability stats
    available_count = sum(1 for item in menu_data['menu_items'] if item['available'])
    top_sellers = [item for item in menu_data['menu_items'] if item['top_seller']]

    print(f"\n📊 Statistics:")
    print(f"   • Available items: {available_count}/{len(menu_data['menu_items'])}")
    print(f"   • Top sellers: {len(top_sellers)}")

    # Price analysis
    if menu_data['menu_items']:
        prices = []
        discounted_items = []

        for item in menu_data['menu_items']:
            if item['price_minor_unit']:
                prices.append(item['price_minor_unit'])
            if item['discounted_price_display']:
                discounted_items.append(item)

        if prices:
            min_price = min(prices) / 100_000
            max_price = max(prices) / 100_000
            avg_price = sum(prices) / len(prices) / 100_000
            print(f"   • Price range: Rp {min_price:.0f}K - Rp {max_price:.0f}K")
            print(f"   • Average price: Rp {avg_price:.0f}K")
            print(f"   • Items on sale: {len(discounted_items)}")

    # Display top sellers
    if top_sellers:
        print(f"\n🔥 Top Sellers (showing first 3):")
        for item in top_sellers[:3]:
            price = item['price_display']
            if item['discounted_price_display']:
                price = f"{item['discounted_price_display']} (was {item['price_display']})"
            print(f"   • {item['name']}: {price}")

    # Show categories and sample items
    print(f"\n📂 Menu Categories and Samples:")
    items_by_category = {}
    for item in menu_data['menu_items']:
        category = item['category']
        if category not in items_by_category:
            items_by_category[category] = []
        items_by_category[category].append(item)

    for category in menu_data['menu_categories'][:5]:  # Show first 5 categories
        if category in items_by_category:
            print(f"\n   {category} ({len(items_by_category[category])} items)")
            for item in items_by_category[category][:2]:  # Show first 2 items per category
                available_mark = "✓" if item['available'] else "✗"
                print(f"      {available_mark} {item['name'][:50]}")


if __name__ == "__main__":
    # Initialize the client
    client = ParseClient()

    # Replace with your actual guest token from GrabFood browser session
    # You can extract this from browser DevTools: sessionStorage.getItem('guest_token')
    GUEST_TOKEN = "your_guest_token_here"

    print("🚀 GrabFood Indonesia Restaurant Analyzer")
    print("=" * 80)

    try:
        # Step 1: Search for restaurants with a keyword
        print("\n🔍 Step 1: Searching for fried chicken restaurants in Jakarta...")
        search_results = client.search_restaurants(
            guest_token=GUEST_TOKEN,
            keyword="ayam goreng",
            page_size=5
        )

        total_found = search_results['total_count']
        restaurants = search_results['restaurants']

        print(f"✓ Found {total_found} total restaurants (showing {len(restaurants)} results)")

        # Step 2: Display search results summary
        print("\n" + "=" * 80)
        print("📋 SEARCH RESULTS SUMMARY")
        print("=" * 80)

        for i, restaurant in enumerate(restaurants, 1):
            print(f"\n{i}. {restaurant['name']}")
            print(f"   ID: {restaurant['id']}")
            print(f"   ⭐ Rating: {restaurant['rating']}/5 ({restaurant['vote_count']:,} votes)")
            print(f"   📏 Distance: {restaurant['distance_km']} km")
            print(f"   ⏱️  Delivery: {restaurant['estimated_delivery_time']} min")
            print(f"   💵 Delivery Fee: {restaurant['delivery_fee_display']}")
            print(f"   🍗 Cuisine: {', '.join(restaurant['cuisine'])}")
            if restaurant.get('promo'):
                print(f"   🎉 Promo: {restaurant['promo']}")
            print(f"   🕌 Halal: {'Yes' if restaurant['halal'] else 'No'}")

        # Step 3: Analyze menus for top restaurants
        print("\n\n" + "=" * 80)
        print("📊 DETAILED MENU ANALYSIS")
        print("=" * 80)

        # Analyze top 2 restaurants
        for restaurant in restaurants[:2]:
            try:
                analyze_restaurant_menu(client, GUEST_TOKEN, restaurant)
            except Exception as e:
                print(f"\n⚠️  Could not retrieve menu for {restaurant['name']}: {str(e)}")

        # Step 4: Comparison summary
        print("\n\n" + "=" * 80)
        print("📊 COMPARISON SUMMARY")
        print("=" * 80)

        print("\nRanking by Rating:")
        sorted_by_rating = sorted(restaurants, key=lambda x: x['rating'], reverse=True)
        for i, restaurant in enumerate(sorted_by_rating[:3], 1):
            print(f"   {i}. {restaurant['name']}: ⭐ {restaurant['rating']} ({restaurant['vote_count']} votes)")

        print("\nRanking by Delivery Time:")
        sorted_by_time = sorted(restaurants, key=lambda x: x['estimated_delivery_time'])
        for i, restaurant in enumerate(sorted_by_time[:3], 1):
            print(f"   {i}. {restaurant['name']}: ⏱️  {restaurant['estimated_delivery_time']} min")

        print("\nRanking by Delivery Fee:")
        def extract_fee(fee_str):
            return float(fee_str.replace("Rp", "").replace(".", "").strip())

        sorted_by_fee = sorted(restaurants, key=lambda x: extract_fee(x['delivery_fee_display']))
        for i, restaurant in enumerate(sorted_by_fee[:3], 1):
            print(f"   {i}. {restaurant['name']}: {restaurant['delivery_fee_display']}")

        print("\n✅ Analysis completed successfully!")

    except ValueError as e:
        print(f"❌ Configuration Error: {e}")
        print("   Please set your API key: export PARSE_API_KEY='your_api_key_here'")
    except requests.exceptions.RequestException as e:
        print(f"❌ API Error: {e}")
        print("   Please verify your guest token and try again.")
    except Exception as e:
        print(f"❌ Unexpected error: {e}")