import os
from datetime import date
import pytest
from alembic.command import upgrade
from alembic.config import Config
from flask.ext.migrate import Migrate, MigrateCommand
from flask.ext.script import Manager
from sqlalchemy.schema import MetaData
from app import create_app, db

from . import (
    create_test_user, service_json, TestClient,
    get_test_user, template_json, api_key_json)


@pytest.fixture(scope='session')
def app_(request):
    app = create_app('test')

    ctx = app.app_context()
    ctx.push()

    def teardown():
        ctx.pop()

    request.addfinalizer(teardown)
    app.test_client_class = TestClient
    return app


@pytest.fixture(scope='session')
def db_(app_, request):
    Migrate(app_, db)
    Manager(db, MigrateCommand)
    BASE_DIR = os.path.dirname(os.path.dirname(__file__))
    ALEMBIC_CONFIG = os.path.join(BASE_DIR, 'migrations')
    config = Config(ALEMBIC_CONFIG + '/alembic.ini')
    config.set_main_option("script_location", ALEMBIC_CONFIG)

    with app_.app_context():
        upgrade(config, 'head')

    def teardown():
        db.session.remove()
        db.drop_all()
        db.engine.execute("drop table alembic_version")
        db.get_engine(app_).dispose()

    request.addfinalizer(teardown)


@pytest.fixture(scope='function')
def db_session(request):
    def teardown():
        db.session.remove()
        for tbl in reversed(meta.sorted_tables):
            if tbl.fullname not in ['roles']:
                db.engine.execute(tbl.delete())

    meta = MetaData(bind=db.engine, reflect=True)
    request.addfinalizer(teardown)


@pytest.fixture(scope='function')
def service_one(request, mock_api_user):
    return service_json(1, 'service one', [mock_api_user.id])


@pytest.fixture(scope='function')
def mock_send_sms(request, mocker):
    return mocker.patch("app.notifications_api_client.send_sms")


@pytest.fixture(scope='function')
def mock_send_email(request, mocker):
    return mocker.patch("app.notifications_api_client.send_email")


@pytest.fixture(scope='function')
def mock_get_service(mocker, mock_api_user):
    def _get(service_id):
        service = service_json(
            service_id, "Test Service", [mock_api_user.id], limit=1000,
            active=False, restricted=True)
        return {'data': service, 'token': 1}

    return mocker.patch('app.notifications_api_client.get_service', side_effect=_get)


@pytest.fixture(scope='function')
def mock_create_service(mocker):
    def _create(service_name, active, limit, restricted, user_id):
        service = service_json(
            101, service_name, [user_id], limit=limit,
            active=active, restricted=restricted)
        return {'data': service}

    mock_class = mocker.patch(
        'app.notifications_api_client.create_service', side_effect=_create)
    return mock_class


@pytest.fixture(scope='function')
def mock_update_service(mocker):
    def _update(service_id,
                service_name,
                active,
                limit,
                restricted,
                users):
        service = service_json(
            service_id, service_name, users, limit=limit,
            active=active, restricted=restricted)
        return {'data': service}

    mock_class = mocker.patch(
        'app.notifications_api_client.update_service', side_effect=_update)
    return mock_class


@pytest.fixture(scope='function')
def mock_get_services(mocker, mock_active_user):
    def _create(user_id):
        service_one = service_json(
            1, "service_one", [mock_active_user.id], 1000, True, False)
        service_two = service_json(
            2, "service_two", [mock_active_user.id], 1000, True, False)
        return {'data': [service_one, service_two]}

    mock_class = mocker.patch(
        'app.notifications_api_client.get_services', side_effect=_create)
    return mock_class


@pytest.fixture(scope='function')
def mock_delete_service(mocker, mock_get_service):
    def _delete(service_id):
        return mock_get_service.side_effect(service_id)

    mock_class = mocker.patch(
        'app.notifications_api_client.delete_service', side_effect=_delete)
    return mock_class


@pytest.fixture(scope='function')
def mock_get_service_template(mocker):
    def _create(service_id, template_id):
        template = template_json(
            template_id, "Template Name", "sms", "template content", service_id)
        return {'data': template}

    return mocker.patch(
        'app.notifications_api_client.get_service_template', side_effect=_create)


@pytest.fixture(scope='function')
def mock_create_service_template(mocker):
    def _create(name, type_, content, service):
        template = template_json(
            101, name, type_, content, service)
        return {'data': template}

    mock_class = mocker.patch(
        'app.notifications_api_client.create_service_template',
        side_effect=_create)
    return mock_class


@pytest.fixture(scope='function')
def mock_update_service_template(mocker):
    def _update(id_, name, type_, content, service):
        template = template_json(
            id_, name, type_, content, service)
        return {'data': template}

    mock_class = mocker.patch(
        'app.notifications_api_client.update_service_template',
        side_effect=_update)
    return mock_class


