# encoding: utf-8

# Import python libs
from __future__ import absolute_import, print_function, unicode_literals
import hashlib
import logging
import os

# Import salt libs
import salt.auth
from salt.utils.versions import StrictVersion as _StrictVersion

__virtualname__ = os.path.abspath(__file__).rsplit(os.sep)[-2] or 'rest_tornado'

log = logging.getLogger(__virtualname__)

# we require at least 4.0, as that includes all the Future's stuff we use
min_tornado_version = '4.0'
has_tornado = False
try:
    import salt.ext.tornado
    if _StrictVersion(salt.ext.tornado.version) >= _StrictVersion(min_tornado_version):
        has_tornado = True
    else:
        log.error('rest_tornado requires at least tornado %s', min_tornado_version)
except (ImportError, TypeError) as err:
    has_tornado = False
    log.error('ImportError! %s', err)


def __virtual__():
    mod_opts = __opts__.get(__virtualname__, {})

    if has_tornado and 'port' in mod_opts:
        return __virtualname__

    return False


def get_application(opts):
    try:
        from . import saltnado
    except ImportError as err:
        log.error('ImportError! %s', err)
        return None

    mod_opts = opts.get(__virtualname__, {})

    paths = [
        (r"/", saltnado.SaltAPIHandler),
        (r"/login", saltnado.SaltAuthHandler),
        (r"/minions/(.*)", saltnado.MinionSaltAPIHandler),
        (r"/minions", saltnado.MinionSaltAPIHandler),
        (r"/jobs/(.*)", saltnado.JobsSaltAPIHandler),
        (r"/jobs", saltnado.JobsSaltAPIHandler),
        (r"/run", saltnado.RunSaltAPIHandler),
        (r"/events", saltnado.EventsSaltAPIHandler),
        (r"/hook(/.*)?", saltnado.WebhookSaltAPIHandler),
    ]

    # if you have enabled websockets, add them!
    if mod_opts.get('websockets', False):
        from . import saltnado_websockets

        token_pattern = r"([0-9A-Fa-f]{{{0}}})".format(len(getattr(hashlib, opts.get('hash_type', 'md5'))().hexdigest()))
        all_events_pattern = r"/all_events/{0}".format(token_pattern)
        formatted_events_pattern = r"/formatted_events/{0}".format(token_pattern)
        log.debug("All events URL pattern is %s", all_events_pattern)
        paths += [
            # Matches /all_events/[0-9A-Fa-f]{n}
            # Where n is the length of hexdigest
            # for the current hashing algorithm.
            # This algorithm is specified in the
            # salt master config file.
            (all_events_pattern, saltnado_websockets.AllEventsHandler),
            (formatted_events_pattern, saltnado_websockets.FormattedEventsHandler),
        ]

    application = salt.ext.tornado.web.Application(paths, debug=mod_opts.get('debug', False))

    application.opts = opts
    application.mod_opts = mod_opts
    application.auth = salt.auth.LoadAuth(opts)
    return application


def start():
    '''
    Start the saltnado!
    '''
    mod_opts = __opts__.get(__virtualname__, {})

    if 'num_processes' not in mod_opts:
        mod_opts['num_processes'] = 1

    if mod_opts['num_processes'] > 1 and mod_opts.get('debug', False) is True:
        raise Exception((
            'Tornado\'s debug implementation is not compatible with multiprocess. '
            'Either disable debug, or set num_processes to 1.'
        ))

    # the kwargs for the HTTPServer
    kwargs = {}
    if not mod_opts.get('disable_ssl', False):
        if 'ssl_crt' not in mod_opts:
            log.error("Not starting '%s'. Options 'ssl_crt' and "
                    "'ssl_key' are required if SSL is not disabled.",
                    __name__)

            return None
        # cert is required, key may be optional
        # https://docs.python.org/2/library/ssl.html#ssl.wrap_socket
        ssl_opts = {'certfile': mod_opts['ssl_crt']}
        if mod_opts.get('ssl_key', False):
            ssl_opts.update({'keyfile': mod_opts['ssl_key']})
        kwargs['ssl_options'] = ssl_opts

    import salt.ext.tornado.httpserver
    http_server = salt.ext.tornado.httpserver.HTTPServer(get_application(__opts__), **kwargs)
    try:
        http_server.bind(mod_opts['port'],
                         address=mod_opts.get('address'),
                         backlog=mod_opts.get('backlog', 128),
                         )
        http_server.start(mod_opts['num_processes'])
    except Exception:  # pylint: disable=broad-except
        log.error('Rest_tornado unable to bind to port %s', mod_opts['port'], exc_info=True)
        raise SystemExit(1)

    try:
        salt.ext.tornado.ioloop.IOLoop.current().start()
    except KeyboardInterrupt:
        raise SystemExit(0)