"""Test PostgreSQL database operations."""

import pytest
from sqlalchemy import create_engine, text
from sqlalchemy.orm import Session

from Services.PostgresDb.database import Base, get_db
from AllConfigs.SqlDatabase.configs import WagDatabase
from Ztest.models import UserModel


@pytest.fixture(scope="session")
def db_engine():
    """Create a test database engine."""
    # Use the same database URL but with test database
    test_db_url = WagDatabase.DATABASE_URL
    engine = create_engine(test_db_url, echo=True)

    # Create all tables
    Base.metadata.create_all(bind=engine)

    yield engine

    # Drop all tables after tests
    Base.metadata.drop_all(bind=engine)


@pytest.fixture
def db_session(db_engine):
    """Create a test database session."""
    connection = db_engine.connect()
    transaction = connection.begin()
    session = Session(bind=connection)

    yield session

    # Rollback the transaction after each test
    transaction.rollback()
    connection.close()
    session.close()


def test_create_user(db_session):
    """Test creating a user in the database."""
    # Create user using CrudMixin methods
    user = UserModel(username="testuser", email="test@example.com")
    db_session.add(user)
    db_session.commit()

    # Verify user was created
    db_user = db_session.query(UserModel).filter_by(username="testuser").first()
    assert db_user is not None
    assert db_user.email == "test@example.com"
    assert db_user.created_at is not None
    assert not db_user.deleted
    assert db_user.active


def test_update_user(db_session):
    """Test updating a user in the database."""
    # Create user
    user = UserModel(username="updateuser", email="update@example.com")
    db_session.add(user)
    db_session.commit()

    # Update user using CrudMixin methods
    user.update(db=db_session, email="newemail@example.com")
    db_session.commit()

    # Verify update
    updated_user = db_session.query(UserModel).filter_by(username="updateuser").first()
    assert updated_user.email == "newemail@example.com"
    assert updated_user.updated_at is not None


def test_soft_delete_user(db_session):
    """Test soft deleting a user from the database."""
    # Create user
    user = UserModel(username="deleteuser", email="delete@example.com")
    db_session.add(user)
    db_session.commit()

    # Soft delete by updating deleted and active flags
    user.update(db=db_session, deleted=True, active=False)
    db_session.commit()

    # Verify soft deletion
    deleted_user = db_session.query(UserModel).filter_by(username="deleteuser").first()
    assert deleted_user is not None
    assert deleted_user.deleted
    assert not deleted_user.active


def test_get_db_context_manager():
    """Test the get_db context manager."""
    with get_db() as session:
        # Verify we can execute a simple query
        result = session.execute(text("SELECT 1"))
        assert result.scalar() == 1