"""CherryPy Application and Tree objects."""

import os

import cherrypy
from cherrypy import _cpconfig, _cplogging, _cprequest, _cpwsgi, tools
from cherrypy.lib import httputil, reprconf


class Application(object):
    """A CherryPy Application.

    Servers and gateways should not instantiate Request objects
    directly. Instead, they should ask an Application object for a
    request object.

    An instance of this class may also be used as a WSGI callable (WSGI
    application object) for itself.
    """

    root = None
    """The top-most container of page handlers for this app.

    Handlers should be arranged in a hierarchy of attributes, matching
    the expected URI hierarchy; the default dispatcher then searches
    this hierarchy for a matching handler. When using a dispatcher other
    than the default, this value may be None.
    """

    config = {}
    """A dict of {path: pathconf} pairs, where 'pathconf' is itself a dict
    of {key: value} pairs."""

    namespaces = reprconf.NamespaceSet()
    toolboxes = {'tools': cherrypy.tools}

    log = None
    """A LogManager instance.

    See _cplogging.
    """

    wsgiapp = None
    """A CPWSGIApp instance.

    See _cpwsgi.
    """

    request_class = _cprequest.Request
    response_class = _cprequest.Response

    relative_urls = False

    def __init__(self, root, script_name='', config=None):
        """Initialize Application with given root."""
        self.log = _cplogging.LogManager(id(self), cherrypy.log.logger_root)
        self.root = root
        self.script_name = script_name
        self.wsgiapp = _cpwsgi.CPWSGIApp(self)

        self.namespaces = self.namespaces.copy()
        self.namespaces['log'] = lambda k, v: setattr(self.log, k, v)
        self.namespaces['wsgi'] = self.wsgiapp.namespace_handler

        self.config = self.__class__.config.copy()
        if config:
            self.merge(config)

    def __repr__(self):
        """Generate a representation of the Application instance."""
        return '%s.%s(%r, %r)' % (self.__module__, self.__class__.__name__,
                                  self.root, self.script_name)

    script_name_doc = """The URI "mount point" for this app. A mount point
    is that portion of the URI which is constant for all URIs that are
    serviced by this application; it does not include scheme, host, or proxy
    ("virtual host") portions of the URI.

    For example, if script_name is "/my/cool/app", then the URL
    "http://www.example.com/my/cool/app/page1" might be handled by a
    "page1" method on the root object.

    The value of script_name MUST NOT end in a slash. If the script_name
    refers to the root of the URI, it MUST be an empty string (not "/").

    If script_name is explicitly set to None, then the script_name will be
    provided for each call from request.wsgi_environ['SCRIPT_NAME'].
    """

    @property
    def script_name(self):  # noqa: D401; irrelevant for properties
        """The URI "mount point" for this app.

        A mount point is that portion of the URI which is constant for
        all URIs that are serviced by this application; it does not
        include scheme, host, or proxy ("virtual host") portions of the
        URI.

        For example, if script_name is "/my/cool/app", then the URL "

        http://www.example.com/my/cool/app/page1"
        might be handled by a
        "page1" method on the root object.

        The value of script_name MUST NOT end in a slash. If the script_name
        refers to the root of the URI, it MUST be an empty string (not "/").

        If script_name is explicitly set to None, then the script_name will be
        provided for each call from request.wsgi_environ['SCRIPT_NAME'].
        """
        if self._script_name is not None:
            return self._script_name

        # A `_script_name` with a value of None signals that the script name
        # should be pulled from WSGI environ.
        return cherrypy.serving.request.wsgi_environ['SCRIPT_NAME'].rstrip('/')

    @script_name.setter
    def script_name(self, value):
        if value:
            value = value.rstrip('/')
        self._script_name = value

    def merge(self, config):
        """Merge the given config into self.config."""
        _cpconfig.merge(self.config, config)

        # Handle namespaces specified in config.
        self.namespaces(self.config.get('/', {}))

    def find_config(self, path, key, default=None):
        """Return the most-specific value for key along path, or default."""
        trail = path or '/'
        while trail:
            nodeconf = self.config.get(trail, {})

            if key in nodeconf:
                return nodeconf[key]

            lastslash = trail.rfind('/')
            if lastslash == -1:
                break
            elif lastslash == 0 and trail != '/':
                trail = '/'
            else:
                trail = trail[:lastslash]

        return default

    def get_serving(self, local, remote, scheme, sproto):
        """Create and return a Request and Response object."""
        req = self.request_class(local, remote, scheme, sproto)
        req.app = self

        for name, toolbox in self.toolboxes.items():
            req.namespaces[name] = toolbox

        resp = self.response_class()
        cherrypy.serving.load(req, resp)
        cherrypy.engine.publish('acquire_thread')
        cherrypy.engine.publish('before_request')

        return req, resp

    def release_serving(self):
        """Release the current serving (request and response)."""
        req = cherrypy.serving.request

        cherrypy.engine.publish('after_request')

        try:
            req.close()
        except Exception:
            cherrypy.log(traceback=True, severity=40)

        cherrypy.serving.clear()

    def __call__(self, environ, start_response):
        """Call a WSGI-callable."""
        return self.wsgiapp(environ, start_response)


