Reserved APIreserved.com ↗

"""
Reserved Hungary API Client using Parse
Get your API key from: https://parse.bot/settings
"""

import os
import requests
from typing import Any, Optional


class ParseClient:
    """Client for interacting with Reserved Hungary API through Parse."""
    
    def __init__(self, api_key: Optional[str] = None):
        """Initialize the Parse client with API credentials."""
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "0216d37e-57d9-471f-9b8b-dc6e4c2e809f"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")
        
        if not self.api_key:
            raise ValueError(
                "API key not provided. Set PARSE_API_KEY environment variable "
                "or pass api_key parameter."
            )
    
    def _call(self, endpoint: str, method: str = "POST", **params) -> dict:
        """Make API call to Parse endpoint."""
        url = f"{self.base_url}/scraper/{self.scraper_id}/{endpoint}"
        headers = {
            "X-API-Key": self.api_key,
            "Content-Type": "application/json"
        }
        
        if method == "GET":
            response = requests.get(url, headers=headers, params=params)
        elif method == "POST":
            response = requests.post(url, headers=headers, json=params)
        else:
            raise ValueError(f"Unsupported HTTP method: {method}")
        
        response.raise_for_status()
        return response.json()
    
    def get_homepage(self) -> dict:
        """Fetch the Reserved Hungary homepage information and promotional banners."""
        return self._call("get_homepage", method="GET")
    
    def list_categories(self) -> dict:
        """Return the full category tree with IDs, names, URLs, and nested children."""
        return self._call("list_categories", method="GET")
    
    def list_products(
        self,
        category_id: str,
        page: int = 0,
        limit: int = 200,
        sort_by: Optional[str] = None,
        min_price: Optional[int] = None,
        max_price: Optional[int] = None,
        colors: Optional[str] = None,
        sizes: Optional[str] = None
    ) -> dict:
        """
        List products in a given category with pagination and filtering.
        
        Args:
            category_id: Category ID from list_categories
            page: Zero-based page index (default: 0)
            limit: Number of results per page (default: 200)
            sort_by: Sort order ID
            min_price: Minimum price filter in HUF
            max_price: Maximum price filter in HUF
            colors: Comma-separated color slugs
            sizes: Comma-separated size slugs
        
        Returns:
            Product list with pagination info
        """
        params = {
            "category_id": category_id,
            "page": page,
            "limit": limit
        }
        
        if sort_by:
            params["sort_by"] = sort_by
        if min_price is not None:
            params["min_price"] = min_price
        if max_price is not None:
            params["max_price"] = max_price
        if colors:
            params["colors"] = colors
        if sizes:
            params["sizes"] = sizes
        
        return self._call("list_products", method="GET", **params)
    
    def search_products(
        self,
        query: str,
        page: int = 0,
        limit: int = 20
    ) -> dict:
        """
        Search for products across all categories.
        
        Args:
            query: Search keyword
            page: Zero-based page index (default: 0)
            limit: Number of results per page (default: 20)
        
        Returns:
            Search results from Algolia index
        """
        return self._call(
            "search_products",
            method="GET",
            query=query,
            page=page,
            limit=limit
        )
    
    def get_product_detail(self, sku: str) -> dict:
        """
        Fetch detailed product information by SKU.
        
        Args:
            sku: Product SKU (e.g., '334HK-00X')
        
        Returns:
            Detailed product information
        """
        return self._call("get_product_detail", method="GET", sku=sku)
    
    def check_store_availability(
        self,
        product_id: str,
        size_id: str,
        location: str = "Budapest"
    ) -> dict:
        """
        Check availability of a specific product size in physical stores.
        
        Args:
            product_id: Numeric product ID
            size_id: Numeric size ID
            location: City or location string (default: "Budapest")
        
        Returns:
            Availability status and store details
        """
        return self._call(
            "check_store_availability",
            method="POST",
            product_id=product_id,
            size_id=size_id,
            location=location
        )


def main():
    """Practical workflow demonstrating API usage."""
    client = ParseClient()
    
    print("=" * 60)
    print("Reserved Hungary API - Practical Workflow")
    print("=" * 60)
    
    # Step 1: Get homepage info
    print("\n1. Fetching homepage information...")
    homepage = client.get_homepage()
    if homepage.get("status") == "success":
        homepage_data = homepage.get("data", {})
        print(f"   Status: {homepage_data.get('status')}")
        print(f"   Title: {homepage_data.get('title')}")
        print(f"   Banners found: {len(homepage_data.get('banners', []))}")
    
    # Step 2: Get categories
    print("\n2. Fetching product categories...")
    categories_response = client.list_categories()
    categories_data = categories_response.get("data", {})
    categories = categories_data.get("categories", [])
    print(f"   Found {len(categories)} top-level categories")
    
    # Find Women's category
    women_category = None
    for cat in categories:
        if cat.get("system_name") == "WOMAN":
            women_category = cat
            break
    
    if women_category:
        print(f"   Women's category ID: {women_category.get('id')}")
        print(f"   Women's subcategories: {len(women_category.get('children', []))}")
    
    # Step 3: Search for a specific product
    print("\n3. Searching for 'ruha' (dress)...")
    search_response = client.search_products(query="ruha", limit=5)
    search_data = search_response.get("data", {})
    results = search_data.get("results", [])
    
    if results and results[0].get("hits"):
        hits = results[0]["hits"]
        print(f"   Found {results[0].get('nbHits')} total results")
        print(f"   Displaying {len(hits)} results on this page:")
        
        # Get details for first search result
        if hits:
            first_hit = hits[0]
            sku = first_hit.get("sku")
            product_name = first_hit.get("name")
            price = first_hit.get("final_price")
            
            print(f"\n4. Getting detailed info for: {product_name}")
            try:
                detail_response = client.get_product_detail(sku=sku)
                detail_data = detail_response.get("data", {})
                
                print(f"   SKU: {detail_data.get('sku')}")
                print(f"   Price: {detail_data.get('final_price')} HUF")
                print(f"   Available sizes: {', '.join(detail_data.get('sizes', []))}")
                
                description = detail_data.get("description", "")
                if description:
                    print(f"   Description: {description[:100]}...")
                
                features = detail_data.get("features", {})
                if features:
                    print(f"   Features:")
                    for feature_key, feature_values in list(features.items())[:2]:
                        print(f"      - {feature_key}: {', '.join(feature_values)}")
            except Exception as e:
                print(f"   Error fetching product details: {e}")
    
    # Step 5: List products from Women's category
    if women_category:
        print(f"\n5. Listing products from Women's category...")
        women_cat_id = women_category.get("id")
        products_response = client.list_products(
            category_id=women_cat_id,
            page=0,
            limit=3
        )
        products_data = products_response.get("data", {})
        products = products_data.get("products", [])
        total = products_data.get("productsTotalAmount", 0)
        
        print(f"   Total products in category: {total}")
        print(f"   Showing {len(products)} on this page:")
        
        for product in products:
            name = product.get("name")
            sku = product.get("sku")
            price = product.get("final_price", product.get("price"))
            has_discount = product.get("has_discount", False)
            
            discount_indicator = " (DISCOUNTED!)" if has_discount else ""
            print(f"   - {name} ({sku}): {price} HUF{discount_indicator}")
    
    print("\n" + "=" * 60)
    print("Workflow complete!")
    print("=" * 60)


if __name__ == "__main__":
    main()