import asyncio
from datetime import datetime, timedelta

import httpx
import pytest
import pytest_asyncio
from passlib.hash import bcrypt
from sqlalchemy.ext.asyncio import (AsyncSession, async_sessionmaker,
                                    create_async_engine)

from src.core.app import app
from src.core.database import Base
from src.modules.models.m2m.event_user_m2m import User
from src.modules.schemas.auth import UserSchema
from src.modules.schemas.event import EventSchema

engine = create_async_engine(
    "postgresql+asyncpg://" +
    "test_user:" +
    "test_password@" +
    "db_test/db_test?prepared_statement_cache_size=0",
    echo=False,
    query_cache_size=0
)
test_async_session = async_sessionmaker(
    autoflush=False,
    autocommit=False,
    bind=engine,
    class_=AsyncSession,
    expire_on_commit=False
)


@pytest.yield_fixture(scope='session')
def event_loop():
    el = asyncio.get_event_loop_policy().new_event_loop()
    yield el
    el.close()


@pytest_asyncio.fixture
async def test_db(event_loop):
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)

    async with test_async_session() as session:
        yield session

    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.drop_all)
    await engine.dispose()


@pytest_asyncio.fixture
async def async_client_fixture():
    async with httpx.AsyncClient(
            app=app,
            base_url='http://localhost/',
    ) as client:
        yield client


@pytest.fixture
def user_payload_correct_fixture():
    payload = dict(
        email='[email protected]',
        password='foo@pass',
        password_confirm='foo@pass',
        first_name='FirstFoo',
        last_name='LastFoo',
        birthdate='2023-06-22'
    )
    return payload


@pytest.fixture
def db_user_fixture(user_payload_correct_fixture):
    payload = user_payload_correct_fixture.copy()
    del payload['password_confirm']
    password = payload.pop('password')
    birthdate = payload.pop('birthdate')
    payload['birthdate'] = datetime.strptime(birthdate, "%Y-%m-%d").date()
    payload['hashed_password'] = bcrypt.hash(password)
    return payload


@pytest.fixture
def db_second_user_fixture(db_user_fixture):
    payload = db_user_fixture.copy()
    payload['email'] = '[email protected]'
    return payload


@pytest.fixture
def user_payload_incorrect_fixture(user_payload_correct_fixture):
    wrong_data = user_payload_correct_fixture.copy()
    wrong_data['password_confirm'] = 'wrongpass'
    return wrong_data


@pytest.fixture
def login_credentials_fixture():
    payload = dict(
        email='[email protected]',
        password='foo@pass',
    )
    return payload


@pytest_asyncio.fixture
async def verified_user_in_db_fixture(
        db_user_fixture,
        test_db,
        async_client_fixture,
        user_payload_correct_fixture
):
    user_instance = User(**db_user_fixture)
    user_instance.is_email_verified = True
    test_db.add(user_instance)
    await test_db.commit()


@pytest_asyncio.fixture
async def verified_second_user_in_db_fixture(
        db_second_user_fixture,
        test_db
):
    user_instance = User(**db_second_user_fixture)
    user_instance.is_email_verified = True
    test_db.add(user_instance)
    await test_db.commit()


@pytest_asyncio.fixture
async def not_verified_user_in_db_fixture(
        db_user_fixture,
        test_db,
        async_client_fixture,
        user_payload_correct_fixture
):
    user_instance = User(**db_user_fixture)
    test_db.add(user_instance)
    await test_db.commit()


@pytest_asyncio.fixture
async def logged_in_verified_user(
        verified_user_in_db_fixture,
        test_db,
        async_client_fixture,
        user_payload_correct_fixture
):
    response = await async_client_fixture.post(
        url='auth/token',
        json=user_payload_correct_fixture
    )
    user = UserSchema(**response.json())
    return user


@pytest_asyncio.fixture
async def logged_in_second_verified_user(
        verified_second_user_in_db_fixture,
        test_db,
        async_client_fixture,
        user_payload_correct_fixture
):
    response = await async_client_fixture.post(
        url='auth/token',
        json=user_payload_correct_fixture
    )
    user = UserSchema(**response.json())
    return user


@pytest_asyncio.fixture
async def logged_in_not_verified_user(
        not_verified_user_in_db_fixture,
        test_db,
        async_client_fixture,
        user_payload_correct_fixture
):
    response = await async_client_fixture.post(
        url='auth/token',
        json=user_payload_correct_fixture
    )
    user = UserSchema(**response.json())
    return user


@pytest.fixture
def event_correct_payload_fixture():
    payload = dict(
        title='Footitle',
        description='Foodescription',
        address=dict(
            country='Foocountry',
            city='Foocity',
            street='Foostreet',
            build='Foobuild'
        ),
        start_time=(
            datetime.now() + timedelta(days=7)
        ).strftime("%Y-%m-%dT%H:%M:%S.%f"),
        end_time=(
            datetime.now() + timedelta(days=10)
        ).strftime("%Y-%m-%dT%H:%M:%S.%f"),
        is_closed=False,
        number_of_members=10,
        min_age=16,
        max_age=20,
        event_type='online',
        notes='notes'
    )
    return payload


@pytest_asyncio.fixture
async def event_second_user_owner_fixture(
        event_correct_payload_fixture,
        logged_in_second_verified_user,
        test_db,
        async_client_fixture,
):
    response = await async_client_fixture.post(
        url='event/create-event',
        json=event_correct_payload_fixture
    )
    event = EventSchema(**response.json())
    return event