import pytest
import asyncio
import pickle
from functions import playerClass, personClass
from database_async import initialize_pool, close_pool, fetch_one
from database.db_operations import pickle_loads_compat

pytestmark = pytest.mark.skip(reason="Requires MySQL database - integration test")

@pytest.fixture
async def db_pool():
    await initialize_pool(pool_size=5)
    yield
    await close_pool()

@pytest.mark.asyncio
async def test_save_game_async(db_pool):
    """Test async game save"""
    from functions import saveGameAsync

    # Create test player
    player = playerClass()
    player.id = "test_user_123"
    player.c = personClass()
    player.c.firstname = "TestPlayer"
    player.c.ageYears = 25
    player.status = "active"

    # Save game
    await saveGameAsync(player)

    # Verify saved to database
    result = await fetch_one(
        "SELECT id, pickle_data FROM lifesim_savegames WHERE id = %s",
        (player.id,)
    )

    assert result is not None
    assert result[0] == "test_user_123"

    # Verify can unpickle with refactoring compatibility
    loaded_player = pickle_loads_compat(result[1])
    assert loaded_player.c.firstname == "TestPlayer"
    assert loaded_player.c.ageYears == 25

@pytest.mark.asyncio
async def test_save_game_concurrent(db_pool):
    """Test concurrent game saves don't conflict"""
    from functions import saveGameAsync

    # Create multiple players
    players = []
    for i in range(10):
        player = playerClass()
        player.id = f"test_concurrent_{i}"
        player.c = personClass()
        player.c.firstname = f"Player{i}"
        players.append(player)

    # Save all concurrently
    await asyncio.gather(*[saveGameAsync(p) for p in players])

    # Verify all saved
    for i, player in enumerate(players):
        result = await fetch_one(
            "SELECT id FROM lifesim_savegames WHERE id = %s",
            (player.id,)
        )
        assert result is not None

@pytest.mark.asyncio
async def test_load_game_async(db_pool):
    """Test async game load"""
    from functions import saveGameAsync, loadGameAsync

    # Create and save test player
    player = playerClass()
    player.id = "test_load_123"
    player.c = personClass()
    player.c.firstname = "LoadTest"
    player.c.ageYears = 30
    player.c.money = 5000

    await saveGameAsync(player)

    # Load game
    loaded = await loadGameAsync("test_load_123")

    assert loaded is not None
    assert loaded.id == "test_load_123"
    assert loaded.c.firstname == "LoadTest"
    assert loaded.c.ageYears == 30
    assert loaded.c.money == 5000

@pytest.mark.asyncio
async def test_load_nonexistent_game(db_pool):
    """Test loading nonexistent game returns None"""
    from functions import loadGameAsync

    loaded = await loadGameAsync("nonexistent_user_999")
    assert loaded is None