"""
open/dulcinea/lib/ui/debug.qpy
"""
import os, os.path, sys
from datetime import timedelta, datetime
from dulcinea.ui.table import Table
from dulcinea.ui.user.util import ensure_admin_access
from dulcinea.ui.util import item_list, dl, boxtitle
from durus.persistent import PersistentObject
from pprint import pformat
from qp.fill.directory import Directory
from qp.fill.form import Form
from qp.fill.html import href, nl2br
from qp.lib.util import get_memory_usage, get_output
from qp.pub.common import get_publisher, get_request, get_session, get_response
from qp.pub.common import redirect, get_connection, header, footer, get_fields
from qpy import xml, xml_quote

class DurusDirectory(Directory):

    def __init__(self, obj=None):
        self.obj = obj

    def get_exports(self):
        ensure_admin_access()
        yield ('', '_q_index', self.get_object().__class__.__name__, None)

    def get_object(self):
        if self.obj is None:
            return get_publisher().get_connection().get_root()
        else:
            return self.obj

    def _q_index:xml(self):
        self.display(self.get_object())

    def _q_lookup(self, component):
        try:
            durus_id = int(component)
        except ValueError:
            return None
        object = get_publisher().get_connection().get(durus_id)
        if object is not None:
            return DurusDirectory(object)
        else:
            return None

    def display:xml(self, obj):
        def ref_repr(obj):
            return str(href(obj._p_format_durus_id() + '/', obj._repr()))
        str_obj = str(obj)
        def format(value):
            pformatted = pformat(value)
            if isinstance(value, datetime):
                return xml_quote(pformatted)
            elif " at " in pformatted:
                return xml('<pre>%s</pre>') % pformatted
            else:
                return nl2br(xml(pformatted))
        PersistentObject._repr = PersistentObject.__repr__
        PersistentObject.__repr__ = ref_repr
        try:
            title = "Object: %s" % obj._p_format_durus_id()
            header(title)
            '<div class="popup">'
            boxtitle(str_obj)
            dl([(attr, format(value))
                for attr, value in
                sorted((obj.__getstate__() or {}).items())])
            '</div>'
            footer(title)
        finally:
            PersistentObject.__repr__ = PersistentObject._repr
            del PersistentObject._repr

