#!/usr/bin/env python3
"""
Generate a signed Telegram WebApp initData payload for local development.

This mirrors Telegram's signature scheme so you can test auth flows without
the Mini App container. The output includes:
- init_data: URL-encoded payload you can POST to the dev auth endpoint
- data_check_string: the canonical string that was signed
- hash: the calculated HMAC-SHA-256 signature
"""

from __future__ import annotations

import argparse
import json
import os
import sys
from pathlib import Path

# Make backend modules importable when running from the repo root.
PROJECT_ROOT = Path(__file__).resolve().parents[1]
BACKEND_DIR = PROJECT_ROOT / "backend"
sys.path.insert(0, str(BACKEND_DIR))

from utils.telegram import generate_signed_init_data  # noqa: E402


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Generate a signed Telegram initData payload for development",
    )
    parser.add_argument(
        "--bot-token",
        default=os.getenv("TELEGRAM_BOT_TOKEN"),
        help="Telegram bot token (defaults to TELEGRAM_BOT_TOKEN env var)",
    )
    parser.add_argument(
        "--user-id",
        type=int,
        required=True,
        help="Telegram user id to embed in the payload",
    )
    parser.add_argument(
        "--username",
        default=None,
        help="Optional Telegram username",
    )
    parser.add_argument(
        "--first-name",
        default="DevUser",
        help="First name to include (default: DevUser)",
    )
    parser.add_argument(
        "--last-name",
        default=None,
        help="Optional last name",
    )
    parser.add_argument(
        "--language-code",
        default="en",
        help="Optional language_code (default: en)",
    )
    parser.add_argument(
        "--photo-url",
        default=None,
        help="Optional photo URL",
    )
    parser.add_argument(
        "--start-param",
        default=None,
        help="Optional referral/start parameter to attach",
    )
    parser.add_argument(
        "--query-id",
        default="dev-query-id",
        help="Optional query_id value (default: dev-query-id)",
    )
    parser.add_argument(
        "--auth-date",
        type=int,
        default=None,
        help="Unix timestamp for auth_date (default: now)",
    )
    parser.add_argument(
        "--future-hours",
        type=int,
        default=None,
        help="Generate auth_date N hours in the future (useful for dev testing)",
    )
    return parser.parse_args()


def main() -> int:
    args = parse_args()

    bot_token = args.bot_token
    if not bot_token:
        print("Error: provide --bot-token or set TELEGRAM_BOT_TOKEN", file=sys.stderr)
        return 1

    user_payload = {
        "id": args.user_id,
        "first_name": args.first_name,
    }
    optional_fields = {
        "username": args.username,
        "last_name": args.last_name,
        "language_code": args.language_code,
        "photo_url": args.photo_url,
    }
    user_payload.update({k: v for k, v in optional_fields.items() if v is not None})

    # Handle future-hours option
    auth_date = args.auth_date
    if args.future_hours is not None:
        if auth_date is not None:
            print(
                "Warning: --auth-date and --future-hours both specified, using --future-hours",
                file=sys.stderr,
            )
        from datetime import datetime, timedelta, timezone

        auth_date = int(
            (datetime.now(timezone.utc) + timedelta(hours=args.future_hours)).timestamp()
        )

    signed = generate_signed_init_data(
        user=user_payload,
        bot_token=bot_token,
        auth_date=auth_date,
        query_id=args.query_id,
        start_param=args.start_param,
    )

    init_data_str = signed["init_data"]
    debug_info = {
        "data_check_string": signed["data_check_string"],
        "hash": signed["hash"],
    }
    start_param = args.start_param

    print(f"\ninit_data (use this in the dev auth endpoint):")
    print(init_data_str)

    print(f"\nSignature details:")
    print(json.dumps(debug_info, indent=2))

    print(f"\nExample curl:")
    payload = {"init_data": init_data_str}
    if start_param:
        payload["start_param"] = start_param
    print(
        f"curl -X POST http://localhost:8000/api/users/auth/telegram/dev/ "
        f"-H 'Content-Type: application/json' "
        f"--data '{json.dumps(payload)}'"
    )
    
    # Add URL-encoded version for browser testing
    from urllib.parse import quote
    encoded_init_data = quote(init_data_str, safe='')
    
    print(f"\nURL-encoded init_data (for browser hash):")
    print(encoded_init_data)
    
    print(f"\nFull browser URL (paste this directly):")
    browser_url = f"http://localhost:5173/#tgWebAppData={encoded_init_data}&tgWebAppVersion=7.0&tgWebAppPlatform=weba"
    print(browser_url)
    
    print(f"\nTo test:")
    print(f"1. Clear localStorage: localStorage.clear()")
    print(f"2. Paste the URL above into your browser")
    print(f"3. The session will persist across reloads")

    return 0


if __name__ == "__main__":
    raise SystemExit(main())