#!/usr/bin/env python3
"""
Test suite for CDK FFI Key-Value Store operations

Tests the KVStore trait functionality exposed through the FFI bindings,
including read, write, list, and remove operations with transaction support.
"""

import asyncio
import os
import sys
import tempfile
from pathlib import Path

# Setup paths before importing cdk_ffi
repo_root = Path(__file__).parent.parent.parent.parent
bindings_path = repo_root / "target" / "bindings" / "python"
lib_path = repo_root / "target" / "release"

# Copy the library to the bindings directory so Python can find it
import shutil

lib_file = "libcdk_ffi.dylib" if sys.platform == "darwin" else "libcdk_ffi.so"
src_lib = lib_path / lib_file
dst_lib = bindings_path / lib_file

if src_lib.exists() and not dst_lib.exists():
    shutil.copy2(src_lib, dst_lib)

# Add target/bindings/python to path to load cdk_ffi module
sys.path.insert(0, str(bindings_path))

import cdk_ffi

# Helper functions

def create_test_db():
    """Create a temporary SQLite database for testing"""
    tmp = tempfile.NamedTemporaryFile(suffix=".db", delete=False)
    db_path = tmp.name
    tmp.close()
    backend = cdk_ffi.WalletDbBackend.SQLITE(path=db_path)
    db = cdk_ffi.create_wallet_db(backend)
    return db, db_path


def cleanup_db(db_path):
    """Clean up the temporary database file"""
    if os.path.exists(db_path):
        os.unlink(db_path)


# Basic KV Store Tests

async def test_kv_write_and_read():
    """Test basic write and read operations"""
    print("\n=== Test: KV Write and Read ===")

    db, db_path = create_test_db()

    try:
        # Write a value using KV transaction
        kv_tx = await db.begin_db_transaction()
        test_data = b"Hello, KVStore!"
        await kv_tx.kv_write("app", "config", "greeting", test_data)
        await kv_tx.commit()
        print("  Written value to KV store")

        # Read it back using a new transaction
        kv_tx2 = await db.begin_db_transaction()
        result = await kv_tx2.kv_read("app", "config", "greeting")
        await kv_tx2.rollback()

        assert result is not None, "Expected to read back the value"
        assert bytes(result) == test_data, f"Expected {test_data}, got {bytes(result)}"
        print("  Read back correct value")

        print("  Test passed: KV write and read work")

    finally:
        cleanup_db(db_path)


async def test_kv_read_nonexistent():
    """Test reading a key that doesn't exist"""
    print("\n=== Test: KV Read Nonexistent Key ===")

    db, db_path = create_test_db()

    try:
        kv_tx = await db.begin_db_transaction()
        result = await kv_tx.kv_read("nonexistent", "namespace", "key")
        await kv_tx.rollback()

        assert result is None, f"Expected None for nonexistent key, got {result}"
        print("  Correctly returns None for nonexistent key")

        print("  Test passed: Reading nonexistent key returns None")

    finally:
        cleanup_db(db_path)


async def test_kv_overwrite():
    """Test overwriting an existing value"""
    print("\n=== Test: KV Overwrite ===")

    db, db_path = create_test_db()

    try:
        # Write initial value
        kv_tx = await db.begin_db_transaction()
        await kv_tx.kv_write("app", "data", "counter", b"1")
        await kv_tx.commit()
        print("  Written initial value")

        # Overwrite with new value
        kv_tx2 = await db.begin_db_transaction()
        await kv_tx2.kv_write("app", "data", "counter", b"42")
        await kv_tx2.commit()
        print("  Overwrote with new value")

        # Read back
        kv_tx3 = await db.begin_db_transaction()
        result = await kv_tx3.kv_read("app", "data", "counter")
        await kv_tx3.rollback()

        assert result is not None, "Expected to read back the value"
        assert bytes(result) == b"42", f"Expected b'42', got {bytes(result)}"
        print("  Read back overwritten value")

        print("  Test passed: KV overwrite works")

    finally:
        cleanup_db(db_path)


