from zsite import ZSite
from authors import Authors
from tools import convert
import Globals, OFS
import os, string, re, sys


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

    _properties = ZSite._properties

    manage_options = (
        ZSite.manage_options[0],
        ZSite.manage_options[1],
        {
            'label'  : 'Authors',
            'icon'   : '',
            'action' : 'manage_authors',
            '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_authors      = Globals.DTMLFile('manage/authors', globals())

    manage_authors_dtml = Globals.DTMLFile('manage/code/authors', globals())


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


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


    def edbminit(self, path, force=0):
        return self._v_system.edbminit(path, force)


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


    def edbmquery(self, request, db):
        if request.form:
            return self._v_system.edbmquery(request.form, db)
        return None


    def edbmfind(self, db, query, virtual='all'):
        if not query:
            return self.EdbmResult(error='no query')
        resultset = self._v_system.edbmfind(db, query, 1, sys.maxint)
        if resultset == None:
            return self.EdbmResult(error='invalid query')
        resultdict = {}
        count = 0
        for result in resultset:
            count += 1
            item = self.EdbmItem(count)
	    if virtual == 'all':
	        attributes = db._factory.schema['attrinfo'].keys()
	    else:
	        attributes = list(db._factory.schema['fields']) + virtual.split()
            for name in attributes:
                setattr(item, name, getattr(result, name))
	    setattr(item, 'attributes', attributes)
            index = getattr(result, 'ai')
            resultdict[index] = resultdict.get(index, [])
            resultdict[index].append(item)
        count = 0
        resultlist = []
        for index in resultdict.keys():
            count += 1
            total = int(getattr(resultdict[index][-1], 'ct'))
            code = ''
            name = ''
            if total:
                code = getattr(resultdict[index][-1], 'ai')
                name = getattr(resultdict[index][-1], 'nm')
                spellings = getattr(resultdict[index][-1], 'sp')
                spellings = re.sub('\s*\[\d+\]', '', spellings)
            item = self.EdbmItem(count)
            setattr(item, 'total', total)
            setattr(item, 'code', code)
            setattr(item, 'name', name)
            setattr(item, 'spellings', spellings)
            resultlist.append(item)
        return self.EdbmResult(len(resultlist), resultlist)


    def edbmeval(self, query, db=None, virtual='all'):
        if query == None:
            return None
        if db == None:
            db = self.edbmopen('authors')
        result = self.edbmfind(db, query, virtual)
        if result:
            result.query = query
            result.first = 1
            result.last  = result.total
        return result


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


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


    class EdbmResult(OFS.SimpleItem.SimpleItem):
        def __init__(self, total=0, list=[], error=None):
            self.total = total
            self.list  = list
            self.error = error
        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')


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

def manage_add(self, id, title, REQUEST=None):
    """Add a new ZAuthors instance"""
    handle          = ZAuthors(REQUEST.name, REQUEST.database)
    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