#!/usr/bin/env python3
"""
UAT script for export-catalog-task.
Sets up a bulk session with a metadata file and starts a Google asset transfer
job, which creates a task token in Redis needed to test /task-success/ and /task-failure/.
"""

import os
import sys
from pathlib import Path

import requests
from dotenv import load_dotenv

load_dotenv(dotenv_path=Path(__file__).parent / ".env")

BASE_URL = "https://qa-ows-product-staging.theorchard.io"
AUTH_TOKEN = os.getenv("AUTH_TOKEN")
VENDOR_UUID = "573d0372-7f2f-48a6-8deb-c9a6558f9549"
XLSX = Path(__file__).parent / "bulk_upload_good_25824.xlsx"

HEADERS = {
    "Authorization": f"Bearer {AUTH_TOKEN}",
    "Content-Type": "application/json",
}

# Reuse a single session for all HTTP requests and set a default timeout
SESSION = requests.Session()
SESSION.headers.update(HEADERS)
DEFAULT_TIMEOUT = 10  # seconds


def print_response(response: requests.Response) -> None:
    print(f"  Status: {response.status_code}")
    try:
        print(f"  Body:   {response.json()}")
    except Exception:
        print(f"  Body:   {response.text}")


def create_bulk_session() -> str:
    print("\n[1/8] Creating bulk session...")
    response = SESSION.post(
        f"{BASE_URL}/bulk-session",
        json={"vendor_uuid": VENDOR_UUID},
        timeout=DEFAULT_TIMEOUT,
    )
    print_response(response)
    response.raise_for_status()
    return response.json()["bulk_session_id"]


def create_metadata_upload(bulk_session_id: str) -> str:
    print("\n[2/8] Creating metadata upload record...")
    response = SESSION.post(
        f"{BASE_URL}/metadata/upload",
        json={
            "bulk_session_id": bulk_session_id,
            "original_filename": XLSX.name,
        },
        timeout=DEFAULT_TIMEOUT,
    )
    print_response(response)
    response.raise_for_status()
    return response.json()["s3_filename"]


def get_presigned_url(s3_filename: str) -> tuple[str, int]:
    print("\n[3/8] Getting presigned URL...")
    response = SESSION.get(
        f"{BASE_URL}/metadata/upload/{s3_filename}",
        params={"parts": 1},
        timeout=DEFAULT_TIMEOUT,
    )
    print_response(response)
    response.raise_for_status()
    part = response.json()["presigned_urls"][0]
    return part["url"], part["part_number"]


def upload_xlsx_to_s3(presigned_url: str) -> str:
    print("\n[4/8] Uploading xlsx to S3...")
    with XLSX.open("rb") as f:
        response = requests.put(presigned_url, data=f, timeout=DEFAULT_TIMEOUT)
    print(f"  Status: {response.status_code}")
    etag = response.headers.get("ETag", "").strip('"')
    print(f"  ETag:   {etag}")
    response.raise_for_status()
    if not etag:
        raise ValueError("ETag missing from S3 response headers")
    return etag


def complete_metadata_upload(s3_filename: str, part_number: int, etag: str) -> str:
    print("\n[5/8] Completing metadata upload...")
    response = SESSION.patch(
        f"{BASE_URL}/metadata/upload/{s3_filename}",
        json={"parts": [{"part_number": part_number, "etag": etag}]},
        timeout=DEFAULT_TIMEOUT,
    )
    print_response(response)
    response.raise_for_status()
    return response.json()["bulk_session_metadata_file_id"]


def finalize_metadata_file(bulk_session_id: str, metadata_file_id: str) -> None:
    print("\n[6/8] Finalizing metadata file...")
    response = SESSION.post(
        f"{BASE_URL}/bulk-session/{bulk_session_id}/metadata-file/{metadata_file_id}/finalize",
        timeout=DEFAULT_TIMEOUT,
    )
    print_response(response)
    response.raise_for_status()


def mark_metadata_valid(bulk_session_id: str, s3_filename: str) -> None:
    print("\n[7/8] Marking metadata file as valid...")
    response = SESSION.patch(
        f"{BASE_URL}/bulk-session/{bulk_session_id}",
        json={
            "success_file": s3_filename,
            "metadata_status": "valid",
        },
        timeout=DEFAULT_TIMEOUT,
    )
    print_response(response)
    response.raise_for_status()


def start_google_transfer_job(bulk_session_id: str) -> None:
    print("\n[8/8] Starting Google asset transfer job...")
    response = SESSION.post(
        f"{BASE_URL}/assets/upload/google",
        json={
            "bulk_session_id": bulk_session_id,
            "user_id": "test-google-user-id",
            "assets": [
                {"name": "sample.flac", "type": "file", "id": "fake-gdrive-id-1"},
                {"name": "sample.jpg", "type": "file", "id": "fake-gdrive-id-2"},
            ],
        },
        timeout=DEFAULT_TIMEOUT,
    )
    print_response(response)
    response.raise_for_status()


def main() -> None:
    bulk_session_id = create_bulk_session()
    s3_filename = create_metadata_upload(bulk_session_id)
    presigned_url, part_number = get_presigned_url(s3_filename)
    etag = upload_xlsx_to_s3(presigned_url)
    metadata_file_id = complete_metadata_upload(s3_filename, part_number, etag)
    finalize_metadata_file(bulk_session_id, metadata_file_id)
    mark_metadata_valid(bulk_session_id, s3_filename)
    start_google_transfer_job(bulk_session_id)

    print("\nDone. Check ECS task logs for TASK_TOKEN to use with:")
    print("  POST /task-success/{token}")
    print("  POST /task-failure/{token}")


if __name__ == "__main__":
    if not AUTH_TOKEN or AUTH_TOKEN.strip() in ("", "<your-token>"):
        print("Error: set a valid AUTH_TOKEN environment variable before running")
        sys.exit(1)
    main()