from datetime import datetime

import pytest
from flask_limiter.errors import RateLimitExceeded
from pytest_factoryboy import register

from atlas_um.app import create_app
from atlas_um.auth.claims import Audience, Role, ResourceGroups
from atlas_um.auth.models import User
from atlas_um.extensions import redis
from atlas_um.pgdb import pgdb
from .factories import factories

for factory in factories:
    register(factory)


@pytest.fixture
def app_config():
    def inner(app):
        app.config["SERVER_NAME"] = "atlas_um.test"
        app.config["WTF_CSRF_ENABLED"] = False

    return inner


@pytest.fixture
def app(request, app_config):
    app = create_app()
    app.testing = True
    app_config(app)
    ctx = app.app_context()
    ctx.push()

    @request.addfinalizer
    def teardown():
        ctx.pop()

    return app


@pytest.fixture
def pgdb_session(request, app):
    connection = pgdb.engine.connect()
    transaction = connection.begin()
    options = dict(bind=connection, binds={})
    session = pgdb.create_scoped_session(options=options)

    pgdb.session = session

    @request.addfinalizer
    def teardown():
        transaction.rollback()
        connection.close()
        session.remove()

    return session


@pytest.fixture
def redis_session(request):
    redis.flushdb()

    @request.addfinalizer
    def teardown():
        redis.flushdb()

    return redis


@pytest.fixture
def expected_copyright_notice():
    return f"Copyright © {datetime.utcnow().year} Sony Music Entertainment"


@pytest.fixture
def exceed_rate_limit(mocker):
    patched_check_limit = mocker.patch(
        "flask_limiter.Limiter._check_request_limit"
    )
    patched_check_limit.side_effect = RateLimitExceeded(mocker.Mock())


@pytest.fixture
def authenticated(app, faker, mocker):
    mocked_get_user = mocker.patch("atlas_um.auth.utils._get_user")
    user = User(faker.pystr(), [])
    mocked_get_user.return_value = user
    return user


@pytest.fixture
def authorized_admin(app, faker, mocker):
    mocked_get_user = mocker.patch("atlas_um.auth.utils._get_user")
    user = User(faker.pystr(), [Role(Role.Values.admin)])
    mocked_get_user.return_value = user
    return user


@pytest.fixture
def authorized_api_client(app, faker, mocker):
    mocked_get_user = mocker.patch("atlas_um.auth.utils._get_user")
    user = User(faker.pystr(), [Audience(Audience.Values.api_read)])
    mocked_get_user.return_value = user
    return user


@pytest.fixture
def authorized_developer(app, faker, mocker):
    mocked_get_user = mocker.patch("atlas_um.auth.utils._get_user")
    user = User(
        faker.pystr(),
        [
            Role(Role.Values.developer),
            ResourceGroups(ResourceGroups.Values([])),
        ],
    )
    mocked_get_user.return_value = user
    return user


@pytest.fixture
def authorized_manager(app, faker, mocker):
    mocked_get_user = mocker.patch("atlas_um.auth.utils._get_user")
    user = User(faker.pystr(), [Role(Role.Values.manager)])
    mocked_get_user.return_value = user
    return user


@pytest.fixture
def bypassed_cache(app, mocker):
    mocked_cache = mocker.MagicMock()
    mocker.patch("atlas_um.extensions.cache._bypass_cache").return_value = True
    mocker.patch("atlas_um.extensions.cache").cache = mocked_cache
    return mocked_cache


@pytest.fixture
def boto3_client_mock(app, mocker):
    return mocker.patch("boto3.client").return_value