from basic import Basic
from data import Data
import crypt, os, re, string, time, types, base64, xmlrpclib, httplib


class System(Data):

    def init(self):
        Data.init(self)
        try:
            self.addentry('', 'table', '')
            self.addentry('', 'table::id', '0')
            self.addentry('', 'table::name', '')
            self.addentry('', 'table::field', '')
            self.addentry('', 'table::field::id', '0')
            self.addentry('', 'table::field::name', '')
            self.addentry('', 'table::field::type', '')
            self.addentry('', 'table::field::default', '')
            self.addentry('', 'table::field::index', '')
            self.addentry('', 'user', '')
            self.addentry('', 'user::id', '0')
            self.addentry('', 'user::name', '')
            self.addentry('', 'user::password', '')
            self.addentry('', 'user::roles', '')
            self.addentry('', 'user::preferences', '')
            self.addentry('', 'function', '')
            self.addentry('', 'function::id', '0')
            self.addentry('', 'function::name', '')
            self.addentry('', 'function::roles', '')
            self.addentry('', 'function::title', '')
            self.addentry('', 'function::attributes', '')
            self.addentry('', 'language', '')
            self.addentry('', 'language::id', '0')
            self.addentry('', 'language::name', '')
            self.addentry('', 'language::title', '')
        except Exception:
            pass
        return


    def addtable(self, name):
        self.addentry(name, 'table', name)
        id = max([0] + map(int, self.listvalues('.*', 'table::id'))) + 1
        self.addentry(name, 'table::id', id)
        self.addentry(name, 'table::name', name)
        return


    def deltable(self, name):
        self.delentry(name, 'table')
        self.delentries('^%s$' % name, '^table::')
        return


    def gettable(self, name):
        return {
            ''     : self.getvalue(name, 'table'),
            'id'   : self.getvalue(name, 'table::id'),
            'name' : self.getvalue(name, 'table::name'),
        }


    def settable(self, name, dict):
        for id in dict.keys():
            if id:
                self.setvalue(name, 'table::%s' % id, dict[id])
            else:
                self.setvalue(name, 'table', dict[id])
        return


    def listtables(self):
        list = []
        for name in self.listnames('^table$', '^.+'):
            list.append(self.gettable(name))
        return list


    def addfield(self, table, name, type='TEXT', default='', index=''):
        field = '%s.%s' % (table, name)
        self.addentry(field, 'table::field', name)
        id = max([0] + map(int, self.listvalues('^%s\\\..*' % (table), 'table::field::id'))) + 1
        self.addentry(field, 'table::field::id', id)
        self.addentry(field, 'table::field::name', name)
        self.addentry(field, 'table::field::type', type)
        self.addentry(field, 'table::field::default', default)
        self.addentry(field, 'table::field::index', index)
        return


    def delfield(self, table, name):
        field = '%s.%s' % (table, name)
        self.delentry(field, 'table::field')
        self.delentries('^%s$' % field, '^table::field::')
        return


    def getfield(self, table, name):
        field = '%s.%s' % (table, name)
        return {
            ''        : self.getvalue(field, 'table::field'),
            'id'      : self.getvalue(field, 'table::field::id'),
            'name'    : self.getvalue(field, 'table::field::name'),
            'type'    : self.getvalue(field, 'table::field::type'),
            'default' : self.getvalue(field, 'table::field::default'),
            'index'   : self.getvalue(field, 'table::field::index'),
        }


    def setfield(self, table, name, dict):
        field = '%s.%s' % (table, name)
        for id in dict.keys():
            if id:
                self.setvalue(field, 'table::field::%s' % id, dict[id])
            else:
                self.setvalue(field, 'table::field', dict[id])
        return


    def listfields(self, table):
        list = []
        for field in self.listnames('^table::field$', '^%s\\\.' % (table)):
            list.append(self.getfield(table, field.split('.')[1]))
        return list


    def adduser(self, name):
        self.addentry(name, 'user', name)
        id = max([0] + map(int, self.listvalues('.*', 'user::id'))) + 1
        self.addentry(name, 'user::id', id)
        self.addentry(name, 'user::name', name)
        self.addentry(name, 'user::password', crypt.crypt('', 'xx'))
        self.addentry(name, 'user::roles', '')
        self.addentry(name, 'user::preferences', '')
        return


    def deluser(self, name):
        self.delentry(name, 'user')
        self.delentries('^%s$' % name, '^user::')
        return


    def getuser(self, name):
        return {
            ''            : self.getvalue(name, 'user'),
            'id'          : self.getvalue(name, 'user::id'),
            'name'        : self.getvalue(name, 'user::name'),
            'password'    : self.getvalue(name, 'user::password'),
            'roles'       : self.getvalue(name, 'user::roles'),
            'preferences' : self.getvalue(name, 'user::preferences'),
        }


    def setuser(self, name, dict):
        for id in dict.keys():
            if id:
                self.setvalue(name, 'user::%s' % id, dict[id])
            else:
                self.setvalue(name, 'user', dict[id])
        return


    def listusers(self):
        list = []
        for name in self.listnames('^user$', '^.+'):
            list.append(self.getuser(name))
        return list


    def passwd(self, name, password):
        self.setvalue(name, 'user::password', crypt.crypt(password, 'xx'))
        return


    def authenticate(self, name, password):
        return crypt.crypt(password, 'xx') == self.getvalue(name, 'user::password')


    def addfunction(self, name):
        self.addentry(name, 'function', name)
        id = max([0] + map(int, self.listvalues('.*', 'function::id'))) + 1
        self.addentry(name, 'function::id', id)
        self.addentry(name, 'function::name', name)
        self.addentry(name, 'function::title', '')
        self.addentry(name, 'function::roles', '')
        self.addentry(name, 'function::attributes', '')
        return


    def delfunction(self, name):
        self.delentry(name, 'function')
        self.delentries('^%s$' % name, '^function::')
        return


    def getfunction(self, name):
        return {
            ''           : self.getvalue(name, 'function'),
            'id'         : self.getvalue(name, 'function::id'),
            'name'       : self.getvalue(name, 'function::name'),
            'title'      : self.getvalue(name, 'function::title'),
            'roles'      : self.getvalue(name, 'function::roles'),
            'attributes' : self.getvalue(name, 'function::attributes'),
        }


    def setfunction(self, name, dict):
        for id in dict.keys():
            if id:
                self.setvalue(name, 'function::%s' % id, dict[id])
            else:
                self.setvalue(name, 'function', dict[id])
        return


    def listfunctions(self):
        list = []
        for name in self.listnames('^function$', '^.+'):
            list.append(self.getfunction(name))
        return list


    def addlanguage(self, name):
        self.addentry(name, 'language', name)
        id = max([0] + map(int, self.listvalues('.*', 'language::id'))) + 1
        self.addentry(name, 'language::id', id)
        self.addentry(name, 'language::name', name)
        self.addentry(name, 'language::title', '')
        return


    def dellanguage(self, name):
        self.delentry(name, 'language')
        self.delentries('^%s$' % name, '^language::')
        return


    def getlanguage(self, name):
        return {
            ''      : self.getvalue(name, 'language'),
            'id'    : self.getvalue(name, 'language::id'),
            'name'  : self.getvalue(name, 'language::name'),
            'title' : self.getvalue(name, 'language::title'),
        }


    def setlanguage(self, name, dict):
        for id in dict.keys():
            if id:
                self.setvalue(name, 'language::%s' % id, dict[id])
            else:
                self.setvalue(name, 'language', dict[id])
        return


    def listlanguages(self):
        list = []
        for name in self.listnames('^language$', '^.+'):
            list.append(self.getlanguage(name))
        return list


    def build(self, table=None):
        if table:
            list = [self.gettable(table)]
        else:
            list = self.listtables()
        for table in list:
            Data.addtable(self, table['name'])
            for field in self.sort(self.listfields(table['name']), 'id'):
                Data.addfield(self, table['name'], field['name'], field['type'], field['default'], field['index'])
        return


    def destroy(self, table=None):
        if table:
            list = [self.gettable(table)]
        else:
            list = self.listtables()
        for table in list:
            Data.deltable(self, table['name'])
        return


    def dump(self, file, table):
        folder = os.path.dirname(file)
        if not os.path.isdir(folder):
            os.mkdir(folder)
            os.chmod(folder, 0777)
        cursor = self.connection.cursor()
        cursor.execute('''COPY %s_%s TO '%s'
                       ''' % (self.name, table, file))
        cursor.close()
        return


    def load(self, file, table):
        for field in self.listfields(table):
            Data.dropindex(self, table, field['name'], field['index'])
        self.commit()
        if os.path.isfile(file):
            cursor = self.connection.cursor()
            cursor.execute('''COPY %s_%s FROM '%s'
                           ''' % (self.name, table, file))
            cursor.close()
        for field in self.listfields(table):
            Data.createindex(self, table, field['name'], field['index'])
        self.commit()
        return


    def dropindeces(self, table):
        for field in self.listfields(table):
            Data.dropindex(self, table, field['name'], field['index'])
        return


    def createindeces(self, table):
        for field in self.listfields(table):
            Data.createindex(self, table, field['name'], field['index'])
        return


    def reindex(self, table):
        for field in self.listfields(table):
            Data.dropindex(self, table, field['name'], field['index'])
            Data.createindex(self, table, field['name'], field['index'])
        return
        

    def backup(self, folder):
        if not os.path.isdir(folder):
            os.mkdir(folder)
            os.chmod(folder, 0777)
        Basic.dump(self, '%s/%s' % (folder, self.name))
        for table in self.listtables():
            self.dump('%s/%s_%s' % (folder, self.name, table['name']), table['name'])
        return


    def restore(self, folder):
        self.destroy()
        Basic.kill(self)
        Basic.init(self)
        self.commit()
        Basic.load(self, '%s/%s' % (folder, self.name))
        self.build()
        for table in self.listtables():
            self.load('%s/%s_%s' % (folder, self.name, table['name']), table['name'])
        self.commit()
        return


    def navigate(self, table, id=0, action='next'):
        cursor = self.connection.cursor()
        if action == 'next':
            cursor.execute('''SELECT id FROM %s_%s
                              WHERE id > %d
                              ORDER BY id
                              LIMIT 1
                           ''' % (self.name, table, id))
        elif action == 'previous':
            cursor.execute('''SELECT id FROM %s_%s
                              WHERE id > 0 AND id < %d
                              ORDER BY id DESC
                              LIMIT 1
                           ''' % (self.name, table, id))
        elif action == 'first':
            cursor.execute('''SELECT id FROM %s_%s
                              WHERE id > 0
                              ORDER BY id
                              LIMIT 1
                           ''' % (self.name, table))
        elif action == 'last':
            cursor.execute('''SELECT id FROM %s_%s
                              ORDER BY id DESC
                              LIMIT 1
                           ''' % (self.name, table))
        else:
            cursor.close()
            return id
        list = cursor.dictfetchall()
        if list:
            id = list[0]['id']
        cursor.close()
        return id


    def minid(self, table):
        cursor = self.connection.cursor()
        cursor.execute('''SELECT id FROM %s_%s
                          ORDER BY id
                          LIMIT 1
                       ''' % (self.name, table))
        dict = cursor.dictfetchone()
        cursor.close()
        if dict:
            return dict['id']
        return 0


    def maxid(self, table):
        cursor = self.connection.cursor()
        cursor.execute('''SELECT id FROM %s_%s
                          ORDER BY id DESC
                          LIMIT 1
                       ''' % (self.name, table))
        dict = cursor.dictfetchone()
        cursor.close()
        if dict:
            return dict['id']
        return 0


    def listids(self, table, where='', order='id', constraint=''):
        table = string.split(table, ',')
        id = '%s.id' % (table[0])
        for i in range(len(table)):
            table[i] = '%s_%s AS %s' % (self.name, table[i], table[i])
        table = string.join(table, ',')
        if type(where) in (types.ListType,):
            if not where:
                return []
            where = '%s in (%s)' % (id, string.join(map(str, where), ','))
        if where:
            where = "WHERE %s" % (where)
        if order:
            order = "ORDER BY %s" % (order)
        cursor = self.connection.cursor()
        cursor.execute('''SELECT %s FROM %s
                          %s
                          %s
                          %s
                       ''' % (id, table, where, order, constraint))
        list = map(self.head, cursor.fetchall())
        cursor.close()
        return list


    def select(self, field, table, where='', order='id', constraint=''):
        table = string.split(table, ',')
        for i in range(len(table)):
            table[i] = '%s_%s AS %s' % (self.name, table[i], table[i])
        table = string.join(table, ',')
        if where:
            where = "WHERE %s" % (where)
        if order:
            order = "ORDER BY %s" % (order)
        cursor = self.connection.cursor()
        cursor.execute('''SELECT %s FROM %s
                          %s
                          %s
                          %s
                       ''' % (field, table, where, order, constraint))
        list = cursor.dictfetchall()
        cursor.close()
        return list


    def sql(self, query):
        cursor = self.connection.cursor()
        cursor.execute(query)
        list = None
        if query.strip().lower().startswith('select'):
            list = cursor.dictfetchall()
        cursor.close()
        return list


    def identifier(self, text):
        return re.sub('\W', '', text)


    def readfile(self, path, name):
        try:
            file = open('%s/%s' % (path, name), 'rb')
            content = file.read()
            file.close()
        except Exception:
            content = None
        return content


    def cleanlog(self, data):
        data = str(data)
        data = string.replace(data, '\r', '')
        data = string.replace(data, '\n', '\\n')
        return data


    def writelog(self, name, data):
        path = os.path.split(name)[0]
        if not os.path.exists(path):
            os.makedirs(path)
        file = open(name, 'a+')
        file.write('%s' % (time.strftime('%Y-%m-%d %H:%M:%S')))
        if type(data) in (types.DictionaryType,):
            list = data.keys()
            list.sort()
            for i in list:
                file.write('\t%s' % self.cleanlog(data[i]))
        elif type(data) in (types.ListType,):
            file.write('\t')
            data = map(self.cleanlog, data)
            file.write(string.join(data, '\t'))
        else:
            file.write('\t%s' % self.cleanlog(data))
        file.write('\n')
        file.close()


    def readlog(self, name):
        list = []
        file = open(name, 'r+')
        for line in file.readlines():
            list.append(string.split(line[:-1], '\t'))
        file.close()
        return list


    class Authentication(xmlrpclib.Transport):
        def __init__(self, username=None, password=None):
            self.username = username
            self.password = password
            self.verbose  = 0

        def request(self, host, handler, request_body, verbose=0):
            h = httplib.HTTP(host)
            h.putrequest('POST', handler)
            h.putheader('Host', host)
            h.putheader('User-Agent', self.user_agent)
            h.putheader('Content-Type', 'text/xml')
            h.putheader('Content-Length', str(len(request_body)))

            if self.username is not None and self.password is not None:
                h.putheader('AUTHORIZATION', 'Basic %s' % string.replace(base64.encodestring('%s:%s' % (self.username, self.password)), '\012', ''))
            h.endheaders()

            if request_body:
                h.send(request_body)

            errcode, errmsg, headers = h.getreply()

            if errcode != 200:
                raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers)

            return self.parse_response(h.getfile()) 


    def checkISSN(self, issn):
        issn = issn.strip()
        if not issn:
            return 1
        elif re.match('^\d\d\d\d-\d\d\d[\dX]$', issn):
            pass
        elif re.match('^\d\d\d\d-\d\d\d[\dX]\/.+$', issn):
            pass
        else:
            return 0
        issn = re.sub('\/.*$', '', issn)
        issn = issn.replace('-', '')
        digit = issn[-1]
        check = 0
        for n in range(7):
            check = check + ((8-n) * int(issn[n]))
        check = str(11 - (check % 11))
        if check == '10':
            check = 'X'
        elif check == '11':
            check = '0'
        if check != digit:
            return 0
        return 1


    def checkISBN(self, isbn):
        isbn = isbn.strip()
        if not isbn:
            return 1
        elif re.match('^\d[-\d]{11}[\dX]$', isbn):
            pass
        elif re.match('^\d[-\d]{11}[\dX]\/.+$', isbn):
            pass
        elif re.match('^\d[-\d]{15}[\dX]$', isbn):
            pass
        elif re.match('^\d[-\d]{15}[\dX]\/.+$', isbn):
            pass
        else:
            return 0
        isbn = re.sub('\/.*$', '', isbn)
        isbn = isbn.replace('-', '')
        digit = isbn[-1]
        check = 0
        if len(isbn) == 10:
            for n in range(9):
                check = check + ((n+1) * int(isbn[n]))
            check = str(check % 11)
            if check == '10':
                check = 'X'
        elif len(isbn) == 13:
            for n in range(12):
                check = check + int(isbn[n])
                if n%2:
                    check = check + (2 * int(isbn[n]))
            check = str(10 - (check % 10))
            if check == '10':
                check = '0'
        else:
            return 0
        if check != digit:
            return 0
        return 1


    def isbn2isbn(self, isbn):
        isbn = isbn.strip()
        test = isbn
        if not test:
            return ''
        if not self.checkISBN(test):
            return ''
        test = re.sub('\/.*$', '', test)
        test = test.replace('-', '')
        digit = test[-1]
        check = 0
        if len(test) == 10:
            test = '978%s' % (test)
            for n in range(12):
                check = check + int(test[n])
                if n%2:
                    check = check + (2 * int(test[n]))
            check = str(10 - (check % 10))
            if check == '10':
                check = '0'
            isbn = '978-%s%s%s' % (isbn[:12], check, isbn[13:])
        elif len(test) == 13:
            test = test[3:]
            for n in range(9):
                check = check + ((n+1) * int(test[n]))
            check = str(check % 11)
            if check == '10':
                check = 'X'
            isbn = isbn[4:]
            isbn = '%s%s%s' % (isbn[:12], check, isbn[13:])
        return isbn


    class Date:
        _months = {
            'januar'    : 1,
            'februar'   : 2,
            'm?rz'      : 3,
            'maerz'     : 3,
            'april'     : 4,
            'mai'       : 5,
            'juni'      : 6,
            'juli'      : 7,
            'august'    : 8,
            'september' : 9,
            'oktober'   : 10,
            'november'  : 11,
            'dezember'  : 12,
            'january'   : 1,
            'february'  : 2,
            'march'     : 3,
            'april'     : 4,
            'may'       : 5,
            'june'      : 6,
            'july'      : 7,
            'august'    : 8,
            'september' : 9,
            'october'   : 10,
            'november'  : 11,
            'december'  : 12,
            'jan'       : 1,
            'feb'       : 2,
            'mar'       : 3,
            'apr'       : 4,
            'may'       : 5,
            'jun'       : 6,
            'jul'       : 7,
            'aug'       : 8,
            'sep'       : 9,
            'oct'       : 10,
            'nov'       : 11,
            'dec'       : 12,
        }

        def __init__(self, text=''):
            self.text   = self._prepare(text)
            self.date   = self.analyze()
            return

        def _prepare(self, text):
            text = re.sub(r'\s*([\.\,\;\-])\s*', '\\1', text)
            text = re.sub(r'\s+', ' ', text)
            text = text.strip()
            text = text.lower()
            return text

        def _token(self):
            token = ''
            while self.pos < self.len:
                if self.text[self.pos] in ' .,;-':
                    break
                else:
                    token += self.text[self.pos]
                    self.pos += 1
            if not token and self.pos < self.len:
                token = self.text[self.pos]
                self.pos += 1
            if 0: sys.stderr.write('%s ' % (token))
            return token

        def _day(self, token):
            day = -1
            if re.match(r'^\d+$', token):
                day = int(token)
            return day

        def _month(self, token):
            month = -1
            if re.match(r'^\d+$', token):
                month = int(token)
            else:
                token = re.sub('\W+', '?', token)
                if self._months.get(token, 0):
                    month = self._months.get(token, 0)
            return month

        def _year(self, token):
            year = -1
            if re.match(r'^\d+$', token):
                year = int(token)
                if year < 2000:
                    year += 2000
            return year

        def analyze(self):
            self.len  = len(self.text)
            self.pos  = 0
            self.date = [{'d':-1,'m':-1,'y':-1,'s':'',}]
            infinity  = 0
            token = self._token()
            part  = 'day'
            while token:
                if token[0] in ',;-':
                    self.date[-1]['s'] = token[0]
                    self.date.append({'d':-1,'m':-1,'y':-1,'s':'',})
                    token = self._token()
                    part  = 'day'
                elif token in ['bis'] and self.date[0]['d'] != -1:
                    self.date[-1]['s'] = '-'
                    self.date.append({'d':-1,'m':-1,'y':-1,'s':'',})
                    token = self._token()
                    part  = 'day'
                elif token in ['ab','seit']:
                    infinity = 1
                if part == 'day':
                    day = self._day(token)
                    if day != -1:
                        self.date[-1]['d'] = day
                        part  = 'month'
                elif part == 'month':
                    month = self._month(token)
                    if month != -1:
                        self.date[-1]['m'] = month
                        part  = 'year'
                elif part == 'year':
                    year = self._year(token)
                    if year != -1:
                        self.date[-1]['y'] = year
                        part  = 'separator'
                token = self._token()
            if self.date and self.date[-1]['y'] == -1:
                self.date[-1]['y'] = int(time.strftime('%Y'))
            for i in range(len(self.date)-1, 0, -1):
                if self.date[i]['d'] != -1 and self.date[i-1]['d'] == -1:
                    self.date[i-1]['d'] = self.date[i]['d']
                if self.date[i]['m'] != -1 and self.date[i-1]['m'] == -1:
                    self.date[i-1]['m'] = self.date[i]['m']
                if self.date[i]['y'] != -1 and self.date[i-1]['y'] == -1:
                    self.date[i-1]['y'] = self.date[i]['y']
            if infinity:
                if self.date:
                    self.date[-1]['s'] = '-'
                self.date.append({'d':99,'m':99,'y':9999,'s':'',})
            return self.date

        def sort(self, reverse=0):
            text = ''
            if reverse:
                for i in range(len(self.date)-1, -1, -1):
                    text += '%(s)s%(y)04d%(m)02d%(d)02d' % (self.date[i])
            else:
                for i in range(len(self.date)):
                    text += '%(y)04d%(m)02d%(d)02d%(s)s' % (self.date[i])
            return text


    def date2sort(self, text, reverse=0):
        date = self.Date(text)
        return date.sort(reverse)


    def tmpstore(self, root, dirname, filename, text):
        if not os.path.exists('%s/tmp' % (root)):
            os.mkdir("%s/tmp" % (root))
        if not os.path.exists('%s/tmp/%s' % (root, dirname)):
            os.mkdir('%s/tmp/%s' % (root, dirname))
        file = open('%s/tmp/%s/%s' % (root, dirname, filename), 'w')
        file.write(text)
        file.close()
        return


    def tmpload(self, root, dirname, filename):
        if not os.path.exists('%s/tmp/%s/%s' % (root, dirname, filename)):
            return ''
        file = open('%s/tmp/%s/%s' % (root, dirname, filename), 'r')
        text = file.read()
        file.close()
        return text


    def tmpclean(self, root, dirname):
        if not os.path.exists('%s/tmp/%s' % (root, dirname)):
            return
        for root, dirs, files in os.walk('%s/tmp/%s' % (root, dirname)):
            for name in files:
                os.remove(os.path.join(root, name))
            os.rmdir(root)
        return


    def dir(self, object):
        return dir(object)