class DebugDirectory(Directory):

    def get_exports(self):
        ensure_admin_access()
        yield ('', '_q_index', 'Tools', 'Debugging Tools')
        yield ('dumpenv', 'dumpenv', 'Environment',
               'Dump request environment variables')
        yield ('exception', 'exception', 'Exception', 'Raise an exception')
        yield ('browse_sessions', 'browse_sessions', 'Sessions',
               'Browse open sessions')
        yield ('browse', 'browse', 'Exports',
               'Browse exported names')
        if os.name == 'posix':
            yield ('client', 'client', 'Client', 'Client process info')
            yield ('durusfile', 'durusfile', '.durus',
                'Stat/Pack the data file.')
        yield ('view_publisher_config', 'view_publisher_configuration',
            'Config', 'View publisher configuration')
        yield ('log', 'log', 'Log', 'The tail of the log.')
        yield ('durus', 'durus', 'Browse', 'Browse Durus Database')


    def _q_index:xml(self):
        title = "Debugging Tools"
        header(title)
        '<div class="popup">'
        item_list(
            ('dumpenv', 'Dump request environment variables'),
            ('exception', 'Raise an exception'),
            ('browse_sessions', 'Browse open sessions'),
            ('view_publisher_config', 'View publisher configuration'),
            ('durusfile', 'Durus file management'),
            ('browse', 'Browse Exports'),
            ('log', 'Log'),
            ('durus', 'Browse Durus Database'),
            )
        '</div>'
        footer(title)

    def _q_lookup(self, component):
        session = get_publisher().get_sessions().get(component)
        if session is None:
            return None
        get_response().set_header('Content-type', 'text/plain')
        return "%s:\n%s\n\n" % (pformat(session), pformat(vars(session)))

    def client:xml(self):
        title = "Client Information"
        header(title)
        '<div style="margin:1em">'
        'pid = %s<br/>' % os.getpid()
        real, virtual = get_memory_usage()
        'real = %s<br/>' % real
        'virtual = %s<br/>' % virtual
        'Cache target size = %s<br/>' % get_connection().get_cache_size()
        '</div>'
        by_class = {}
        for x in get_connection().get_cache():
            name = x.__class__.__name__
            if name not in by_class:
                by_class[name] = [0, 0, 0]
            by_class[name][x._p_status + 1] += 1
        table = Table()
        table.column(class_name='Class')
        table.column(ghost='Ghost')
        table.column(saved='Saved')
        table.column(unsaved='Unsaved')
        table.column(total="Total")
        ghost_total = 0
        saved_total = 0
        unsaved_total = 0
        total_total = 0
        for name, items in sorted(by_class.items()):
            ghost_total += items[0]
            saved_total += items[1]
            unsaved_total += items[2]
            total_total += sum(items)
            table.row(class_name=name, ghost=items[0], saved=items[1],
                unsaved=items[2], total=sum(items))
        table.set_title(ghost="Ghost<br/>&Sigma;=%s" % ghost_total)
        table.set_title(saved="Saved<br/>&Sigma;=%s" % saved_total)
        table.set_title(unsaved="Unsaved<br/>&Sigma;=%s" % unsaved_total)
        table.set_title(total="Total<br/>&Sigma;=%s" % total_total)
        def tfooter:xml():
            '<tbody>'
            '<tr>'
            '<th>Totals</th>'
            '<th>%s</th>' % ghost_total
            '<th>%s</th>' % saved_total
            '<th>%s</th>' % unsaved_total
            '<th>%s</th>' % total_total
            '</tr>'
            '</tbody>'
        table.set_footer(tfooter())
        '<div style="clear:both"></div>'
        '<div class="popup">'
        table.render(css_class="pretty")
        '</div>'
        footer(title)


    def durusfile:xml(self):
        title = 'Durus File'
        header(title)
        durus_file_name = get_publisher().get_site().get_durus_file()
        '<div class="popup">'
        '<dl>'
        '<dt>sys.executable</dt><dd>%s</dd>' % sys.executable
        '<dt>sys.version</dt><dd>%s</dd>' % sys.version
        '<dt>File</dt><dd>%s</dd>' % durus_file_name
        '<dt>File Prefix</dt><dd>%s</dd>' % get_output(
            str("head -1 %s" % durus_file_name))[:10]
        filestat = os.stat(durus_file_name)
        from grp import getgrgid
        from pwd import getpwuid
        uid = filestat.st_uid
        gid = filestat.st_gid
        rwx = ['---', '--x', '-w-', '-wx', 'r--', 'r-x', 'rw-', 'rwx']
        owner = getpwuid(uid).pw_name
        group = getgrgid(gid).gr_name
        permissions = (
            rwx[filestat.st_mode >> 6 & 7] +
            rwx[filestat.st_mode >> 3 & 7] +
            rwx[filestat.st_mode & 7])
        data = dict(
            permissions=permissions,
            owner=owner,
            group=group,
            size=filestat.st_size,
            atime=datetime.fromtimestamp(filestat.st_atime),
            ctime=datetime.fromtimestamp(filestat.st_ctime),
            mtime=datetime.fromtimestamp(filestat.st_mtime))

        for key, value in sorted(data.items()):
            '<dt>%s</dt>' % key
            '<dd>%s</dd>' % value
        '</dl>'
        '<pre>'
        get_output(str("df -m %s" % durus_file_name))

        '</pre>'

        form = Form(css_class="nopopup")
        form.add_submit('pack', 'Pack')
        if form.get('pack'):
            get_connection().pack()
            redirect('')
        form.render()
        '<div style="clear:left"></div>'
        '</div>' # popup
        footer(title)

    def dumpenv:xml(self):
        title = 'Enviroment Dump'
        header(title)
        lines = []
        '<div class="popup">'
        '<h1><tt>request.environ</tt>:</h1>'
        env = get_request().environ

        for item in sorted(env.items()):
            '%s=%s<br />' % item

        '<h1><tt>os.environ</tt>:</h1>'
        if os.environ is env:
            '(identical to <tt>request.environ</tt>)'
        elif os.environ == env:
            '(equal to <tt>request.environ</tt>)'
        else:
            for item in sorted(os.environ.items()):
                '%s=%s<br />' % item
        '</div>'
        footer(title=title)

    def exception(self):
        assert 0, 'relax, just testing'

    def browse_sessions:xml(self):
        header('Open Sessions')
        table = Table()
        table.column(id='Id')
        table.column(user='User')
        table.column(last_user='Authenticated Owner')
        table.column(address='Address')
        table.column(authentication="Authentication")
        table.column(access="Access")
        table.column(action="Action")
        sessions = get_publisher().get_sessions()
        to_remove = []
        form = Form(use_tokens=False)
        form.add_submit('delete_old',
            'Delete all sessions not accessed in 24 hours.')
        form.render()
        '<br style="clear:left" />'
        if form.get('delete_old'):
            cutoff = get_session().get_access_time() - timedelta(hours=24)
            to_remove = [key for key, s in sessions.items()
                if s.get_access_time() < cutoff]
            for key in to_remove:
                del sessions[key]
            redirect('')
        for id, session in sessions.iteritems():
            access = session.get_access_time()
            form = Form(use_tokens=False, css_class="nopopup")
            form.add_submit(id, value="Delete")
            if form.get(id):
                to_remove.append(id)
                continue
            table.row(
                id=id,
                last_user=session.get_owner().get_id(),
                address=session.get_remote_address(),
                authentication=session.get_authentication_time(),
                access=session.get_access_time(),
                action=form.render(),
                user=session.get_effective_user().get_id())
        for id in to_remove:
            if id in sessions:
                del sessions[id]
        '<div style="clear:both"></div>'
        '<div class="popup" style="width:95%">'
        table.render(css_class="pretty")
        '</div>'
        footer(title='Open Sessions')

    def view_publisher_configuration:xml(self):
        title = 'Publisher Configuration'
        header(title)
        '<div class="popup">'
        '<dl>'
        items = sorted(get_publisher().configuration.items())
        for item in items:
            '<dt>%s</dt><dd>%r</dd>' % item

        '<dt>is_email_enabled()</dt>'
        '<dd>%r</dd>' % get_publisher().is_email_enabled()
        '<dt>get_smtp_server()</dt>'
        '<dd>%r</dd>' % get_publisher().get_smtp_server()
        '<dt>get_webmaster_address()</dt>'
        '<dd>%r</dd>' % get_publisher().get_webmaster_address()
        '<dt>display_exceptions()</dt>'
        '<dd>%r</dd>' % get_publisher().display_exceptions()
        '</dl>'
        '</div>'
        footer(title)

    def log(self):
        filename = get_publisher().get_site().get_logfile()
        get_response().set_content_type('text/plain', 'utf-8')
        return get_output("tail -1000 %s" % filename)

    def browse:xml(self):
        title = 'Browse'
        header(title)
        '<div class="popup">'
        form = get_fields()
        if form:
            redirect(str(form.get('path') + '/' + form.get('component')))
        def process:xml(directory, base_path):
            exports = sorted([export[0] for export in directory.get_exports()])
            for name in exports:
                objname = directory._q_translate(name)
                if objname is None:
                    obj = directory._q_lookup(name)
                else:
                    obj = getattr(directory, objname)
                if isinstance(obj, (Directory, Directory)):
                    process(obj, base_path + '/' + name)
                else:
                    full_name = base_path +'/' + name
                    href(full_name, full_name)
                    '<br />'
                    if (name == '' and hasattr(directory, '_q_lookup')):
                        q_lookup = directory._q_lookup
                        def get_function(method):
                            if sys.version < "3":
                                return method.im_func
                            else:
                                return getattr(method, '__function__', method)
                        if (get_function(q_lookup) != get_function(
                            Directory._q_lookup)):
                            '<form style="display:inline" action="browse" '
                            'method="post">'
                            full_name
                            '<input name="path" type="hidden" '
                            'value="%s" />' % base_path
                            '<input name="component" type="string" size="20" '
                            'style="display:inline"/>'
                            '</form>'
                            '<br />'
        '<div style="font-size:smaller; margin:2em">'
        process(get_publisher().get_root_directory(),
            get_request().get_script_name())
        '</div>'
        '</div>' # popup
        footer(title)

    durus = DurusDirectory()