@pytest.fixture(scope='function')
def mock_get_service_templates(mocker):
    def _create(service_id):
        template_one = template_json(
            1, "template_one", "sms", "template one content", service_id)
        template_two = template_json(
            2, "template_two", "sms", "template two content", service_id)
        return {'data': [template_one, template_two]}

    mock_class = mocker.patch(
        'app.notifications_api_client.get_service_templates',
        side_effect=_create)
    return mock_class


@pytest.fixture(scope='function')
def mock_delete_service_template(mocker):
    def _delete(service_id, template_id):
        template = template_json(
            template_id, "Template to delete",
            "sms", "content to be deleted", service_id)
        return {'data': template}

    return mocker.patch(
        'app.notifications_api_client.delete_service_template', side_effect=_delete)


@pytest.fixture(scope='function')
def mock_api_user(mocker):
    from app.notify_client.user_api_client import User
    user_data = {'id': 1,
                 'name': 'Test User',
                 'password': 'somepassword',
                 'email_address': 'test@user.gov.uk',
                 'mobile_number': '+4412341234',
                 'state': 'pending',
                 'failed_login_count': 0
                 }
    user = User(user_data)
    return user


@pytest.fixture(scope='function')
def mock_register_user(mocker, mock_api_user):

    def _register(name, email_address, mobile_number, password):
        mock_api_user.name = name
        mock_api_user.email_address = email_address
        mock_api_user.mobile_number = mobile_number
        mock_api_user.password = password
        return mock_api_user

    return mocker.patch('app.user_api_client.register_user', side_effect=_register)


@pytest.fixture(scope='function')
def mock_active_user(mocker, mock_api_user):
    mock_api_user.state = 'active'
    return mock_api_user


@pytest.fixture(scope='function')
def mock_activate_user(mocker):

    def _activate(user):
        user.state = 'active'
        return user

    return mocker.patch('app.user_api_client.update_user', side_effect=_activate)


@pytest.fixture(scope='function')
def mock_get_user(mocker, mock_active_user):

    def _get_user(id):
        return mock_active_user

    return mocker.patch('app.main.dao.users_dao.get_user_by_id', side_effect=_get_user)


@pytest.fixture(scope='function')
def mock_get_by_email(mocker, mock_api_user, mock_active_user, mock_get_user):

    def _get_user(email_address):
        if email_address == 'notfound@example.gov.uk':
            return None
        if email_address == 'locked_user@example.gov.uk':
            mock_active_user.failed_login_count = 5
            return mock_active_user
        if email_address == 'inactive_user@example.gov.uk':
            mock_active_user.state = 'inactive'
        if email_address == 'pending_user@example.gov.uk':
            return mock_api_user

        else:
            mock_active_user.email_address = email_address
            return mock_active_user
    return mocker.patch('app.main.dao.users_dao.get_user_by_email', side_effect=_get_user)


@pytest.fixture(scope='function')
def mock_user_checkpassword(mocker, mock_active_user):

    def _check(mock_active_user, password):
        return True

    return mocker.patch('app.main.dao.users_dao.verify_password', side_effect=_check)


@pytest.fixture(scope='function')
def mock_update_email(mocker, mock_active_user):

    def _update(id, email_address):
        mock_active_user.email_address = email_address

    return mocker.patch('app.main.dao.users_dao.update_email_address', side_effect=_update)


@pytest.fixture(scope='function')
def mock_update_mobile(mocker, mock_active_user):

    def _update(id, mobile_number):
        mock_active_user.mobile_number = mobile_number

    return mocker.patch('app.main.dao.users_dao.update_mobile_number', side_effect=_update)


@pytest.fixture(scope='function')
def mock_password_reset(mocker, mock_active_user):

    def _reset(email):
        mock_active_user.state = 'request_password_reset'

    return mocker.patch('app.main.dao.users_dao.request_password_reset', side_effect=_reset)


@pytest.fixture(scope='function')
def mock_create_api_key(mocker):
    def _create(service_id, key_name):
        import uuid
        return {'data': str(uuid.uuid4())}

    mock_class = mocker.patch('app.api_key_api_client.create_api_key', side_effect=_create)
    return mock_class


@pytest.fixture(scope='function')
def mock_revoke_api_key(mocker):
    def _revoke(service_id, key_id):
        return {}

    mock_class = mocker.patch('app.api_key_api_client.revoke_api_key', side_effect=_revoke)
    return mock_class


@pytest.fixture(scope='function')
def mock_get_api_keys(mocker):
    def _get_keys(service_id, key_id=None):
        keys = {'apiKeys': [api_key_json(1, 'some key name'),
                            api_key_json(2, 'another key name', expiry_date=str(date.fromtimestamp(0)))]}
        return keys

    mock_class = mocker.patch('app.api_key_api_client.get_api_keys', side_effect=_get_keys)
    return mock_class


@pytest.fixture(scope='function')
def mock_get_no_api_keys(mocker):
    def _get_keys(service_id):
        keys = {'apiKeys': []}
        return keys

    mock_class = mocker.patch('app.api_key_api_client.get_api_keys', side_effect=_get_keys)
    return mock_class