#
# -*- coding: utf-8 -*-
'''
$RCSfile: configuration.py,v $
$Revision: 902 $
$Author: markus $
$Date: 2008-04-29 23:04:41 +0200 (Di, 29. Apr 2008) $
'''


############################################################################################################
#
#   IMPORTS
#
#===========================================================================================================
import inspect as           _i
import os.path as           _p
import sys, os
from types import DictType, ListType
import ConfigParser

INT_PROPS =['recLimit','expire','error_maxbytes','error_backupcount','debug_maxbytes','debug_backupcount','request_maxbytes','request_backupcount']
BOOL_PROPS=['debug','pickle','prettyprint']

def isTrue(arg):
    '''Boolean expression evaluation extended by '0' and 'false' (case insensitive) evaluating to False 
    instead of True done by bool function which is used for all other evaluations.'''
    try:
        arg =str(arg)
        arg = arg.strip()
        arg = arg.lower()
        if arg in ('0', 'false'):
            return False
        else:
            return bool(arg)
    except:
        return bool(arg)


############################################################################################################
#
#   Singleton metaclass. Exists in biocase.tools also but avoided here so no biocase namespace is required
#
#===========================================================================================================
class Singleton(type):
    def __init__(cls,name,bases,dic):
        super(Singleton,cls).__init__(name,bases,dic)
        cls.__instance=None
    def __call__(cls,*args,**kw):
        if cls.__instance is None:
            cls.__instance=super(Singleton,cls).__call__(*args,**kw)
        return cls.__instance
        
        
############################################################################################################
#
#   CONFIGURATION SECTION CLASS
#
#===========================================================================================================
class ConfigurationSection( object ):
    #-------------------------------------------------------------------------------------------------------
    def __init__(self):
        self.__name__     = None
        self.__filename__ = None

    #-------------------------------------------------------------------------------------------------------ä
    def __setOption__(self, optionName, value):
        if optionName in INT_PROPS:
            try:
                value=int(value)
            except:
                # Configuration option is no integer! Default to 0
                value=0
        elif optionName in BOOL_PROPS:
            value=isTrue(value)
        setattr(self, optionName, value )

    #-------------------------------------------------------------------------------------------------------
    def __save__( self ):
        if self.__filename__ is None:
            return False
        options = {}
        # get entries (flatten lists)
        for name in dir( self ):
            if name.startswith( '__' ): continue
            attr = getattr( self, name )
            if type(attr) == ListType:
                for i,e in enumerate(attr):
                    options["%s_%i"%(name,i+1)] = e
            elif name in INT_PROPS:
                options[name]=unicode(attr)
            elif name in BOOL_PROPS:
                options[name]=unicode(attr)
            else:
                options[name]=unicode(attr)
        # write options
        fp = file(self.__filename__)
        pre  = ""
        post = ""
        tmp = ""
        inSect = False
        # read existing ini and ignore this sections
        for line in fp.readlines():
            if not inSect:
                tmp = tmp + line
                if line.strip() == "[%s]"%self.__name__:
                    # found this objects section.
                    inSect = True
                    pre = tmp
                    tmp = ""                    
            else:
                if line.strip().startswith("["):
                    # other section starting
                    inSect = False
                    tmp = "\n" + line
                else:
                    # options. ignore them
                    pass
        post = tmp
        fp.close()            
        
        fpw = file(self.__filename__, 'w')
        fpw.write(pre)
        # create new string for options
        names = sorted(options.keys())
        for name in names:
            fpw.write("%s  =  %s\n" % (name.encode('utf-8'), options[name].encode('utf-8')))
        fpw.write(post)
        fpw.close()

        
