import asyncio
import time
from datetime import datetime

import databases
import pytest
import sqlalchemy
from sqlalchemy import func, text

import ormar
from tests.settings import DATABASE_URL

database = databases.Database(DATABASE_URL, force_rollback=True)
metadata = sqlalchemy.MetaData()


class Product(ormar.Model):
    class Meta:
        tablename = "product"
        metadata = metadata
        database = database

    id: ormar.Integer(primary_key=True)
    name: ormar.String(max_length=100)
    company: ormar.String(max_length=200, server_default='Acme')
    sort_order: ormar.Integer(server_default=text("10"))
    created: ormar.DateTime(server_default=func.now())


@pytest.fixture(scope="module")
def event_loop():
    loop = asyncio.get_event_loop()
    yield loop
    loop.close()


@pytest.fixture(autouse=True, scope="module")
async def create_test_database():
    engine = sqlalchemy.create_engine(DATABASE_URL)
    metadata.drop_all(engine)
    metadata.create_all(engine)
    yield
    metadata.drop_all(engine)


def test_table_defined_properly():
    assert Product.Meta.model_fields['created'].nullable
    assert not Product.__fields__['created'].required
    assert Product.Meta.table.columns['created'].server_default.arg.name == 'now'


@pytest.mark.asyncio
async def test_model_creation():
    async with database:
        async with database.transaction(force_rollback=True):
            p1 = Product(name='Test')
            assert p1.created is None
            await p1.save()
            await p1.load()
            assert p1.created is not None
            assert p1.company == 'Acme'
            assert p1.sort_order == 10

            date = datetime.strptime('2020-10-27 11:30', '%Y-%m-%d %H:%M')
            p3 = await Product.objects.create(name='Test2', created=date, company='Roadrunner', sort_order=1)
            assert p3.created is not None
            assert p3.created == date
            assert p1.created != p3.created
            assert p3.company == 'Roadrunner'
            assert p3.sort_order == 1

            p3 = await Product.objects.get(name='Test2')
            assert p3.company == 'Roadrunner'
            assert p3.sort_order == 1

            time.sleep(1)

            p2 = await Product.objects.create(name='Test3')
            assert p2.created is not None
            assert p2.company == 'Acme'
            assert p2.sort_order == 10

            if Product.db_backend_name() != 'postgresql':
                # postgres use transaction timestamp so it will remain the same
                assert p1.created != p2.created  # pragma nocover