from __future__ import absolute_import

from leap.common.events import (server as events_server)
from pixelated.adapter.welcome_mail import add_welcome_mail
from pixelated.authentication import Authenticator
from pixelated.bitmask_libraries.certs import LeapCertificate
from pixelated.bitmask_libraries.provider import LeapProvider
from pixelated.config import credentials
from pixelated.config import leap_config
from pixelated.config.sessions import LeapSessionFactory
from twisted.internet import defer
from twisted.logger import Logger

log = Logger()


def initialize_leap_provider(provider_hostname, provider_cert, provider_fingerprint, leap_home):
    LeapCertificate.set_cert_and_fingerprint(provider_cert,
                                             provider_fingerprint)
    leap_config.set_leap_home(leap_home)
    provider = LeapProvider(provider_hostname)
    provider.setup_ca()
    provider.download_settings()
    return provider


@defer.inlineCallbacks
def initialize_leap_multi_user(provider_hostname,
                               leap_provider_cert,
                               leap_provider_cert_fingerprint,
                               credentials_file,
                               leap_home):

    config, provider = initialize_leap_provider(provider_hostname, leap_provider_cert, leap_provider_cert_fingerprint, leap_home)

    defer.returnValue((config, provider))


@defer.inlineCallbacks
def create_leap_session(provider, username, password, auth=None):
    leap_session = yield LeapSessionFactory(provider).create(username, password, auth)
    defer.returnValue(leap_session)


@defer.inlineCallbacks
def initialize_leap_single_user(leap_provider_cert,
                                leap_provider_cert_fingerprint,
                                credentials_file,
                                leap_home):

    init_monkeypatches()
    events_server.ensure_server()

    provider, username, password = credentials.read(credentials_file)

    provider = initialize_leap_provider(provider, leap_provider_cert, leap_provider_cert_fingerprint, leap_home)

    auth = Authenticator(provider).authenticate(username, password)

    leap_session = yield create_leap_session(provider, username, password, auth)

    defer.returnValue(leap_session)


def init_monkeypatches():
    import pixelated.extensions.requests_urllib3


class BootstrapUserServices(object):

    def __init__(self, services_factory, provider):
        self._services_factory = services_factory
        self._provider = provider

    @defer.inlineCallbacks
    def setup(self, user_auth, password, language='pt-BR'):
        leap_session = yield create_leap_session(self._provider, user_auth.username, password, user_auth)
        yield self._setup_user_services(leap_session)
        yield self._add_welcome_email(leap_session, language)

    @defer.inlineCallbacks
    def _setup_user_services(self, leap_session):
        user_id = leap_session.user_auth.uuid
        if not self._services_factory.has_session(user_id):
            yield self._services_factory.create_services_from(leap_session)
            self._services_factory.map_email(leap_session.user_auth.username, user_id)

    @defer.inlineCallbacks
    def _add_welcome_email(self, leap_session, language):
        if leap_session.fresh_account:
            yield add_welcome_mail(leap_session.mail_store, language)