async def test_kv_remove():
    """Test removing a key"""
    print("\n=== Test: KV Remove ===")

    db, db_path = create_test_db()

    try:
        # Write a value
        kv_tx = await db.begin_db_transaction()
        await kv_tx.kv_write("app", "temp", "to_delete", b"delete me")
        await kv_tx.commit()
        print("  Written value to delete")

        # Verify it exists
        kv_tx2 = await db.begin_db_transaction()
        result = await kv_tx2.kv_read("app", "temp", "to_delete")
        await kv_tx2.rollback()
        assert result is not None, "Value should exist before removal"
        print("  Verified value exists")

        # Remove it
        kv_tx3 = await db.begin_db_transaction()
        await kv_tx3.kv_remove("app", "temp", "to_delete")
        await kv_tx3.commit()
        print("  Removed value")

        # Verify it's gone
        kv_tx4 = await db.begin_db_transaction()
        result_after = await kv_tx4.kv_read("app", "temp", "to_delete")
        await kv_tx4.rollback()

        assert result_after is None, f"Expected None after removal, got {result_after}"
        print("  Verified value is removed")

        print("  Test passed: KV remove works")

    finally:
        cleanup_db(db_path)


async def test_kv_list_keys():
    """Test listing keys in a namespace"""
    print("\n=== Test: KV List Keys ===")

    db, db_path = create_test_db()

    try:
        # Write multiple keys
        kv_tx = await db.begin_db_transaction()
        await kv_tx.kv_write("myapp", "settings", "theme", b"dark")
        await kv_tx.kv_write("myapp", "settings", "language", b"en")
        await kv_tx.kv_write("myapp", "settings", "timezone", b"UTC")
        await kv_tx.kv_write("myapp", "other", "unrelated", b"data")
        await kv_tx.commit()
        print("  Written multiple keys")

        # List keys in the settings namespace
        kv_tx2 = await db.begin_db_transaction()
        keys = await kv_tx2.kv_list("myapp", "settings")
        await kv_tx2.rollback()

        assert len(keys) == 3, f"Expected 3 keys, got {len(keys)}"
        assert "theme" in keys, "Expected 'theme' in keys"
        assert "language" in keys, "Expected 'language' in keys"
        assert "timezone" in keys, "Expected 'timezone' in keys"
        assert "unrelated" not in keys, "'unrelated' should not be in settings namespace"
        print(f"  Listed keys: {keys}")

        print("  Test passed: KV list works")

    finally:
        cleanup_db(db_path)


async def test_kv_list_empty_namespace():
    """Test listing keys in an empty or nonexistent namespace"""
    print("\n=== Test: KV List Empty Namespace ===")

    db, db_path = create_test_db()

    try:
        kv_tx = await db.begin_db_transaction()
        keys = await kv_tx.kv_list("nonexistent", "namespace")
        await kv_tx.rollback()

        assert isinstance(keys, list), "Expected a list"
        assert len(keys) == 0, f"Expected empty list, got {keys}"
        print("  Empty namespace returns empty list")

        print("  Test passed: KV list on empty namespace works")

    finally:
        cleanup_db(db_path)


# Transaction Tests

async def test_kv_transaction_commit():
    """Test that KV changes persist after commit"""
    print("\n=== Test: KV Transaction Commit ===")

    db, db_path = create_test_db()

    try:
        # Write and commit
        kv_tx = await db.begin_db_transaction()
        await kv_tx.kv_write("test", "commit", "key1", b"committed")
        await kv_tx.commit()
        print("  Written and committed")

        # Verify in new transaction
        kv_tx2 = await db.begin_db_transaction()
        result = await kv_tx2.kv_read("test", "commit", "key1")
        await kv_tx2.rollback()

        assert result is not None, "Value should persist after commit"
        assert bytes(result) == b"committed", f"Expected b'committed', got {bytes(result)}"
        print("  Value persists after commit")

        print("  Test passed: KV transaction commit works")

    finally:
        cleanup_db(db_path)


