import importlib
import os
from unittest.mock import patch, MagicMock

from behave import fixture, use_fixture
from behave.fixture import fixture_call_params, use_fixture_by_tag
from faker import Faker
from flask_webtest import TestApp as WebtestApp
from mockserver import MockServerClient

from atlas_um.app import create_app
from atlas_um.extensions import celery, redis
from atlas_um.pgdb import pgdb
from tests.atlas_um import factories

FAKE_HOST = "atlas_um.test"


@fixture
def atlas_um_app(context, *args, **kwargs):
    app = create_app()
    app.testing = True
    app.config["SERVER_NAME"] = FAKE_HOST
    app.config["SESSION_COOKIE_SECURE"] = False
    ctx = app.app_context()
    ctx.push()

    context.atlas_um_app = app
    yield app

    ctx.pop()


@fixture
def atlas_um_celery(context, *args, **kwargs):
    celery.conf.update(task_always_eager=True)


@fixture
def atlas_um_client(context, *args, **kwargs):
    use_fixture(atlas_um_app, context)
    atlas_um_client = WebtestApp(context.atlas_um_app)
    context.atlas_um_client = atlas_um_client
    return atlas_um_client


@fixture
def pgdb_session(context, *args, **kwargs):
    use_fixture(atlas_um_app, context)
    connection = pgdb.engine.connect()
    transaction = connection.begin()

    options = dict(bind=connection, binds={})
    session = pgdb.create_scoped_session(options=options)

    pgdb.session = session
    context.pgdb_session = session
    yield session

    transaction.rollback()
    connection.close()
    session.remove()


@fixture
def redis_session(context, *args, **kwargs):
    use_fixture(atlas_um_app, context)
    redis.flushdb()
    context.redis = redis
    yield redis
    redis.flushdb()


@fixture
def faker(context, *args, **kwargs):
    context.faker = Faker()


@fixture
def mock_usm_client(context, *args, **kwargs):
    mock_server_address = os.environ["TEST_USM_MOCK_SERVER"]
    mock_usm_client = MockServerClient(mock_server_address)
    context.mock_usm_client = mock_usm_client
    context.add_cleanup(mock_usm_client.reset)
    return mock_usm_client


@fixture
def mock_boto3_client(context, *args, **kwargs):
    mocked_boto3_client = MagicMock()
    patcher = patch("boto3.client", mocked_boto3_client)
    patcher.start()


@fixture
def extra_lookup_values(context, *args, **kwargs):
    use_fixture(atlas_um_client, context)
    use_fixture(pgdb_session, context)
    values = {}
    job_category = factories.JobCategoryFactory.build(name="test_job_category")
    context.pgdb_session.add(job_category)
    values["job_category"] = job_category
    personnel_type = factories.PersonnelTypeFactory.build(
        name="test_personnel_type"
    )
    context.pgdb_session.add(personnel_type)
    values["personnel_type"] = personnel_type
    business_unit = factories.BusinessUnitFactory.build(
        name="test_business_unit"
    )
    context.pgdb_session.add(business_unit)
    values["business_unit"] = business_unit
    context.extra_lookup_values = values
    context.pgdb_session.commit()
    return values


def before_feature(context, feature):
    use_fixture(atlas_um_client, context)
    use_fixture(faker, context)
    use_fixture(atlas_um_celery, context)
    use_fixture(redis_session, context)


def before_scenario(context, scenario):
    use_fixture(pgdb_session, context)
    use_fixture(extra_lookup_values, context)
    context.patched = []


def after_scenario(context, scenario):
    for module, patcher in context.patched:
        patcher.stop()
        importlib.reload(module)


fixture_registry = {
    "fixture.usm": fixture_call_params(mock_usm_client),
    "fixture.boto3": fixture_call_params(mock_boto3_client),
}


def before_tag(context, tag):
    if tag.startswith("fixture."):
        return use_fixture_by_tag(tag, context, fixture_registry)