##QGEP=group
##QGEP_translate=name
##Layers_config_source_table=table
##Reset_layer_name=boolean
##Reset_layer_title=boolean
##Fields_config_source_table=table
##Reset_field_alias=boolean
from qgis.core import *
import re
import json

class tools:

    @staticmethod
    def getLayerFromLegendByTableProps(tableName, geomCol='geom', sql=''):
        '''
        Get the layer from QGIS legend
        corresponding to a database
        table name (postgis or sqlite)
        '''
        layer = None
        lr = QgsMapLayerRegistry.instance()
        for lid,l in lr.mapLayers().items():
            if not hasattr(l, 'providerType'):
                continue
            if hasattr(l, 'type') and l.type() != 0:
                continue
            if not l.providerType() in (u'postgres', u'spatialite'):
                continue

            connectionParams = getConnectionParameterFromDbLayer(l)

            import re

            reg = r'(\.| )?(%s)' % tableName
            if connectionParams and \
                ( \
                    connectionParams['table'] == tableName or \
                    ( re.findall(reg, '%s' % connectionParams['table']) and re.findall(reg, '%s' % connectionParams['table'])[0] ) \
                ) and \
                connectionParams['geocol'] == geomCol:
                #and connectionParams['sql'] == sql:
                return l

        return layer

    @staticmethod
    def getConnectionParameterFromDbLayer(layer):
        '''
        Get connection parameters
        from the layer datasource
        '''
        connectionParams = None

        # Get params via regex
        uri = layer.dataProvider().dataSourceUri()
        reg = "(?:dbname='([^']+)' )?(?:service=([^ ]+) )?(?:host=([^ ]+) )?(?:port=([0-9]+) )?(?:user='([^ ]+)' )?(?:password='([^ ]+)' )?(?:sslmode=([^ ]+) )?(?:key='([^ ]+)' )?(?:estimatedmetadata=([^ ]+) )?(?:srid=([0-9]+) )?(?:type=([a-zA-Z]+) )?(?:table=\"(.+)\" )?(?:geomcol=([^ ]+)\) )?(?:sql=(.*))?"
        result = re.findall(r'%s' % reg, uri)
        if not result:
            return None

        res = result[0]
        if not res:
            return None

        dbname = res[0]
        service = res[1]
        host = res[2]
        port = res[3]
        user = res[4]
        password = res[5]
        sslmode = res[6]
        key = res[7]
        estimatedmetadata = res[8]
        srid = res[9]
        gtype = res[10]
        table = res[11]
        geocol = res[12]
        sql = res[13]

        schema = ''

        if ' FROM ' not in table:
            if re.search('"\."', table):
                table = '"' + table + '"'
                sp = table.replace('"', '').split('.')
                schema = sp[0]
                table = sp[1]
        else:
            reg = r'\* FROM ([^\)]+)?(\))?'
            f = re.findall(r'%s' % reg, table)

            if f and f[0]:
                sp = f[0][0].replace('"', '').split('.')
                if len(sp) > 1:
                    schema = sp[0].replace('\\', '')
                    table = sp[1]
                else:
                    table = sp[0]
            else:
                return None


        if layer.providerType() == u'postgres':
            dbType = 'postgis'
        else:
            dbType = 'spatialite'

        connectionParams = {
            'dbname' : dbname,
            'service' : service,
            'host' : host,
            'port': port,
            'user' : user,
            'password': password,
            'sslmode' : sslmode,
            'key': key,
            'estimatedmetadata' : estimatedmetadata,
            'srid' : srid,
            'type': gtype,
            'schema': schema,
            'table' : table,
            'geocol' : geocol,
            'sql' : sql,
            'dbType': dbType
        }

        return connectionParams

# Get vector layer objects
ltable= processing.getObject(Layers_config_source_table)
ftable= processing.getObject(Fields_config_source_table)

# Create dictionnary to store data to use
fdata = {}

# Get layers
layers = QgsMapLayerRegistry.instance().mapLayers().values()

# Read data to use and store it into data
tableFeatures = ftable.getFeatures()
for f in tableFeatures:
    d = f['field_name_fr']
    if len(f['field_description_fr']) < 5:
        d+= ' %s ' % f['field_description_fr']
    fdata[ f['field_name'] ] = d

# Apply aliases on layers
for layer in layers:
    progress.setInfo( '===== LAYER FIELDS ALIASES: ' + layer.name())
    if not hasattr( layer, 'pendingFields'):
        continue
    for i, field in enumerate(layer.pendingFields()):
        fname = re.sub('^(fk_|ws_|_|co_|[a-z]+_fk_)', '', field.name())
        if fname in fdata:
            alias = ''
            if not Reset_field_alias:
                alias = fdata[fname]
            layer.addAttributeAlias(i, alias)
            progress.setInfo( ' * Field : ' + field.name() + ' -> %s' % alias )


# Read data to use and store it into data
tableFeatures = ltable.getFeatures()
tdata = {}
for f in tableFeatures:
    d = f['name_fr']
    tdata[ f['tablename'] ] = d

progress.setInfo( '')
progress.setInfo( '===== LAYERS METADATA  ===== ')

# Apply title and name on layers
for layer in layers:
    progress.setInfo( '== LAYER : ' + layer.name())
    cp = {}
    cp = tools.getConnectionParameterFromDbLayer(layer)
    if not cp:
        continue
    table = cp['table']
    table = re.sub('^(vw(_qgep)?)?_', 'od_', table)
    if table in tdata:
        title = ''
        if not Reset_layer_title:
            title = tdata[table]
        layer.setTitle(title)
        lname = table
        if not Reset_layer_name:
            lname = tdata[table]
        layer.setName(lname)
        progress.setInfo( ' * Title : -> %s' % tdata[table] )


output = 'test'