async def test_kv_transaction_rollback():
    """Test that KV changes are reverted after rollback"""
    print("\n=== Test: KV Transaction Rollback ===")

    db, db_path = create_test_db()

    try:
        # Write and rollback
        kv_tx = await db.begin_db_transaction()
        await kv_tx.kv_write("test", "rollback", "key1", b"should_not_persist")
        await kv_tx.rollback()
        print("  Written and rolled back")

        # Verify not persisted
        kv_tx2 = await db.begin_db_transaction()
        result = await kv_tx2.kv_read("test", "rollback", "key1")
        await kv_tx2.rollback()

        assert result is None, f"Value should not persist after rollback, got {bytes(result) if result else None}"
        print("  Value not persisted after rollback")

        print("  Test passed: KV transaction rollback works")

    finally:
        cleanup_db(db_path)


async def test_kv_transaction_atomicity():
    """Test that multiple operations in a transaction are atomic"""
    print("\n=== Test: KV Transaction Atomicity ===")

    db, db_path = create_test_db()

    try:
        # Perform multiple writes in one transaction
        kv_tx = await db.begin_db_transaction()
        await kv_tx.kv_write("atomic", "test", "key1", b"value1")
        await kv_tx.kv_write("atomic", "test", "key2", b"value2")
        await kv_tx.kv_write("atomic", "test", "key3", b"value3")

        # Read within same transaction (should see uncommitted values)
        keys_before = await kv_tx.kv_list("atomic", "test")
        print(f"  Keys within transaction: {keys_before}")

        # Rollback all
        await kv_tx.rollback()
        print("  Rolled back transaction")

        # Verify none persisted
        kv_tx2 = await db.begin_db_transaction()
        keys_after = await kv_tx2.kv_list("atomic", "test")
        await kv_tx2.rollback()

        assert len(keys_after) == 0, f"Expected no keys after rollback, got {keys_after}"
        print("  No keys persisted after rollback")

        # Now do the same but commit
        kv_tx3 = await db.begin_db_transaction()
        await kv_tx3.kv_write("atomic", "test", "key1", b"value1")
        await kv_tx3.kv_write("atomic", "test", "key2", b"value2")
        await kv_tx3.kv_write("atomic", "test", "key3", b"value3")
        await kv_tx3.commit()
        print("  Committed transaction with 3 keys")

        # Verify all persisted
        kv_tx4 = await db.begin_db_transaction()
        keys_final = await kv_tx4.kv_list("atomic", "test")
        await kv_tx4.rollback()

        assert len(keys_final) == 3, f"Expected 3 keys after commit, got {len(keys_final)}"
        print(f"  All 3 keys persisted: {keys_final}")

        print("  Test passed: KV transaction atomicity works")

    finally:
        cleanup_db(db_path)


async def test_kv_read_within_transaction():
    """Test reading values within the same transaction they were written"""
    print("\n=== Test: KV Read Within Transaction ===")

    db, db_path = create_test_db()

    try:
        kv_tx = await db.begin_db_transaction()

        # Write a value
        await kv_tx.kv_write("intra", "tx", "mykey", b"myvalue")

        # Read it back in same transaction
        result = await kv_tx.kv_read("intra", "tx", "mykey")

        assert result is not None, "Should be able to read uncommitted value in same tx"
        assert bytes(result) == b"myvalue", f"Expected b'myvalue', got {bytes(result)}"
        print("  Can read uncommitted value within transaction")

        await kv_tx.rollback()

        print("  Test passed: KV read within transaction works")

    finally:
        cleanup_db(db_path)


# Namespace Isolation Tests

async def test_kv_namespace_isolation():
    """Test that different namespaces are isolated"""
    print("\n=== Test: KV Namespace Isolation ===")

    db, db_path = create_test_db()

    try:
        # Write same key in different namespaces
        kv_tx = await db.begin_db_transaction()
        await kv_tx.kv_write("app1", "config", "key", b"app1_value")
        await kv_tx.kv_write("app2", "config", "key", b"app2_value")
        await kv_tx.kv_write("app1", "other", "key", b"app1_other_value")
        await kv_tx.commit()
        print("  Written same key in different namespaces")

        # Read from each namespace
        kv_tx2 = await db.begin_db_transaction()

        result1 = await kv_tx2.kv_read("app1", "config", "key")
        result2 = await kv_tx2.kv_read("app2", "config", "key")
        result3 = await kv_tx2.kv_read("app1", "other", "key")

        await kv_tx2.rollback()

        assert bytes(result1) == b"app1_value", f"Expected b'app1_value', got {bytes(result1)}"
        assert bytes(result2) == b"app2_value", f"Expected b'app2_value', got {bytes(result2)}"
        assert bytes(result3) == b"app1_other_value", f"Expected b'app1_other_value', got {bytes(result3)}"
        print("  Each namespace has correct value")

        print("  Test passed: KV namespace isolation works")

    finally:
        cleanup_db(db_path)


