import logging
import os

from merchant_wallet_libs.logging.slack import ConioSlackLogger

from etc import settings


class LoggingFactory(object):
    @staticmethod
    def _get_logger(name):
        return logging.getLogger(name)

    @property
    def root(self):
        return LoggingFactory._get_logger('')

    @property
    def dino(self):
        return LoggingFactory._get_logger('dino.un.crodino')

    @property
    def request(self):
        return LoggingFactory._get_logger('request')

    @property
    def wallet(self):
        return LoggingFactory._get_logger('wallet')

    @property
    def btc_transactions(self):
        return LoggingFactory._get_logger('btc_transactions')

    @property
    def sms_service(self):
        return LoggingFactory._get_logger('sms_service')

    @property
    def exchange_rate_service(self):
        return LoggingFactory._get_logger('exchange_rate')

    @property
    def cards(self):
        return LoggingFactory._get_logger('cards')

    @property
    def payments(self):
        return LoggingFactory._get_logger('payments')

    @property
    def validation(self):
        return LoggingFactory._get_logger('validation')

    @property
    def security(self):
        return LoggingFactory._get_logger('security')

    @property
    def system(self):
        return LoggingFactory._get_logger('system')

    @property
    def session(self):
        return LoggingFactory._get_logger('session')

    @property
    def deprecation(self):
        return LoggingFactory._get_logger('deprecation')

    @property
    def versioning(self):
        return LoggingFactory._get_logger('versioning')

    @property
    def trading(self):
        return LoggingFactory._get_logger('trading')

    @property
    def sell(self):
        return LoggingFactory._get_logger('sell')

    @property
    def market(self):
        return LoggingFactory._get_logger('market')

    @property
    def test(self):
        return LoggingFactory._get_logger('test')

    @property
    def asks(self):
        return LoggingFactory._get_logger('asks')

    @property
    def speedup(self):
        return LoggingFactory._get_logger('speedup')

    @property
    def user(self):
        return LoggingFactory._get_logger('user')

    @property
    def wallet_bittrade(self):
        return LoggingFactory._get_logger('wallet.bittrade')

    @property
    def entry_point(self):
        return LoggingFactory._get_logger('entry_point')

    @property
    def btc_tx_create_trace(self):
        return LoggingFactory._get_logger('btc_tx_create_trace')

    @property
    def fees_info(self):
        return LoggingFactory._get_logger('fees_info')

    @property
    def ask_create_trace(self):
        return LoggingFactory._get_logger('ask_create_trace')

    @property
    def safe_withdrawal(self):
        return LoggingFactory._get_logger('safe_withdrawal')

    @property
    def testing(self):
        return LoggingFactory._get_logger('testing')

    @property
    def onboarding(self):
        return LoggingFactory._get_logger('onboarding')


class EventsLoggingFactory(object):

    class _internalEventsLogger:
        def __init__(self, name):
            self._logger = logging.getLogger('monitoring_events.'+name)

        def log(self, payload):
            self._logger.info("", extra={'conio_data': payload})

    @property
    def timing(self):
        return self._internalEventsLogger('timing')


LOGGING_FACTORY = LoggingFactory()
EVENTS_FACTORY = EventsLoggingFactory()


def _init_logging():
    import etc
    from logging import config

    path = os.path.dirname(etc.__file__)
    resource = os.path.join(
        path,
        os.environ['CONIO_ENV'],
        'logging.conf'
    )

    print('Configuring logger using file {}'.format(resource))
    config.fileConfig(resource, disable_existing_loggers=False)

    if settings.SENTRY_ENABLE:
        print('Configuring Sentry handler')
        import sentry_sdk
        from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
        sentry_sdk.init(
            settings.SENTRY_DSN,
            integrations=[AwsLambdaIntegration()],
            environment=settings.SENTRY_ENVIRONMENT)

    if settings.SLACK_ENABLE:
        slack_handler = ConioSlackLogger(
            settings.SLACK_APIKEY,
            'logging_staging',
            stack_trace=True,
            catch_all_exceptions=True
        )
        slack_handler.setLevel(logging.ERROR)
        logging.getLogger().addHandler(slack_handler)


_init_logging()