class Tree(object):
    """A registry of CherryPy applications, mounted at diverse points.

    An instance of this class may also be used as a WSGI callable (WSGI
    application object), in which case it dispatches to all mounted
    apps.
    """

    apps = {}
    """
    A dict of the form {script name: application}, where "script name"
    is a string declaring the URI mount point (no trailing slash), and
    "application" is an instance of cherrypy.Application (or an arbitrary
    WSGI callable if you happen to be using a WSGI server)."""

    def __init__(self):
        """Initialize registry Tree."""
        self.apps = {}

    def mount(self, root, script_name='', config=None):
        """Mount a new app from a root object, script_name, and config.

        root
            An instance of a "controller class" (a collection of page
            handler methods) which represents the root of the application.
            This may also be an Application instance, or None if using
            a dispatcher other than the default.

        script_name
            A string containing the "mount point" of the application.
            This should start with a slash, and be the path portion of the
            URL at which to mount the given root. For example, if root.index()
            will handle requests to "http://www.example.com:8080/dept/app1/",
            then the script_name argument would be "/dept/app1".

            It MUST NOT end in a slash. If the script_name refers to the
            root of the URI, it MUST be an empty string (not "/").

        config
            A file or dict containing application config.
        """
        if script_name is None:
            raise TypeError(
                "The 'script_name' argument may not be None. Application "
                'objects may, however, possess a script_name of None (in '
                'order to inpect the WSGI environ for SCRIPT_NAME upon each '
                'request). You cannot mount such Applications on this Tree; '
                'you must pass them to a WSGI server interface directly.')

        # Next line both 1) strips trailing slash and 2) maps "/" -> "".
        script_name = script_name.rstrip('/')

        if isinstance(root, Application):
            app = root
            if script_name != '' and script_name != app.script_name:
                raise ValueError(
                    'Cannot specify a different script name and pass an '
                    'Application instance to cherrypy.mount')
            script_name = app.script_name
        else:
            app = Application(root, script_name)

            # If mounted at "", add favicon.ico
            needs_favicon = (
                script_name == ''
                and root is not None
                and not hasattr(root, 'favicon_ico')
            )
            if needs_favicon:
                favicon = os.path.join(
                    os.getcwd(),
                    os.path.dirname(__file__),
                    'favicon.ico',
                )
                root.favicon_ico = tools.staticfile.handler(favicon)

        if config:
            app.merge(config)

        self.apps[script_name] = app

        return app

    def graft(self, wsgi_callable, script_name=''):
        """Mount a wsgi callable at the given script_name."""
        # Next line both 1) strips trailing slash and 2) maps "/" -> "".
        script_name = script_name.rstrip('/')
        self.apps[script_name] = wsgi_callable

    def script_name(self, path=None):
        """Return the script_name of the app at the given path, or None.

        If path is None, cherrypy.request is used.
        """
        if path is None:
            try:
                request = cherrypy.serving.request
                path = httputil.urljoin(request.script_name,
                                        request.path_info)
            except AttributeError:
                return None

        while True:
            if path in self.apps:
                return path

            if path == '':
                return None

            # Move one node up the tree and try again.
            path = path[:path.rfind('/')]

    def __call__(self, environ, start_response):
        """Pre-initialize WSGI env and call WSGI-callable."""
        # If you're calling this, then you're probably setting SCRIPT_NAME
        # to '' (some WSGI servers always set SCRIPT_NAME to '').
        # Try to look up the app using the full path.
        env1x = environ
        path = httputil.urljoin(env1x.get('SCRIPT_NAME', ''),
                                env1x.get('PATH_INFO', ''))
        sn = self.script_name(path or '/')
        if sn is None:
            start_response('404 Not Found', [])
            return []

        app = self.apps[sn]

        # Correct the SCRIPT_NAME and PATH_INFO environ entries.
        environ = environ.copy()
        environ['SCRIPT_NAME'] = sn
        environ['PATH_INFO'] = path[len(sn.rstrip('/')):]
        return app(environ, start_response)
