# -*- coding: utf-8 -*-

from __future__ import absolute_import
# Import the PyQt and QGIS libraries
from builtins import next
from builtins import str
from builtins import object
import qgis
from qgis.PyQt import QtCore
from qgis.PyQt.QtCore import QSettings
from qgis.PyQt import QtWidgets
from qgis.PyQt.QtWidgets import QAction, QMenu, QDialog
from qgis.PyQt.QtGui import QIcon
try:
    from PyQt5.QtCore import *
    from PyQt5.QtGui import *
    from PyQt5 import QtGui
except:
    from PyQt6.QtCore import *
    from PyQt6.QtGui import *
    from PyQt6 import QtGui

from qgis.core import *
from qgis.core import QgsDataSourceUri
from qgis.PyQt.QtSvg import QSvgWidget
from qgis.PyQt.QtWidgets import (
    QDialog,
    QAction,
    QDockWidget,
    QFileDialog,
    QInputDialog,
    QMenu,
    QToolButton,
    QTableWidget, 
    QTableWidgetItem,
    QMessageBox,
    QVBoxLayout,
)
from .tools.SQLRequet import *
from .tools.resources import (
    load_ui,
    resources_path,
    send_issues,
)
try:
    from .tools.PythonSQL import login_base
except:
    print('Pas de fichier PythonSQL')

from .issues import CenRa_Issues

from ast import literal_eval
from qgis.utils import iface
import os.path
import webbrowser, os
import psycopg2
import psycopg2.extras
import base64

global DeBUG
DeBUG = 0

try:
    account = login_base('account')
    user = account[0]
    mdp = account[1]
    host = account[2]
    port = account[3]
    dbname = account[4]
    sigdb = account[5]
    refdb = account[6]



except:
    print('')
