from zsite import ZSite
from reviewer import Reviewer
import Globals, OFS
import os, string, re, types


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

    _properties = ZSite._properties

    manage_options = (
        ZSite.manage_options[0],
        ZSite.manage_options[1],
        {
            'label'  : 'Reviewer',
            'icon'   : '',
            'action' : 'manage_reviewer',
            '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_reviewer      = Globals.DTMLFile('manage/reviewer', globals())

    manage_reviewer_dtml = Globals.DTMLFile('manage/code/reviewer', globals())


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


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


    def mirror(self, attr='id'):
        return self._v_system.mirror(self.location, attr)


    def authentication(self, request, reviewer=None, document=None):
        if not request:
            return ''
        session = request.SESSION
        if not session:
            return ''
        instance = session.get(self.name, {})
        if reviewer and document:
            reviewer = reviewer.strip()
            document = document.strip()
            state = self.matrix_authenticate_reviewer(reviewer, document)
            if state:
                try:
                    instance['reviewer'] = int(reviewer)
                    if document.upper().startswith('DE'):
                        instance['document'] = int(document[2:-1])
                    else:
                        instance['document'] = int(document)
                except:
                    if instance.has_key('reviewer'):
                        del instance['reviewer']
                        del instance['document']
            else:
                if instance.has_key('reviewer'):
                    del instance['reviewer']
                    del instance['document']
            session[self.name] = instance
            if instance.has_key('reviewer'):
                request.set('reviewer_id_', instance['reviewer'])
                request.set('document_id_', instance['document'])
            return state
        else:
            instance = session.get(self.name, {})
            if instance.has_key('reviewer'):
                request.set('reviewer_id_', instance['reviewer'])
                request.set('document_id_', instance['document'])
            return '???'
        return ''


    def logoff(self, request):
        if not request:
            return 0
        session = request.SESSION
        if not session:
            return 0
        instance = session.get(self.name, {})
        if instance.has_key('reviewer'):
            del instance['reviewer']
            del instance['document']
            session[self.name] = instance
        request.set('reviewer_id_', None)
        request.set('document_id_', None)
        return 1


    def matrix_authenticate_reviewer(self, reviewer='', document=''):
        return self._v_system.matrix_authenticate_reviewer(reviewer, document)


    def matrix_get_reviewer(self, id=0):
        if not id:
            return None
        reviewer = self._v_system.matrix_get_reviewer(id)
        if reviewer:
            return self.Record('reviewer', reviewer)
        return None


    def matrix_get_document(self, id=0):
        if type(id) in (types.StringType, types.InstanceType,):
            id = id.strip().upper()
            if id.startswith('DE'):
                id = id[2:-1]
            if re.search('\D', id):
                id = '0'
            id = int(id)
        if not id:
            return None
        document = self._v_system.matrix_get_document(id)
        if document:
            return self.Record('document', document)
        return None


    def matrix_get_mathilde(self, reviewer=0, document=0):
        return self._v_system.matrix_get_mathilde(reviewer, document)


    def matrix_set_mathilde(self, reviewer=0, document=0, state=''):
        return self._v_system.matrix_set_mathilde(reviewer, document, state)


    def matrix_list_mathilde(self, reviewer=0, state=None):
        if not reviewer:
            return None
        list = self._v_system.matrix_list_mathilde(reviewer, state)
        if list:
            return map(self.Record, ['document']*len(list), list)
        return None


    def preview(self, data, type='pdf', response=None):
        id = 0
        if data.get('documentid', ''):
            id = data.get('documentid', '').strip().upper()
            if id.startswith('DE'):
                id = id[2:-1]
            if not re.match('^\d+$', id):
                id = '0'
            id = int(id)
        name = self._v_system.preview(id, data, type)
        content = open('/tmp/%s.%s' % (name, type)).read()
        if response:
            if type == 'pdf':
                response.setHeader('Content-Type', 'application/pdf')
            elif type == 'txt':
                response.setHeader('Content-Type', 'text/plain')
            else:
                response.setHeader('Content-Type', 'application/octet-stream')
            response.setHeader('Cache-Control', 'no-cache')
            response.setHeader('Pragma', 'no-cache')
            response.setHeader('Expires', '0')
            response.setHeader('Content-Length', len(content))
            response.setHeader('Accept-Ranges', 'bytes')
            response.setHeader('Content-Disposition', 'attachment; filename=%s.%s' % (name, type))
            response.write(content)
            response.setStatus('OK')
        return


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

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