Co APItickets.cinema-city.co.il ↗

"""
Cinema City Israel Schedule API Client
Get your API key from: https://parse.bot/settings
"""

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


class ParseClient:
    """Client for interacting with the Parse API for Cinema City Israel schedules."""

    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 = "222a3403-419e-4566-b9fe-f848e9a705ff"
        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 API.

        Args:
            endpoint: The endpoint name (e.g., "get_schedule")
            method: HTTP method ("GET" or "POST")
            **params: Query/body parameters for the API call

        Returns:
            Parsed JSON response from the API

        Raises:
            requests.RequestException: If the API request 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:  # POST
            response = requests.post(url, headers=headers, json=params)

        response.raise_for_status()
        return response.json()

    def get_schedule(
        self,
        location_id: str = "0",
        include_synopsis: str = "0"
    ) -> Dict[str, List[Dict[str, Any]]]:
        """
        Get the full cinema schedule grouped by branch name.

        Args:
            location_id: Numeric location ID to filter by branch. Use "0" for all branches.
                        Known IDs: 1173 (Rishon LeZion), 1176 (Netanya), 1178 (Beer Sheva),
                        1170 (Glilot), 1181 (Ashdod)
            include_synopsis: Whether to include movie synopsis ("0" or "1")

        Returns:
            Dictionary with branch names as keys and lists of movies as values.
            Each movie contains: movie_title, showtimes, and booking_links
        """
        params = {
            "location_id": location_id,
            "include_synopsis": include_synopsis
        }
        return self._call("get_schedule", method="GET", **params)


def print_cinema_schedule(schedule: Dict[str, List[Dict[str, Any]]], branch_filter: Optional[str] = None):
    """
    Pretty print the cinema schedule.

    Args:
        schedule: Schedule dictionary from the API
        branch_filter: Optional branch name to filter by
    """
    for branch_name, movies in schedule.items():
        if branch_filter and branch_filter.lower() not in branch_name.lower():
            continue

        print(f"\n{'='*60}")
        print(f"🎬 {branch_name}")
        print(f"{'='*60}")

        for movie in movies:
            movie_title = movie.get("movie_title", "Unknown")
            showtimes = movie.get("showtimes", [])
            booking_links = movie.get("booking_links", [])

            print(f"\n  📽️  {movie_title}")
            print(f"     Showtimes:")
            for i, showtime in enumerate(showtimes):
                try:
                    dt = datetime.strptime(showtime, "%Y-%m-%d %H:%M")
                    formatted_time = dt.strftime("%a %d/%m at %H:%M")
                    booking_link = booking_links[i] if i < len(booking_links) else "N/A"
                    print(f"       • {formatted_time} - 🎫 {booking_link}")
                except (ValueError, IndexError):
                    print(f"       • {showtime}")

        print(f"\n{'-'*60}")


def find_upcoming_showtimes(schedule: Dict[str, List[Dict[str, Any]]], movie_title: str) -> List[Dict[str, Any]]:
    """
    Find all upcoming showtimes for a specific movie across all branches.

    Args:
        schedule: Schedule dictionary from the API
        movie_title: Name of the movie to search for

    Returns:
        List of dictionaries with branch, showtime, and booking_link information
    """
    results = []
    for branch_name, movies in schedule.items():
        for movie in movies:
            if movie_title.lower() in movie.get("movie_title", "").lower():
                for i, showtime in enumerate(movie.get("showtimes", [])):
                    booking_links = movie.get("booking_links", [])
                    booking_link = booking_links[i] if i < len(booking_links) else None
                    results.append({
                        "branch": branch_name,
                        "movie_title": movie.get("movie_title"),
                        "showtime": showtime,
                        "booking_link": booking_link
                    })
    return results


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

    print("🎭 Cinema City Israel Schedule Viewer")
    print("=" * 60)

    # Get schedule for all branches
    print("\n📡 Fetching schedule for all branches...")
    schedule = client.get_schedule(location_id="0", include_synopsis="0")

    # Show summary
    total_branches = len(schedule)
    total_movies = sum(len(movies) for movies in schedule.values())
    print(f"✅ Retrieved {total_branches} branches with {total_movies} movies")

    # Show complete schedule for all branches (limit output for demo)
    print("\n📋 Current Schedule:")
    print_cinema_schedule(schedule)

    # Demo: Get schedule for a specific branch (Rishon LeZion - ID 1173)
    print("\n\n🎬 Fetching schedule for Rishon LeZion branch...")
    rishon_schedule = client.get_schedule(location_id="1173", include_synopsis="0")

    if rishon_schedule:
        for branch_name, movies in rishon_schedule.items():
            print(f"\n📍 {branch_name}:")
            print(f"   Movies available: {len(movies)}")
            for movie in movies[:3]:  # Show first 3 movies
                print(f"   • {movie['movie_title']} ({len(movie['showtimes'])} showtimes)")

    # Demo: Search for a specific movie (if available in the schedule)
    print("\n\n🔍 Searching for movies in the schedule...")
    all_schedule = client.get_schedule(location_id="0", include_synopsis="0")

    # Get a sample movie title to search for
    sample_movie = None
    for branch_movies in all_schedule.values():
        if branch_movies:
            sample_movie = branch_movies[0].get("movie_title", "")
            break

    if sample_movie:
        print(f"   Searching for: '{sample_movie}'")
        showtimes = find_upcoming_showtimes(all_schedule, sample_movie)
        if showtimes:
            print(f"   Found {len(showtimes)} showtimes:")
            for showing in showtimes[:5]:  # Show first 5
                print(f"     • {showing['branch']}: {showing['showtime']}")
                if showing['booking_link']:
                    print(f"       Book: {showing['booking_link']}")