EDITOR_CLASS = load_ui('CenRa_Flux_base.ui')
html = '''<!DOCTYPE html>
<html>
<head>
    <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css"
     integrity="sha256-p4NxAoJBhIIN+hmNHrzRCf9tD/miZyoHS5obTRR9BMY="
     crossorigin=""/>
    <script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"
     integrity="sha256-20nQCchB9co0qIjJZRGuk2/Z9VM+kNiyxNV1lvTlZBo="
     crossorigin=""></script>
    <style>
        body { padding: 0; margin: 0; }
        html, body, #map { height: 100%; }
        .leaflet-control-layers-toggle {
          background-image: url(https://intranet.cenra-outils.org/Intranet/css/images/layers.png);
        }
        .legend_parc {
          border-radius: 15px;
          box-shadow: 2px 2px 3px 0 #6a6a6a;
          background-color: #fefafab3;
          opacity:0;
        }
        .legend_parc:hover{
          opacity:1;
        }
        .popup-with-no-events {
          pointer-events: none;
        }
    </style>
</head>
<body>
    <div id="map"></div>
    <script src="map.js"></script>
</body>
</html>
<script>'''
font = '''var OrthoIGN = L.tileLayer('https://wmts.geopf.fr/wmts?'+
'&LAYER={ignLayer}&STYLE={style}&TILEMATRIXSET=PM'+
'&SERVICE={service}&REQUEST=GetTile&VERSION=1.0.0'+
'&FORMAT={format}&TILECOL={x}&TILEROW={y}&TILEMATRIX={z}',
{
	ignLayer: 'ORTHOIMAGERY.ORTHOPHOTOS',
	style: 'normal',
	service: 'WMTS',
	format: 'image/jpeg',
	minZoom: 0,
	maxZoom: 19,
	attribution: '&copy; IGN'
}).addTo(map);
// Plan IGN avec une transparence de 50%
var PlanIGN = L.tileLayer('https://wmts.geopf.fr/wmts?'+
'&LAYER={ignLayer}&STYLE={style}&TILEMATRIXSET=PM'+
'&SERVICE={service}&REQUEST=GetTile&VERSION=1.0.0'+
'&FORMAT={format}&TILECOL={x}&TILEROW={y}&TILEMATRIX={z}',
{
	ignLayer: 'GEOGRAPHICALGRIDSYSTEMS.PLANIGNV2',
	style: 'normal',
	service: 'WMTS',
	format: 'image/png',
	minZoom: 0,
	maxZoom: 19,
	attribution: '&copy; IGN'
});
var baseMaps = {
	// "BDORTHO2" : bdortho,
// "Openstreetmap": openStreetMap,
// "Opentopomap": openTopoMap,				
"BDORTHO" : OrthoIGN,
"PlanIGN": PlanIGN
};
var overlayMaps = {
"Sites": Sites,
//"Parcelle":JSON
};
L.control.layers(baseMaps,overlayMaps).addTo(map);
var scale = L.control.scale({position: 'bottomleft', metric:true, imperial:false});
scale.addTo(map);
var legend = L.control({position: 'bottomleft'});

legend.onAdd = function (map) {
    var div = L.DomUtil.create('div', 'info legend_parc'),
    labels = [];
    labels.push('<i style="background:#73004c;width:18px;height:18px;float:left;margin-right:8px;opacity: 0.7;"></i> Acquisition')

    labels.push('<i style="background:#ff00c5;width:18px;height:18px;float:left;margin-right:8px;opacity: 0.7;"></i> Acquis en partie BND')

    labels.push('<i style="background:#f0ade1ab;width:18px;height:18px;float:left;margin-right:8px;opacity: 0.7;"></i> Acquisition pour partie')

    labels.push('<i style="background:#73462e;width:18px;height:18px;float:left;margin-right:8px;opacity: 0.7;"></i> Acquisition / Convention')

    labels.push('<i style="background:#e69800;width:18px;height:18px;float:left;margin-right:8px;opacity: 0.7;"></i> Convention')

    labels.push('<i style="background:#ffd37f;width:18px;height:18px;float:left;margin-right:8px;opacity: 0.7;"></i> Convention en partie BND')

    labels.push('<i style="background:#ffebaf;width:18px;height:18px;float:left;margin-right:8px;opacity: 0.7;"></i> Convention pour partie')

    labels.push('<i style="background:#c8c8c8;width:18px;height:18px;float:left;margin-right:8px;opacity: 0.7;"></i> Autre')

    labels.push('<i style="background:#f9ff08;width:18px;height:18px;float:left;margin-right:8px;opacity: 0.7;"></i> Projet en cours')

    labels.push('<i style="background:#fe0000;width:18px;height:18px;float:left;margin-right:8px;opacity: 0.7;"></i> Problème de mise à jour')

    labels.push('<i style="background:#000;width:18px;height:18px;float:left;margin-right:8px;opacity: 0.7;"></i> Pas de maitrise')

    div.innerHTML = labels.join('<br>');
    return div;
};

legend.addTo(map);
</script>'''
targetCrs = QgsCoordinateReferenceSystem('EPSG:4326')
layerCrs = QgsCoordinateReferenceSystem('EPSG:2154')
TranformCRS  = QgsCoordinateTransform(layerCrs, targetCrs,QgsProject.instance())