############################################################################################################
#
#   GLOBAL CONFIGURATION BASE CLASS. might be replaced by another class when using getCfg()
#
#===========================================================================================================
class Cfg( object ):
    __metaclass__ = Singleton

    def __init__(self):
        self.ns2prefix={}
        # set home locators. Needed to find default configuration files
        self._setHomeLocator()
        # always read the lib configs
        self._readConfigFiles()

    #-------------------------------------------------------------------------------------------------------
    def _setHomeLocator(self, bpsPath=None):
        #print "Set CFG bpsPath = %s"%bpsPath
        if bpsPath is None or not os.path.isdir(bpsPath):
            from adjustpath import bpsPath as homeLocator
            #print "adjustpath bpsPath = %s"%homeLocator
            if homeLocator is None or not os.path.isdir(homeLocator):
                homeLocator = _p.join( _p.dirname( _i.getfile( lambda:None )), os.pardir, os.pardir)
        else: 
            homeLocator = bpsPath
        Cfg.homeLocator             = _p.normpath(homeLocator)
        #print "Cfg.homeLocator = %s\n"%Cfg.homeLocator
        Cfg.libLocator              = _p.join( Cfg.homeLocator,             'lib'                  )
        Cfg.logLocator              = _p.join( Cfg.homeLocator,             'log'                  )
        Cfg.cacheLocator            = _p.join( Cfg.homeLocator,             'cache'                )

        Cfg.wwwLocator              = _p.join( Cfg.homeLocator,             'www'                  )
        Cfg.resourceLocator         = _p.join( Cfg.wwwLocator,              'resources'            )
        Cfg.schemasLocator          = _p.join( Cfg.resourceLocator,         'schemas'              )

        Cfg.configurationLocator    = _p.join( Cfg.homeLocator,             'config'               )
        Cfg.dsaLocator              = _p.join( Cfg.configurationLocator,    'datasources'          )
        Cfg.skinLocator             = _p.join( Cfg.configurationLocator,    'querytool','skins'    )

        Cfg.templateLocator         = _p.join( Cfg.homeLocator,             'templates'            )
        Cfg.rawCmfTemplateLocator   = _p.join( Cfg.templateLocator,         'cmf'                  )
        Cfg.dsaTemplateLocator      = _p.join( Cfg.templateLocator,         'datasources'          )
    
        
    #-------------------------------------------------------------------------------------------------------ä
    def _setOption(self, sectionName, optionName, value):
        if sectionName in dir(self):
            sect = getattr(self, sectionName)
            if isinstance(sect, ConfigurationSection):
                sect.__setOption__(optionName, value)

    #-------------------------------------------------------------------------------------------------------
    def _listOptions(self, sectionName):
        if sectionName in dir( self ):
            sect = getattr( self, sectionName )
            if isinstance(sect, ConfigurationSection):
                return self._getRecursiveDict(sect).keys()
        return []

    #-------------------------------------------------------------------------------------------------------
    def _dictAsTable( self, d, indent=0 ):
        R = [ ]
        names = d.keys()
        names.sort()
        for name in names:
            value = d[ name ]
            if type(value) == DictType:
                value = '\n' + self._dictAsTable(d=value, indent=indent+1)
            indentString = '  '*indent
            R.append( '%s%s:\t%s' % ( indentString, name, value, ) )
        R = '\n'.join( R )
        return R

    #-------------------------------------------------------------------------------------------------------
    def _getSections(self):
        sections = []
        for name in dir( self ):
            attr = getattr( self, name )
            if isinstance(attr, ConfigurationSection):
                sections.append( attr )
        return sections
        
    #-------------------------------------------------------------------------------------------------------
    def _getDict( self, d=None, base='' ):
        '''Return a simple dictionary with keys using . for the sections'''
        R = {}
        if d is None:
            d = self._getRecursiveDict()
        names = d.keys()
        names.sort()
        for name in names:
            value = d[ name ]
            if type(value) == DictType:
                R2 = self._getDict(d=value, base="%s."%name)
                R.update(R2)
            else:
                R['%s%s'%(base,name)] = value
        return R
    
    def _getRecursiveDict( self, obj=None ):
        if obj == None:
            obj = self
        R = {}
        for name in dir( obj ):
            attr = getattr( obj, name )
            if name.startswith( '_' ) or _i.ismethod(attr): continue
            if isinstance(attr, ConfigurationSection):
                R[ name ] = self._getRecursiveDict( obj=attr )
            else:
                R[ name ] = attr
        return R
    
    #-------------------------------------------------------------------------------------------------------
    def _asTable( self, showEnvironment = False ):
        R = self._getRecursiveDict()
        return self._dictAsTable( R )

    #-------------------------------------------------------------------------------------------------------
    def __repr__( self ):
        return self._asTable()
    
    #-------------------------------------------------------------------------------------------------------
    def _readConfigFiles(self, filenames=[] ):
        # always read the lib, namespace & server configs
        self.__addCfgFile__(_p.join( self.libLocator, 'biocase','configuration.ini' ), readonly=True)
        self.__addCfgFile__(_p.join( self.configurationLocator,'config.ini' ), readonly=False)
        self.__addCfgFile__(_p.join( self.configurationLocator,'namespaces.ini' ), readonly=True)
        # postprocess namespaces. Create dictionary!
        if hasattr(self, "namespaces"):
            for name in dir(self.namespaces):
                if not name.startswith("_"):
                    self.ns2prefix[getattr(self.namespaces,name)]=name
        for fn in filenames:
            self.__addCfgFile__(configFilename, readonly=False)
            
    #-------------------------------------------------------------------------------------------------------
    def __addCfgFile__( self, configFilename, readonly=False ):
        '''Read a configParser file and add its entries to this object'''
        # read configparser file
        cfg = ConfigParser.ConfigParser()
        cfg.optionxform = str
        cfg.read(configFilename)
        for sectname in cfg.sections():
            # add section to cfg object
            section = ConfigurationSection()
            section.__name__ = sectname
            setattr(self, sectname, section)
            if readonly:
                section.__filename__ = None
            else:
                section.__filename__ = configFilename
            lists = {}
            for opt,val in cfg.items(sectname):
                if len(opt) > 1 and opt[-2] == '_':
                    # process as list
                    idx = int(opt[-1])
                    opt = opt[:-2]
                    if not lists.has_key(opt):
                        lists[opt]={}
                    lists[opt][idx] = val 
                else:
                    # set option in this section
                    section.__setOption__(opt, val)
            # add lists to section
            for opt, valList in lists.items():
                ids = valList.keys()
                ids.sort()
                l = []
                for i in ids:
                    l.append(valList[i])
                section.__setOption__(opt, l)
            
    #-------------------------------------------------------------------------------------------------------
    def __save__( self ):
        for sect in self._getSections():
            sect.__save__()
            
    #-------------------------------------------------------------------------------------------------------
    def getWebappURL(self):
        return "%s%s/" % (self.server.host, self.server.webroot)
    def getAccessPoint(self, dsa, protocol="biocase"):
        '''Return the full absolute URL to the pywrapper for this datasource'''
        if protocol == 'spice':
            return '%spyspice.cgi?dsa=%s'%(self.getWebappURL(), dsa)
        else:
            return '%spywrapper.cgi?dsa=%s'%(self.getWebappURL(), dsa)
    def getIP(self):
        return self.server.host.replace(self.server.host[:self.server.host.find('://')+3], '' )
    #-------------------------------------------------------------------------------------------------------
    def reloadConfigFiles(self, additionalConfigFiles=[], bpsPath=None):
        '''reload config file(s)'''
        # remove existing sections
        for sec in self._getSections():
            delattr( self, sec.__name__ )
        # reset home locator
        self._setHomeLocator(bpsPath)
        # load sections again
        self._readConfigFiles(additionalConfigFiles)


############################################################################################################
#
#===========================================================================================================
if __name__ == '__main__':
    import sys
    sys.setrecursionlimit( 20 )
    cfg = Cfg()
    print cfg
    print cfg._listOptions("server")
    print type(cfg.server.debug)
    cfg.server.__setOption__("debug","False")
    print cfg.server.debug, type(cfg.server.debug)
    #cfg.__save__()
    cfg.reloadConfigFiles()
    print cfg.ns2prefix
    print "-"*80
    print cfg
    
