Centurygame APIkingshot-giftcode.centurygame.com ↗

"""
King's Shot Gift Code API Client

Provides a client for interacting with the King's Shot mobile game gift code
redemption center API. Supports player lookup, gift code redemption, and
configuration retrieval.

Get your API key from: https://parse.bot/settings
"""

import os
import sys
from typing import Any, Dict, Optional

import requests


class ParseClient:
    """Client for King's Shot Gift Code API."""

    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 environment variable.
        """
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "ea8ff0bc-09f9-419a-a710-2374107ef49c"
        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 env var or pass api_key parameter."
            )

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

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

        Returns:
            Parsed JSON response as dictionary

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

        try:
            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()
        except requests.RequestException as e:
            print(f"API request failed: {e}")
            raise

    def get_player(self, fid: str) -> Dict[str, Any]:
        """
        Look up a King's Shot player by their in-game player ID.

        Args:
            fid: The player's in-game ID (numeric string)

        Returns:
            API response containing player information or error details
        """
        return self._call("get_player", method="POST", fid=fid)

    def redeem_code(self, fid: str, code: str) -> Dict[str, Any]:
        """
        Redeem a gift code for a King's Shot player.

        Args:
            fid: The player's in-game ID
            code: The gift code to redeem (case-sensitive)

        Returns:
            API response containing redemption result and rewards
        """
        return self._call("redeem_code", method="POST", fid=fid, code=code)

    def get_gift_code_config(self) -> Dict[str, Any]:
        """
        Retrieve the gift code center configuration.

        Returns:
            API response containing banner URLs for each supported language
        """
        return self._call("get_gift_code_config", method="GET")


def main():
    """Practical workflow example for King's Shot Gift Code API."""

    # Initialize client
    client = ParseClient()

    # List of player IDs and gift codes to process
    players_and_codes = [
        {"player_id": "12345", "codes": ["WELCOME2024", "KINGSHOT100"]},
        {"player_id": "67890", "codes": ["CELEBRATE50"]},
        {"player_id": "11111", "codes": ["BONUS200", "FREEGEMS"]},
    ]

    print("=" * 60)
    print("King's Shot Gift Code Redemption Workflow")
    print("=" * 60)

    # Step 1: Get gift code configuration
    print("\n[Step 1] Fetching gift code center configuration...")
    try:
        config_response = client.get_gift_code_config()
        if config_response.get("data", {}).get("code") == 0:
            print("✓ Configuration retrieved successfully")
            languages = list(config_response.get("data", {}).get("data", {}).keys())
            print(f"  Supported languages: {', '.join(languages)}")
        else:
            print(
                f"✗ Failed to get config: {config_response.get('data', {}).get('msg')}"
            )
            return
    except Exception as e:
        print(f"✗ Error fetching config: {e}")
        return

    # Step 2: Verify players and redeem codes
    print("\n[Step 2] Processing player gift code redemptions...")
    print("-" * 60)

    redemption_results = []

    for player_info in players_and_codes:
        player_id = player_info["player_id"]
        codes = player_info["codes"]

        print(f"\nPlayer ID: {player_id}")

        # Verify player exists
        try:
            player_response = client.get_player(player_id)

            if player_response.get("data", {}).get("code") == 0:
                print("  ✓ Player found")
                player_data = player_response.get("data", {}).get("data")
                if isinstance(player_data, dict):
                    print(f"    Player details: {player_data}")
            else:
                print(
                    f"  ✗ Player not found: {player_response.get('data', {}).get('msg')}"
                )
                continue

        except Exception as e:
            print(f"  ✗ Error looking up player: {e}")
            continue

        # Redeem each code for this player
        for code in codes:
            print(f"  Redeeming code: {code}")

            try:
                redeem_response = client.redeem_code(player_id, code)
                response_data = redeem_response.get("data", {})

                if response_data.get("code") == 0:
                    rewards = response_data.get("data", [])
                    print("    ✓ Redeemed successfully")
                    if rewards:
                        print(f"      Rewards: {rewards}")
                    redemption_results.append(
                        {
                            "player_id": player_id,
                            "code": code,
                            "status": "success",
                            "rewards": rewards,
                        }
                    )
                else:
                    error_msg = response_data.get("msg")
                    error_code = response_data.get("err_code")
                    print(f"    ✗ Redemption failed: {error_msg} (code: {error_code})")
                    redemption_results.append(
                        {
                            "player_id": player_id,
                            "code": code,
                            "status": "failed",
                            "error": error_msg,
                        }
                    )

            except Exception as e:
                print(f"    ✗ Error redeeming code: {e}")
                redemption_results.append(
                    {
                        "player_id": player_id,
                        "code": code,
                        "status": "error",
                        "error": str(e),
                    }
                )

    # Step 3: Summary
    print("\n" + "=" * 60)
    print("Redemption Summary")
    print("=" * 60)

    successful = sum(1 for r in redemption_results if r.get("status") == "success")
    failed = sum(1 for r in redemption_results if r.get("status") == "failed")
    errors = sum(1 for r in redemption_results if r.get("status") == "error")

    print(f"Total attempts: {len(redemption_results)}")
    print(f"Successful: {successful}")
    print(f"Failed: {failed}")
    print(f"Errors: {errors}")

    if successful > 0:
        print("\n✓ Successfully redeemed codes:")
        for r in redemption_results:
            if r.get("status") == "success":
                print(f"  - Player {r['player_id']}: {r['code']}")

    if failed > 0:
        print("\n✗ Failed redemptions:")
        for r in redemption_results:
            if r.get("status") == "failed":
                print(f"  - Player {r['player_id']}: {r['code']} ({r['error']})")


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\n\nInterrupted by user")
        sys.exit(0)
    except Exception as e:
        print(f"\nFatal error: {e}")
        sys.exit(1)