class Flux_Editor(QDialog, EDITOR_CLASS):

    def __init__(self, parent=None):
        _ = parent
        super().__init__()
        self.setupUi(self)
        self.settings = QgsSettings()
        self.s = QSettings()
        self.setWindowIcon(QtGui.QIcon(resources_path('icons','icon.png')))
        self.first_start = None
        self.iface = iface
        self.label_3.setPixmap(QtGui.QPixmap(resources_path('ui','logo.png')))
        self.commandLinkButton.setIcon(QtGui.QIcon(resources_path('ui','arrow-bottom.png')))
        self.commandLinkButton_2.setIcon(QtGui.QIcon(resources_path('ui','arrow-up.png')))

        #self.tableWidget.setSelectionBehavior(QTableWidget.selectRow)
        self.tableWidget.setEditTriggers(QtWidgets.QAbstractItemView.EditTrigger(0))
        self.toolButton.setIcon(QtGui.QIcon(resources_path('ui','find.png')))
        self.comboBox_2.addItem("SIG")
        self.comboBox_2.addItem('REF')
        self.comboBox.currentIndexChanged.connect(self.initialisation_flux)
        self.commandLinkButton.clicked.connect(self.selection_flux)
        self.tableWidget.itemDoubleClicked.connect(self.selection_flux)
        self.pushButton_2.clicked.connect(self.limite_flux)
        self.commandLinkButton_2.clicked.connect(self.suppression_flux)
        self.tableWidget_2.itemDoubleClicked.connect(self.suppression_flux)
        self.comboBox_2.currentIndexChanged.connect(self.bd_source)
        self.checkBox.hide()
        self.checkBox.stateChanged.connect(self.modeCarte)
        self.toolButton.clicked.connect(self.getCanevas)
        layout = QVBoxLayout()
        self.lineEdit.textChanged.connect(self.filtre_dynamique)
        self.viewer.textChanged.connect(self.NewTitle)
        layout.addWidget(self.lineEdit)
        self.viewer.hide()
        self.DeBUG.addItem('')
        self.DeBUG.addItem('01')
        self.DeBUG.addItem('0726')
        self.DeBUG.addItem('4269')

        self.DeBUG.hide()
        #self.lineEdit.mousePressEvent = self._mousePressEvent

        #metadonnees_plugin = open(self.plugin_path + '/metadata.txt')
        #infos_metadonnees = metadonnees_plugin.readlines()

    def raise_(self):
        """Run method that performs all the real work"""
        self.bd_source()
    def ModeDeBUG(self):
        self.DeBUG.show()

    def mousePressEvent(self, event):
        global DeBUG
        if 330 <= event.pos().x() <= 560 and 5 <= event.pos().y() <= 75:
            DeBUG = DeBUG+1
            if DeBUG == 3:
                DeBUG = 0
                self.ModeDeBUG()
        else:
            DeBUG = 0
            self.DeBUG.hide()

    def NewTitle(self):
        if self.viewer.title() != '':
            Tsplit = ((self.viewer.title()).split('.'))
            print(Tsplit[0],Tsplit[1])
            self.openPostGIS(Tsplit[0],Tsplit[1])

    def modeCarte(self):
        if self.checkBox.isChecked():
            self.viewer.show()

            cur.execute("SELECT ST_AsGeoJSON(st_centroid(ST_Transform(geom,4326))) FROM _agregation_ra._agreg_contour")
            varcenter = literal_eval(cur.fetchall()[0][0])
            varcenter = [varcenter['coordinates'][1],varcenter['coordinates'][0]]

            cur.execute("SELECT ST_AsGeoJSON(ST_Transform(st_collect(geom),4326)),tschema,tname FROM _agregation_ra._agreg_contour WHERE geom IS NOT NULL GROUP BY tschema,tname;" )
            varSite = cur.fetchall()
            cur.execute("SELECT ST_AsGeoJSON(ST_Transform(st_collect(geom),4326)),tschema,tname FROM _agregation_ra._agreg_travaux_prevus_poly WHERE geom IS NOT NULL GROUP BY tschema,tname;")
            varTravaux = cur.fetchall()
            cur.execute("SELECT ST_AsGeoJSON(ST_Transform(geom,4326)),milieu_libelle ,lb_eu_01,tschema,tname FROM _agregation_ra._agreg_eu_habitat WHERE geom IS NOT NULL;")
            varHabitat = cur.fetchall()

            vargeomS = literal_eval(varSite[0][0])
            vargeomT = literal_eval(varTravaux[0][0])
            vargeomH = literal_eval(varHabitat[0][0])
            #new_objectS = self.SwitchGeom(vargeomS)
            #new_objectT = self.SwitchGeom(vargeomT)
            #new_objectH = self.SwitchGeom(vargeomH)

            script = 'var map = L.map("map").setView('+str(varcenter)+', 13);'

            id = 0
            varSiteJSON = '''var ParcelleJSON = {
    "type": "FeatureCollection",
    "features":['''
            for varP in varSite:
                id = id+1
                varSiteJSON = varSiteJSON+'{"properties": {"code": "'+str(varP[1])+'.'+str(varP[2])+'" },'+str(varP[0][1:])+','
            varSiteJSON = varSiteJSON[:-1]+''']};
var Sites = L.geoJSON(ParcelleJSON,{
    style: function(feature) {
        switch (feature.geometry.properties.code) {
            case 'Ensemble de sites': return {fillColor: "#9a7863",color:"white",weight: 1,fillOpacity: 0.7};
            case 'Sous-site conservatoire': return {fillColor: "#e69800",color:"white",weight: 1,fillOpacity: 0.7};
            case 'Site non géré': return {fillColor: "#73004c",color:"white",weight: 1,fillOpacity: 0.7};
            case 'Animation territoriale': return {fillColor: "#ffebaf",color:"white",weight: 1,fillOpacity: 0.7};
            case 'Site conservatoire': return {fillColor: "#f9ff08",color:"white",weight: 1,fillOpacity: 0.7};
            default: return {fillColor: "#c8c8c8",color:"white",weight: 1,fillOpacity: 0.7};
        }
    },
    onEachFeature: function (feature,layer) { 
        layer.on('click', function(e) {
            map.fitBounds(layer.getBounds());
            document.title = feature.properties.code.toString();
        });
        layer.on('mouseover', function(e) {
            layer.setStyle({
                weight: 5,
                color: '#fe0000',
                dashArray: '',
            });
        });
        //layer.on('mousemove', function(e) {
            //layer.openPopup(e.latlng);
        //});
        layer.on('mouseout', function(e) {
            layer.setStyle({
                color:"white",
                weight: 1,
            });
        });
        layer.bindTooltip(feature.properties.code.toString(), {
            sticky: true,
            permanent: false,
            direction: 'right',
            className: 'label_parc'
        });
    }
}).addTo(map);'''
            id = 0
            varTravauxJSON = '''var TravauxJSON = {
    "type": "FeatureCollection",
    "features":['''
            for varT in varTravaux:
                id = id+1
                varTravauxJSON = varTravauxJSON+'{"properties": {"code": "'+str(varT[1])+'.'+str(varT[2])+'" },'+str(varT[0][1:])+','
            varTravauxJSON = varTravauxJSON[:-1]+''']};
var Travaux = L.geoJSON(TravauxJSON,{
    onEachFeature: function (feature,layer) { 
        layer.on('click', function(e) {
            map.fitBounds(layer.getBounds());
            document.title = feature.properties.code.toString();
        });
        layer.on('mouseover', function(e) {
            layer.setStyle({
                weight: 5,
                color: '#fe0000',
                dashArray: '',
            });
        });
        //layer.on('mousemove', function(e) {
            //layer.openPopup(e.latlng);
        //});
        layer.on('mouseout', function(e) {
            layer.setStyle({
                color:"white",
                weight: 1,
            });
        });
        layer.bindTooltip(feature.properties.code.toString(), {
            sticky: true,
            permanent: false,
            direction: 'right',
            className: 'label_parc'
        });
    }
}).addTo(map);'''
            script = script+varSiteJSON+varTravauxJSON
            self.viewer.setHtml(html+script+font)

        else:
            self.viewer.hide()

    def bd_source(self):
        self.activateWindow()
        bd_origine=self.comboBox_2.currentText()
        if bd_origine == 'REF':
            self.run_ref()
        if bd_origine == 'SIG':
            self.run_sig()

    def run_ref(self):
        """Run method that performs all the real work"""
        while self.tableWidget_2.rowCount() > 0:
            self.tableWidget_2.removeRow(self.tableWidget_2.rowCount()-1)