# Binary Data Tests

async def test_kv_binary_data():
    """Test storing and retrieving binary data"""
    print("\n=== Test: KV Binary Data ===")

    db, db_path = create_test_db()

    try:
        # Various binary data types
        test_cases = [
            ("empty", b""),
            ("null_byte", b"\x00"),
            ("all_bytes", bytes(range(256))),
            ("utf8_special", "Hello World".encode("utf-8")),
            ("random_binary", bytes([0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE])),
        ]

        kv_tx = await db.begin_db_transaction()
        for name, data in test_cases:
            await kv_tx.kv_write("binary", "test", name, data)
        await kv_tx.commit()
        print(f"  Written {len(test_cases)} binary test cases")

        # Read back and verify
        kv_tx2 = await db.begin_db_transaction()
        for name, expected_data in test_cases:
            result = await kv_tx2.kv_read("binary", "test", name)
            assert result is not None, f"Expected data for {name}"
            actual_data = bytes(result)
            assert actual_data == expected_data, f"Mismatch for {name}: expected {expected_data!r}, got {actual_data!r}"
            print(f"    '{name}': OK ({len(actual_data)} bytes)")
        await kv_tx2.rollback()

        print("  Test passed: KV binary data works")

    finally:
        cleanup_db(db_path)


async def test_kv_large_value():
    """Test storing a large value"""
    print("\n=== Test: KV Large Value ===")

    db, db_path = create_test_db()

    try:
        # Create a 1MB value
        large_data = bytes([i % 256 for i in range(1024 * 1024)])

        kv_tx = await db.begin_db_transaction()
        await kv_tx.kv_write("large", "data", "megabyte", large_data)
        await kv_tx.commit()
        print(f"  Written {len(large_data)} bytes")

        # Read back
        kv_tx2 = await db.begin_db_transaction()
        result = await kv_tx2.kv_read("large", "data", "megabyte")
        await kv_tx2.rollback()

        assert result is not None, "Expected to read large value"
        result_bytes = bytes(result)
        assert len(result_bytes) == len(large_data), f"Size mismatch: {len(result_bytes)} vs {len(large_data)}"
        assert result_bytes == large_data, "Data mismatch"
        print(f"  Read back {len(result_bytes)} bytes correctly")

        print("  Test passed: KV large value works")

    finally:
        cleanup_db(db_path)


# Key Name Tests

async def test_kv_special_key_names():
    """Test keys with special characters"""
    print("\n=== Test: KV Special Key Names ===")

    db, db_path = create_test_db()

    try:
        special_keys = [
            "simple",
            "with-dashes",
            "with_underscores",
            "MixedCase",
            "numbers123",
            "unicode_",  # Note: Using underscore instead of actual unicode for simplicity
            "empty_value",
        ]

        kv_tx = await db.begin_db_transaction()
        for i, key in enumerate(special_keys):
            print(key)
            await kv_tx.kv_write("special", "keys", key, f"value_{i}".encode())
        await kv_tx.commit()
        print(f"  Written {len(special_keys)} special keys")

        # List and verify
        kv_tx2 = await db.begin_db_transaction()
        keys = await kv_tx2.kv_list("special", "keys")
        await kv_tx2.rollback()

        assert len(keys) == len(special_keys), f"Expected {len(special_keys)} keys, got {len(keys)}"
        for key in special_keys:
            assert key in keys, f"Key '{key}' not found in list"
        print(f"  All special keys stored and listed correctly")

        print("  Test passed: KV special key names work")

    finally:
        cleanup_db(db_path)


# Database Read Method Tests

