#!/usr/bin/env python3
"""
Test if we're getting real data and debug the GraphQL response structure
"""

import json
import logging
import sys
import os

# Add the src directory to the path
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def test_real_data_structure():
    """Test what real data structure we get back"""
    logger.info("Testing real data structure...")
    
    try:
        from swingmusic.services.spotify_web_player_client import get_spotify_web_player_client
        
        client = get_spotify_web_player_client()
        
        # Test with a simple track lookup
        logger.info("Making direct GraphQL query...")
        
        # Use the same payload structure as SpotiFLAC
        payload = {
            "variables": {
                "uri": "spotify:track:4cOdK2wGLETOMrsVzAojDx"
            },
            "operationName": "getTrack",
            "extensions": {
                "persistedQuery": {
                    "version": 1,
                    "sha256Hash": "612585ae06ba435ad26369870deaae23b5c8800a256cd8a57e08eddc25a37294"
                }
            }
        }
        
        # Make the raw request to see the actual response
        if not client._ensure_token():
            logger.error("Failed to get token")
            return False
        
        headers = {
            "Authorization": f"Bearer {client._token.access_token}",
            "Client-Token": client._token.client_token,
            "Spotify-App-Version": client._token.client_version,
            "Content-Type": "application/json",
        }
        
        response = client.session.post(
            "https://api-partner.spotify.com/pathfinder/v1/query",  # Try v1 first
            json=payload,
            headers=headers,
            timeout=30
        )
        
        logger.info(f"Response status: {response.status_code}")
        
        if response.status_code == 200:
            data = response.json()
            logger.info("✅ Got response from v1 API")
            
            # Print the structure
            logger.info("Response structure:")
            logger.info(json.dumps(data, indent=2)[:1000] + "..." if len(json.dumps(data)) > 1000 else json.dumps(data, indent=2))
            
            # Check if we have real data
            if "data" in data:
                track_data = data["data"].get("trackUnion", {})
                if track_data.get("name"):
                    logger.info(f"✅ Real track data: {track_data.get('name')}")
                    return True
                else:
                    logger.warning("⚠️  Got response but no track name")
                    logger.info(f"Available keys in trackUnion: {list(track_data.keys())}")
            else:
                logger.warning("⚠️  No 'data' key in response")
                logger.info(f"Available keys: {list(data.keys())}")
        
        elif response.status_code == 401:
            logger.error("❌ Authentication failed")
        else:
            logger.error(f"❌ Request failed: {response.status_code}")
            logger.error(f"Response: {response.text[:500]}")
        
        # Try v2 API (SpotiFLAC uses this)
        logger.info("Trying v2 API (SpotiFLAC endpoint)...")
        
        response_v2 = client.session.post(
            "https://api-partner.spotify.com/pathfinder/v2/query",  # SpotiFLAC uses v2
            json=payload,
            headers=headers,
            timeout=30
        )
        
        logger.info(f"V2 Response status: {response_v2.status_code}")
        
        if response_v2.status_code == 200:
            data_v2 = response_v2.json()
            logger.info("✅ Got response from v2 API")
            
            # Print the structure
            logger.info("V2 Response structure:")
            logger.info(json.dumps(data_v2, indent=2)[:1000] + "..." if len(json.dumps(data_v2)) > 1000 else json.dumps(data_v2, indent=2))
            
            # Check if we have real data
            if "data" in data_v2:
                track_data = data_v2["data"].get("trackUnion", {})
                if track_data.get("name"):
                    logger.info(f"✅ Real track data from v2: {track_data.get('name')}")
                    return True
                else:
                    logger.warning("⚠️  Got v2 response but no track name")
                    logger.info(f"Available keys in trackUnion: {list(track_data.keys())}")
            else:
                logger.warning("⚠️  No 'data' key in v2 response")
                logger.info(f"Available keys: {list(data_v2.keys())}")
        
        return False
        
    except Exception as e:
        logger.error(f"Test failed: {e}")
        import traceback
        traceback.print_exc()
        return False

def main():
    print("=" * 60)
    print("Real Data Structure Test")
    print("=" * 60)
    
    success = test_real_data_structure()
    
    print("\n" + "=" * 60)
    if success:
        print("✅ Real data retrieval working!")
    else:
        print("❌ Real data retrieval issues found")
    print("=" * 60)

if __name__ == "__main__":
    main()