#            print(self.tableWidget_2.rowCount())
        global cur,con,dbtype
        dbtype=refdb
        con = psycopg2.connect("host=" + host + " port=" + port + " dbname="+dbtype+" user=" + user + " password=" + mdp)
        cur = con.cursor(cursor_factory = psycopg2.extras.DictCursor)
        self.initialisation_flux()
        self.combobox_custom()
        # Create the dialog with elements (after translation) and keep reference
        # Only create GUI ONCE in callback, so that it will only load when the plugin is started
        if self.first_start == True:
            self.first_start = False
        # show the dialog
        self.show()
        # Run the dialog event loop
        result = self.exec()
        # See if OK was pressed
        if result:
            # Do something useful here - delete the line containing pass and
            # substitute with your code.
            pass

    def run_sig(self):
        """Run method that performs all the real work"""
        while self.tableWidget_2.rowCount() > 0:
            self.tableWidget_2.removeRow(self.tableWidget_2.rowCount()-1)
        global cur,con,dbtype
        dbtype=sigdb
        con = psycopg2.connect("host=" + host + " port=" + port + " dbname="+dbtype+" user=" + user + " password=" + mdp)
        cur = con.cursor(cursor_factory = psycopg2.extras.DictCursor)
        self.initialisation_flux()
        self.combobox_custom()
        # Create the dialog with elements (after translation) and keep reference
        # Only create GUI ONCE in callback, so that it will only load when the plugin is started
        if self.first_start == True:
            self.first_start = False
        # show the dialog
        self.show()
        # Run the dialog event loop
        result = self.exec()
        # See if OK was pressed
        if result:
            # Do something useful here - delete the line containing pass and
            # substitute with your code.
            pass

    def suppression_flux(self):
        self.tableWidget_2.removeRow(self.tableWidget_2.currentRow())

    def open_url(self, item):
        url = item.data(Qt.UserRole)

    def initialisation_flux(self):
        if dbtype == sigdb:
            # self.toolButton.setEnabled(1)
            if self.comboBox.currentText() == 'toutes les catégories':
                custom_list=schemaname_list
            elif self.comboBox.currentText() == 'travaux':
                custom_list="""(SELECT schemaname,tablename from pg_catalog.pg_tables
         where schemaname like '"""+ str(self.comboBox.currentText()) +"""%' order by schemaname,tablename) UNION (SELECT schemaname,matviewname AS tablename FROM pg_catalog.pg_matviews where schemaname like '"""+ str(self.comboBox.currentText()) +"""%' order by schemaname,tablename) order by schemaname,tablename;"""
            else:
                custom_list="""(SELECT schemaname,tablename from pg_catalog.pg_tables
         where schemaname like '\_"""+ str(self.comboBox.currentText()) +"""%' order by schemaname,tablename) UNION (SELECT schemaname,matviewname AS tablename FROM pg_catalog.pg_matviews where schemaname like '\_"""+ str(self.comboBox.currentText()) +"""%' order by schemaname,tablename) order by schemaname,tablename;"""
        else:
            if self.comboBox.currentText() == 'toutes les catégories':
                custom_list=schemaname_list_ref
            else:
                custom_list="""SELECT schemaname,tablename from pg_catalog.pg_tables
         where schemaname like '"""+ str(self.comboBox.currentText()) +"""' order by schemaname,tablename;"""
        cur.execute(custom_list)
        list_schema = cur.fetchall()

        SQLraster = """SELECT concat(r_table_schema,'.',r_table_name) from public.raster_columns; """
        cur.execute(SQLraster)
        list_raster = cur.fetchall()
        RasterList = []
        for rasterFind in list_raster:
            RasterList.append(rasterFind[0])

        self.tableWidget.setRowCount(len(list_schema))
        self.tableWidget.setColumnCount(3)
        i=0
        for value in list_schema:
            if dbtype == sigdb:
                type_val = str(value[0])[1:3]
                schema_name=str(value[0])[4:]
                table_name=str(value[1][len(value[0])+1:])
                if value[0] == value[1][:len(value[0])]:
                    table_name=str(value[1][len(value[0])+1:])
                else:
                    table_name=str(value[1])
            else:
                type_val = ''
                schema_name=str(value[0])
                table_name=str(value[1])
            if type_val == 'fo':
                type_val=str(value[0])[1:5]
                schema_name=str(value[0])[6:]
                if value[0] == value[1][:len(value[0])]:
                    table_name=str(value[1][len(value[0])+1:])
                else:
                    table_name=str(value[1])
            elif type_val == 'ra':
                type_val='travaux'
                schema_name=str(value[0])
                table_name=str(value[1])
            elif type_val != '00' and type_val != '01' and type_val != '07' and type_val != '26' and type_val != '42' and type_val != '69' and type_val != 'ra':
                if dbtype == refdb:
                    if (schema_name+'.'+table_name) in RasterList:
                        SVG = 'mIconRaster.svg'
                    else:
                        SVG = 'mIconWfs.svg'
                    svgWidget = QSvgWidget(resources_path('icons',SVG))
                else:
                    type_val='agregation'
                schema_name=str(value[0])
                table_name=str(value[1])

            item = QTableWidgetItem(type_val)
            if dbtype == refdb:
                self.tableWidget.setCellWidget(i,0,svgWidget)
                self.tableWidget.setItem(i,0,QTableWidgetItem(''))
            else:
                self.tableWidget.setCellWidget(i,0,None)
                self.tableWidget.setItem(i,0,item)
            item = QTableWidgetItem(schema_name)
            self.tableWidget.setItem(i,1,item)
            item = QTableWidgetItem(table_name)
            self.tableWidget.setItem(i,2,item)
            i=i+1
        self.tableWidget.setColumnWidth(0, 20)
        self.tableWidget.setColumnWidth(1, 300)
        self.tableWidget.setColumnWidth(2, 300)
        self.tableWidget.setHorizontalHeaderLabels(["Code","Schema","Table"])

    def selection_flux(self):
        selected_row = 0
        selected_items = self.tableWidget.selectedItems()

        # Assuming you want to compare items in the first column for uniqueness
        svgTake = (selected_items[2].tableWidget().cellWidget(0,0))
        new_item_text = selected_items[2].text()

        if not self.item_already_exists(new_item_text):
            self.tableWidget_2.insertRow(selected_row)

            for column in range(self.tableWidget.columnCount()):
                cloned_item = selected_items[column].clone()
                self.tableWidget_2.setHorizontalHeaderLabels(["Code","Schema", "Table"])
                self.tableWidget_2.setColumnCount(3)
                self.tableWidget_2.setItem(selected_row, column, cloned_item)

            self.tableWidget_2.setColumnWidth(0, 50)
            self.tableWidget_2.setColumnWidth(1, 300)
            self.tableWidget_2.setColumnWidth(2, 300)


    def item_already_exists(self, new_item_text):
        # Assuming you want to compare items in the first column for uniqueness
        existing_items = self.tableWidget_2.findItems(new_item_text, QtCore.Qt.MatchFlag(0))

        # Check if there are any existing items with the same text in the first column
        return len(existing_items) > 0



    def limite_flux(self):

        if self.tableWidget_2.rowCount() > 5:
            self.QMBquestion = QMessageBox.question(iface.mainWindow(), u"Attention !",
                                                    "Le nombre de flux à charger en une seule fois est limité à 5 pour des questions de performances. Souhaitez vous tout de même charger les " + str(
                                                        self.tableWidget_2.rowCount()) + " flux sélectionnés ? (risque de plantage de QGIS)",
                                                    QMessageBox.StandardButton(0x00004000)|QMessageBox.StandardButton(0x00010000))
            if self.QMBquestion == QMessageBox.StandardButton(0x00004000):
                self.chargement_flux()

            if self.QMBquestion == QMessageBox.StandardButton(0x00001000):
                print("Annulation du chargement des couches")

        if self.tableWidget_2.rowCount() <= 5:
            self.chargement_flux()
    def openPostGIS(self,schema,table):
        uri = QgsDataSourceUri()
        uri.setConnection(host ,port ,sigdb ,user ,mdp)

        if (schema+'.'+table) in RasterList:
            uri.setDataSource(schema, table, "rast")
            uri.setKeyColumn('rid')
            uri.setSrid('2154')
            layer = QgsRasterLayer(uri.uri(), table, "postgresraster")
        else:
            uri.setDataSource(schema, table, "geom")
            uri.setKeyColumn('gid')
            uri.setSrid('2154')
            layer = QgsVectorLayer(uri.uri(), table, "postgres")
        # Ajout de la couche au canevas QGIS
        QgsProject.instance().addMapLayer(layer)

    def chargement_flux(self):

        managerAU = QgsApplication.authManager()
        k = managerAU.availableAuthMethodConfigs().keys()

        def REQUEST(type):
            switcher = {
                'WFS': "GetFeature",
                'WMS': "GetMap",
                'WMS+Vecteur': "GetMap",
                'WMS+Raster': "GetMap",
                'WMTS': "GetMap"
            }
            return switcher.get(type, "nothing")



        def displayOnWindows(type, uri, name):
            p = []

        SQLraster = """SELECT concat(r_table_schema,'.',r_table_name) from public.raster_columns; """
        cur.execute(SQLraster)
        list_raster = cur.fetchall()
        RasterList = []
        for rasterFind in list_raster:
            RasterList.append(rasterFind[0])

        for row in range(0, self.tableWidget_2.rowCount()):
            color_rgba = 855030089
            if self.tableWidget_2.item(row, 0).background().color().rgba() != 855030089:
                ## supression de la partie de l'url après le point d'interrogation
                if dbtype == sigdb:
                    code = self.tableWidget_2.item(row,0).text()
                    schema = '_'+code+'_'+self.tableWidget_2.item(row,1).text()
                    if code == 'travaux' or code == 'agregation':
                        schema = self.tableWidget_2.item(row,1).text()
                        table = self.tableWidget_2.item(row,2).text()
                    else:
                        table = self.tableWidget_2.item(row,2).text()
                        table = schema+'_'+table
                if dbtype == refdb:
#                    code = self.tableWidget_2.item(row,0).text()
                    schema = self.tableWidget_2.item(row,1).text()
                    table = self.tableWidget_2.item(row,2).text()#.split("?", 1)[0]
                uri = QgsDataSourceUri()
                uri.setConnection(host ,port ,dbtype ,user ,mdp)

                # nom du schéma à remplacer: "hydrographie" à supprimer et mettre "couches_collaboratives" lorsqu'on aura regroupé les couches à modifier dans un même schéma

                if (schema+'.'+table) in RasterList:
                    uri.setDataSource(schema, table, "rast")
                    uri.setKeyColumn('rid')
                    uri.setSrid('2154')
                    layer = QgsRasterLayer(uri.uri(), table, "postgresraster")
                    QgsProject.instance().addMapLayer(layer)
                else:
                    uri.setDataSource(schema, table, "geom")
                    uri.setKeyColumn('gid')

                    # Chargement de la couche PostGIS
                    geom_type ='SELECT right(st_geometrytype(geom),-3) as a FROM '+schema+'.'+table+' GROUP BY a'
                    cur.execute(geom_type)
                    list_typegeom = cur.fetchall()
                    if len(list_typegeom) > 1:
                        for typegeom in list_typegeom:
                            if typegeom[0] == 'MultiPolygon':
                                uri.setWkbType(QgsWkbTypes.MultiPolygon)
                            elif typegeom[0] == 'MultiLineString':
                                uri.setWkbType(QgsWkbTypes.MultiLineString)
                            elif typegeom[0] == 'Point':
                                uri.setWkbType(QgsWkbTypes.Point)
                            if typegeom[0] == 'Polygon':
                                uri.setWkbType(QgsWkbTypes.Polygon)
                            elif typegeom[0] == 'LineString':
                                uri.setWkbType(QgsWkbTypes.LineString)
                            elif typegeom[0] == 'MultiPoint':
                                uri.setWkbType(QgsWkbTypes.MultiPoint)
                            if (typegeom[0] != None and typegeom[0] != 'Polygon'):
                                uri.setSrid('2154')
                                layer = QgsVectorLayer(uri.uri(), table, "postgres")
                                # Ajout de la couche au canevas QGIS
                                QgsProject.instance().addMapLayer(layer)
                    else:
                        layer = QgsVectorLayer(uri.uri(), table, "postgres")
                        # Ajout de la couche au canevas QGIS
                        QgsProject.instance().addMapLayer(layer)
            else:
                self.QMBquestion = QMessageBox.question(iface.mainWindow(), u"Attention !","La couche «" + str(self.tableWidget_2.item(row,1).text()) +' '+ str(self.tableWidget_2.item(row,2).text()) + "» ne ce trouve pas dans cette BD !",QMessageBox.StandardButton(0x00004000))
    def combobox_custom(self):
        if dbtype == sigdb:
            self.toolButton.setEnabled(1)
            self.comboBox.clear()
            self.comboBox.addItem("toutes les catégories")
            self.comboBox.addItem('00')
            self.comboBox.addItem('01')
            self.comboBox.addItem('07')
            self.comboBox.addItem('26')
            self.comboBox.addItem('42')
            self.comboBox.addItem('69')
            self.comboBox.addItem('agregation')
            self.comboBox.addItem('travaux')
            self.comboBox.addItem('form')
        if dbtype == refdb:
            self.toolButton.setEnabled(0)
            custom_list=schemaname_distinct
            cur.execute(custom_list)
            list_schema = cur.fetchall()
            self.comboBox.clear()
            self.comboBox.addItem("toutes les catégories")
            for baxval in list_schema:
                self.comboBox.addItem(baxval[0])

    def filtre_dynamique(self, filter_text):
        if filter_text.find(' ') >= 0:
            filter_text=filter_text.replace(" ","_")
        for i in range(self.tableWidget.rowCount()):
            for j in range(self.tableWidget.columnCount()):
                item = self.tableWidget.item(i, j)
                match = filter_text.lower() not in item.text().lower()
                self.tableWidget.setRowHidden(i, match)
                if not match:
                    break

    def getCanevas(self):
        poly = iface.mapCanvas().extent()
        geom = (str(poly.xMinimum())+','+str(poly.yMinimum())+','+str(poly.xMaximum())+','+str(poly.yMaximum()))

        SQL_GEOM_CONTOUR = """SELECT DISTINCT tschema,tname FROM "_agregation_ra"."_agreg_contour" WHERE st_intersects(geom,ST_MakeEnvelope("""+geom+",2154)) ORDER BY tname"
        SQL_GEOM_HABITAT = """SELECT DISTINCT tschema,tname FROM "_agregation_ra"."_agreg_habitat" WHERE st_intersects(geom,ST_MakeEnvelope("""+geom+",2154)) ORDER BY tname"
        SQL_GEOM_EU_HABITAT = """SELECT DISTINCT tschema,tname FROM "_agregation_ra"."_agreg_eu_habitat" WHERE st_intersects(geom,ST_MakeEnvelope("""+geom+",2154)) ORDER BY tname"
        SQL_GEOM_TRAVAUX_PREVUS_LIGNE = """SELECT DISTINCT tschema,tname FROM "_agregation_ra"."_agreg_travaux_prevus_ligne" WHERE st_intersects(geom,ST_MakeEnvelope("""+geom+",2154)) ORDER BY tname"
        SQL_GEOM_TRAVAUX_PREVUS_POINT = """SELECT DISTINCT tschema,tname FROM "_agregation_ra"."_agreg_travaux_prevus_point" WHERE st_intersects(geom,ST_MakeEnvelope("""+geom+",2154)) ORDER BY tname"
        SQL_GEOM_TRAVAUX_PREVUS_POLY = """SELECT DISTINCT tschema,tname FROM "_agregation_ra"."_agreg_travaux_prevus_poly" WHERE st_intersects(geom,ST_MakeEnvelope("""+geom+",2154)) ORDER BY tname"

        cur.execute(SQL_GEOM_CONTOUR)
        TableContour = cur.fetchall()
        cur.execute(SQL_GEOM_HABITAT)
        TableHabitat = cur.fetchall()
        cur.execute(SQL_GEOM_EU_HABITAT)
        TableEuHabitat = cur.fetchall()
        cur.execute(SQL_GEOM_TRAVAUX_PREVUS_LIGNE)
        TableTravauxLigne = cur.fetchall()
        cur.execute(SQL_GEOM_TRAVAUX_PREVUS_POINT)
        TableTravauxPoint = cur.fetchall()
        cur.execute(SQL_GEOM_TRAVAUX_PREVUS_POLY)
        TableTravauxPoly = cur.fetchall()

        TableHaveGeom = sorted(TableContour+TableHabitat+TableEuHabitat+TableTravauxLigne+TableTravauxPoint+TableTravauxPoly)
        row_count = 0
        self.tableWidget.setRowCount(0)
        for e in TableHaveGeom:
            cur.execute("""SELECT DISTINCT count(*) FROM pg_catalog.pg_tables WHERE schemaname LIKE '"""+e[0]+"""' AND tablename LIKE '"""+e[1]+"""';""")
            TableSomme = cur.fetchall()[0][0]

            if e[0][1:3] != 'fo':
                DepName = QTableWidgetItem(e[0][1:3])
                SchemaName = QTableWidgetItem(e[0][4:])
            else:
                DepName = QTableWidgetItem('form')
                SchemaName = QTableWidgetItem(e[0][6:])
            TableName = QTableWidgetItem(e[1][len(e[0])+1:])
            self.tableWidget.insertRow(row_count)
            self.tableWidget.setItem(row_count,0,DepName)
            self.tableWidget.setItem(row_count,1,SchemaName)
            self.tableWidget.setItem(row_count,2,TableName)
            if TableSomme == 0:
                for j in range(self.tableWidget.columnCount()):
                    self.tableWidget.item(row_count, j).setBackground(QtGui.QColor(246, 185, 73,50))
                    self.tableWidget.item(row_count,j).setToolTip('Couche dans une autre BD !')
            row_count = row_count+1
        if self.lineEdit.text() != 'Recherche par mots-clés':
            self.filtre_dynamique(self.lineEdit.text())

    def SwitchGeom(self,vargeom):
        new_object = '['
        obj = vargeom['coordinates'][0][0]
        for obj_X in obj:
            new_object = new_object+'['+str(obj_X[1])+','+str(obj_X[0])+'],'
        new_object = new_object[:-1]+']'
        return(new_object)

    def popup(self):

        self.dialog = Popup()  # +++ - self
        self.dialog.text_edit.show()