async def test_kv_database_read_methods():
    """Test kv_read and kv_list methods on the database object (not transaction)"""
    print("\n=== Test: KV Database Read Methods ===")

    db, db_path = create_test_db()

    try:
        # Write some data first
        kv_tx = await db.begin_db_transaction()
        await kv_tx.kv_write("dbread", "test", "key1", b"value1")
        await kv_tx.kv_write("dbread", "test", "key2", b"value2")
        await kv_tx.commit()
        print("  Written test data")

        # Read back using database-level kv_read (not transaction)
        result = await db.kv_read("dbread", "test", "key1")
        assert result is not None, "Expected to read key1"
        assert bytes(result) == b"value1", f"Expected b'value1', got {bytes(result)}"
        print("  db.kv_read() works")

        keys = await db.kv_list("dbread", "test")
        assert len(keys) == 2, f"Expected 2 keys, got {len(keys)}"
        print(f"  db.kv_list() works: {keys}")

        print("  Test passed: KV database read methods work")

    finally:
        cleanup_db(db_path)


# Persistence Test

async def test_kv_persistence_across_instances():
    """Test that KV data persists when reopening the database"""
    print("\n=== Test: KV Persistence Across Instances ===")

    db_path = None
    try:
        # Create and write
        with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as tmp:
            db_path = tmp.name

        backend = cdk_ffi.WalletDbBackend.SQLITE(path=db_path)
        db1 = cdk_ffi.create_wallet_db(backend)

        kv_tx = await db1.begin_db_transaction()
        await kv_tx.kv_write("persist", "test", "mykey", b"persistent_value")
        await kv_tx.commit()
        print("  Written and committed with first db instance")

        # Delete reference to first db (simulating closing)
        del db1
        await asyncio.sleep(0.1)
        print("  First db instance closed")

        # Reopen and read
        backend2 = cdk_ffi.WalletDbBackend.SQLITE(path=db_path)
        db2 = cdk_ffi.create_wallet_db(backend2)

        kv_tx2 = await db2.begin_db_transaction()
        result = await kv_tx2.kv_read("persist", "test", "mykey")
        await kv_tx2.rollback()

        assert result is not None, "Data should persist across db instances"
        assert bytes(result) == b"persistent_value", f"Expected b'persistent_value', got {bytes(result)}"
        print("  Data persisted across db instances")

        print("  Test passed: KV persistence across instances works")

    finally:
        if db_path and os.path.exists(db_path):
            os.unlink(db_path)


async def main():
    """Run all KV store tests"""
    print("Starting CDK FFI Key-Value Store Tests")
    print("=" * 60)

    tests = [
        # Basic operations
        ("KV Write and Read", test_kv_write_and_read),
        ("KV Read Nonexistent", test_kv_read_nonexistent),
        ("KV Overwrite", test_kv_overwrite),
        ("KV Remove", test_kv_remove),
        ("KV List Keys", test_kv_list_keys),
        ("KV List Empty Namespace", test_kv_list_empty_namespace),
        # Transaction tests
        ("KV Transaction Commit", test_kv_transaction_commit),
        ("KV Transaction Rollback", test_kv_transaction_rollback),
        ("KV Transaction Atomicity", test_kv_transaction_atomicity),
        ("KV Read Within Transaction", test_kv_read_within_transaction),
        # Namespace tests
        ("KV Namespace Isolation", test_kv_namespace_isolation),
        # Data tests
        ("KV Binary Data", test_kv_binary_data),
        ("KV Large Value", test_kv_large_value),
        ("KV Special Key Names", test_kv_special_key_names),
        # Database methods
        ("KV Database Read Methods", test_kv_database_read_methods),
        # Persistence
        ("KV Persistence Across Instances", test_kv_persistence_across_instances),
    ]

    passed = 0
    failed = 0

    for test_name, test_func in tests:
        try:
            await test_func()
            passed += 1
        except Exception as e:
            failed += 1
            print(f"\n  Test failed: {test_name}")
            print(f"  Error: {e}")
            import traceback
            traceback.print_exc()

    print("\n" + "=" * 60)
    print(f"Test Results: {passed} passed, {failed} failed")
    print("=" * 60)

    return 0 if failed == 0 else 1


if __name__ == "__main__":
    exit_code = asyncio.run(main())
    sys.exit(exit_code)