from zsite import ZSite
from zmath import ZMath
from tools import convert
import Globals, OFS
import string, re, time


class ZZMath(ZSite):
    id        = 'zmath'
    name      = 'ZZMath'
    icon      = 'misc_/ZZMath/Icon'
    meta_type = 'ZZMath'
    color     = '#003366'

    _properties = ZSite._properties

    manage_options = (
        ZSite.manage_options[0],
        ZSite.manage_options[1],
        {
            'label'  : 'ZMath',
            'icon'   : '',
            'action' : 'manage_zmath',
            'target' : '_self',
        },
        ZSite.manage_options[2],
        ZSite.manage_options[3],
        ZSite.manage_options[4],
        ZSite.manage_options[5],
        ZSite.manage_options[6],
        ZSite.manage_options[7],
        ZSite.manage_options[8],
        ZSite.manage_options[9],
        ZSite.manage_options[10],
    )

    manage_zmath      = Globals.DTMLFile('manage/zmath', globals())

    manage_zmath_dtml = Globals.DTMLFile('manage/code/zmath', globals())


    def __init__(self, name, database, location):
        self._v_system = ZMath(name, database, location)
        return


    def init(self):
        self._v_system = ZMath(self.name, self.database, self.location)
        return


    def edbminit(self, path):
        return self._v_system.edbminit(path)


    def edbmopen(self, name, format=''):
        return self._v_system.edbmopen(name, format)


    def edbmlog(self, user, id, ip, first, last, count, type, format, script, query):
        return self._v_system.edbmlog(user, id, ip, first, last, count, type, format, script, query)


    def edbmdate(self):
        return self._v_system.edbmdate()


    def edbmfind(self, db, query, first, last, virtual=""):
        if not query:
            return self.EdbmResult(error='no query')
        resultset = self._v_system.edbmfind(db, query, first, last)
        if resultset == None:
            return self.EdbmResult(error='invalid query')
        if virtual == 'repr_html_short' and len(resultset) == 1:
	    virtual = 'repr_html_complete repr_html_short'
        resultlist = []
        count = 0
        for result in resultset:
            item = self.EdbmItem(first + count)
	    if virtual == 'all':
	        attributes = db._factory.schema['attrinfo'].keys()
	    else:
	        attributes = list(db._factory.schema['fields']) + virtual.split()
                if virtual.startswith('repr_html'):
                    attributes += ['openurl_0_1', 'openurl_1_0']
	    for name in attributes:
		    setattr(item, name, getattr(result, name))
	    setattr(item, 'attributes', attributes)
            resultlist.append(item)
            count += 1
        return self.EdbmResult(resultset.total, resultlist)


    def edbmeval(self, query, first, last, db=None, virtual=""):
        if query == None:
            return None
        if db == None:
            db = self.edbmopen('zmath')
        tm = time.time()
        result = self.edbmfind(db, query, first, last, virtual)
        tm = time.time() - tm
        if result:
            result.query = query
            result.first = first
            result.last  = last
            result.time  = tm
        return result


    def form2query(self, request):
	return self._v_system.form2query(request)


    def query2edbm(self, query):
	return self._v_system.query2edbm(query)


    def external(self, query, first, last, type, format, response=None):
        if query == None: return
	db = self.edbmopen('zmath')
	resultset = self._v_system.edbmfind(db, query, first, last)
	if resultset == None: return
	content = self._v_system.external(resultset, type, format)
        if response:
            name = 'zmath.%s' % (type)
            response.setHeader('Content-Type', 'application/%s' % (type))
            response.setHeader('Content-Length', len(content))
            response.setHeader('Accept-Ranges', 'bytes')
            response.setHeader('Content-Name', name)
            response.setHeader('Content-Disposition', 'inline; filename=%s' % (name))
            response.setHeader('text', name)
            response.write(content)
            response.setStatus('OK')
        else:
            return content
        return

    
    class EdbmResult(OFS.SimpleItem.SimpleItem):
        def __init__(self, total=0, list=[], error=None):
            self.total = total
            self.list  = list
            self.error = error
            return
        def __nonzero__(self):
            return self.total != 0


    class EdbmItem(OFS.SimpleItem.SimpleItem):
        def __init__(self, index):
            self.index = index
            return
	def __str__(self):
	    list =[]
	    for attr in self.attributes:
	        list.append("%s: %s" % (attr, convert.wrap(str(getattr(self, attr)), 80)))
	    return string.join(list, '\n')


    def auth(self, request, session, username='', password=''):
        user = None
        if username and password:
            user = self._v_system.auth(username, password)
            instance = session.get(self.name, {})
            if user:
                instance['username'] = user[0]
                instance['customer'] = user[1]
                instance['authentication'] = user
            else:
                if instance.has_key('username'):
                    del instance['username']
                    del instance['customer']
                    del instance['authentication']
                    self.history(request, session, remove=1)
            session[self.name] = instance
        else:
            instance = session.get(self.name, {})
            if instance.has_key('authentication'):
                user = instance['authentication']
            else:
                ip = request.get('HTTP_X_FORWARDED_FOR', '').split(', ')[-1]
                if not ip:
                    ip = request.get('REMOTE_ADDR', '0.0.0.0').split(', ')[-1]
                access = self._v_system.edbmaccess(ip)
                if access:
                    user = [''] + access[1:]
        return user


    def history(self, request, session, query='', count=0, remove=None):
        instance = session.get(self.name, {})
        if instance.has_key('history'):
            if remove:
                instance['history'] = []
                session[self.name] = instance
            if query:
                dict = {
                    'query' : query,
                    'count' : count,
                }
                if dict in instance['history']:
                    instance['history'].remove(dict)
                instance['history'].append(dict)
                session[self.name] = instance
        else:
            instance['history'] = []
            session[self.name] = instance
        return instance['history']


    def openurl(self, item, version, url, icon):
        return self._v_system.openurl(item, version, url, icon)


    def mirror(self, attr='id'):
        if not hasattr(self, '_v_system'):
            self.init()
        return self._v_system.mirror(self.location, attr)


    def facts(self):
        return self._v_system.facts(self.location)


    def mathml(self, an):
        return self._v_system.mathml(an)


    def debug(self, request):
        ip = request.get('HTTP_X_FORWARDED_FOR', '').split(', ')[-1]
        if not ip:
            ip = request.get('REMOTE_ADDR', '0.0.0.0').split(', ')[-1]
        ac = self._v_system.edbmaccess(ip)
        return '%s | %s | %s | %s' % (request.get('REMOTE_ADDR', '0.0.0.0').split(', ')[-1], request.get('HTTP_X_FORWARDED_FOR', '0.0.0.0').split(', ')[-1], ip, ac)


manage_addZZMath = Globals.DTMLFile('manage/add', globals())

def manage_add(self, id, title, REQUEST=None):
    """Add a new ZZMath instance"""
    handle          = ZZMath(REQUEST.name, REQUEST.database, REQUEST.location)
    handle.id       = id
    handle.title    = title
    handle.name     = REQUEST.name
    handle.database = REQUEST.database
    handle.location = REQUEST.location

    self = self.this()
    self._setObject(id, handle)

    if REQUEST is not None:
        REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
    return