# -*- coding: utf-8 -*-
u"""
Copyright (c) 2016 Biuro Urządzania Lasu i Geodezji Leśnej

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), 
to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, 
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
OTHER DEALINGS IN THE SOFTWARE.
"""

from Mapa_PU.kontroler.rejestr import szukaj_taksator
from Mapa_PU.model import biblioteka_dll

from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
#from PyQt5.QtGui import *
from qgis.core import *
from qgis.gui import *
from Mapa_PU.model.konfiguracja import *
from Mapa_PU.model.warstwy import Warstwy
from Mapa_PU.kontroler.mapa import Mapa 
from Mapa_PU.kontroler.generuj_oddzialy import GenerujOddzialy
from Mapa_PU.kontroler.generuj_pododdzialy import GenerujPodOddzialy
from Mapa_PU.kontroler.kontrola_geometrii import KontrolaGeometrii
from Mapa_PU.kontroler.kontrola_opisu_taksacyjnego import KontroleOpisuTaksacyjnego
from Mapa_PU.model.baza_danych import Baza
from Mapa_PU.kontroler.etykietownik import Etykietownik
from Mapa_PU.model.obiekty_podstawowe_model import ObiektyPodstawoweModel
from Mapa_PU.kontroler.obiekty_liniowe import ObiektyLiniowe
from functools import partial
from Mapa_PU.kontroler import komunikaty
import os, sys, webbrowser, operator, re
# Initialize Qt resources from file resources.py
from .resources import *

# Import the code for the dialog
from .upul_modul_dialog import upulDialog
import os.path
from Mapa_PU.kontroler import metody_globalne
from Mapa_PU.kontroler.generuj_lokalizacje import Centroid
import platform
from Mapa_PU.kontroler.swdl import Swdl
from Mapa_PU.kontroler import rejestr
from PyQt5 import QtGui, QtCore
from Mapa_PU.kontroler.kontrole_danych import Kontroluj
from Mapa_PU.kontroler.raporty import Raporty
from Mapa_PU.kontroler.informacja import Informacja
from Mapa_PU.widok.o_programie import OProgramieDialog
from Mapa_PU.widok.pasek_wiadomosci import PasekWiadomosc
from Mapa_PU.model.baza_danych import Baza
from Mapa_PU.swdl.containers.containers import Container
import traceback
import pyodbc

root=os.path.dirname(__file__)
taksator_PU='2.0'

import configparser
config = configparser.ConfigParser()
config.read(os.path.join(root,'metadata.txt'))
version=config.get('general', 'version')
swdl_version=config.get('general', 'swdl')
# try: import dotnet.seamless
# except ImportError:
#     pass


class upul:
    u"""QGIS Plugin Implementation."""

    def __init__(self, iface):
        u"""Constructor.

        :param iface: An interface instance that will be passed to this class
            which provides the hook by which you can manipulate the QGIS
            application at run time.
        :type iface: QgsInterface
        """
        # Save reference to the QGIS interface
        self.iface = iface
        # initialize plugin directory
        self.plugin_dir = os.path.dirname(__file__)
        
        self._konfiguracja=None
        self._mapa=None
        self._projekt=None
        Container.Version=version
        Container.Root=root
        Container.SwdlVersion=swdl_version
        # initialize locale
        locale = QSettings().value('locale/userLocale')[0:2]
        locale_path = os.path.join(
            self.plugin_dir,
            'i18n',
            'upul_{}.qm'.format(locale))

        if os.path.exists(locale_path):
            self.translator = QTranslator()
            self.translator.load(locale_path)

            if qVersion() > '4.3.3':
                QCoreApplication.installTranslator(self.translator)

        # Create the dialog (after translation) and keep reference
        self.dlg = upulDialog()

        # Declare instance attributes
        self.actions = []
        
        self.baza_kontroli=Baza(u'{}/szablony/baza_kontroli_upul.mdb'.format(root))
        
        #Instalacja sterownika Access
        drivers=[x for x in pyodbc.drivers() if x.startswith('Microsoft Access Driver')]#[x for x in pyodbc.drivers () if x.startswith('Microsoft Access Driver (*.mdb, *.accdb)')]
        if len(drivers)==0:
            ret=komunikaty.pytanie_tak_nie(u'Brak sterownika Access',u'Do poprawnego działania Mapa PU wymagany jest sterownik do bazy Access-a.\nCzy Mapa PU ma zainstalować sterownik?')
            if ret==1:
                raise Exception("Nie można otworzyć Mapa PU z powodu braku sterownika do bazy Access")
            if ret==0:
                import subprocess
                if '64 bit' in sys.version:
                    subprocess.call(['%s/moduly/AccessDatabaseEngine_X64.exe' % root])
                    #subprocess.run(['%s/moduly/AccessDatabaseEngine_X64.exe' % root,'/quiet'])
                if '32 bit' in sys.version:
                    #subprocess.run(['%s/moduly/AccessDatabaseEngine.exe' % root,'/quiet'])
                    subprocess.call(['%s/moduly/AccessDatabaseEngine.exe' % root])
                #sprawdzenie zainstalowania sterownika po instalacji
                drivers=[x for x in pyodbc.drivers () if x.startswith('Microsoft Access Driver (*.mdb, *.accdb)')]
                if len(drivers)==0:
                    raise Exception("Nie można otworzyć Mapa PU z powodu braku sterownika do bazy Access")
        #
        

    def tr(self, message):
        u"""Get the translation for a string using Qt translation API.

        We implement this ourselves since we do not inherit QObject.

        :param message: String for translation.
        :type message: str, QString

        :returns: Translated version of message.
        :rtype: QString
        """
        # noinspection PyTypeChecker,PyArgumentList,PyCallByClass
        return QCoreApplication.translate('upul', message)

   
    def initGui(self):
        u"""Create the menu entries and toolbar icons inside the QGIS GUI."""
        try:
            icon_path = ':/plugins/upul/icon.png'
            
            self.menu=QMenu(self.iface.mainWindow()) 
            self.menu.setObjectName('Mapa PU')
            self.menu.setTitle('Mapa PU')
            
            menuBar=self.iface.mainWindow().menuBar()
            menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(), self.menu)
            
                  
            self.utworz = QAction(QIcon(None),u"Utwórz mapę dla UPUL...",self.iface.mainWindow())
            self.otworz = QAction(QIcon(None),u"Otwórz mapę dla UPUL...",self.iface.mainWindow())
            self.pomoc=QAction(QIcon(None),u"Pomoc",self.iface.mainWindow())
            self.oProgramie=QAction(QIcon(None),u'O Mapa PU',self.iface.mainWindow())
            
            self.etykiety=QMenu(u"Etykietuj",self.menu)
            self.warstwy=QMenu(u"Generuj warstwy",self.menu)
            self.kontrolaOpisuTaksacyjnego=QAction(QIcon(None),u"Kontroluj opis taksacyjny",self.iface.mainWindow())
            self.kontrolaGeometrii = QAction(QIcon(None),u"Kontroluj poprawność geometryczną",self.iface.mainWindow())
            self.dane = QAction(QIcon(None),u"Kontroluj spójność danych",self.iface.mainWindow())
            self.zestawienia = QAction(QIcon(None),u"Utwórz zestawienie...",self.iface.mainWindow())
            self.validacjaSWDL=QAction(QIcon(None),u"Sprawdź plik SWDL...",self.iface.mainWindow())
            self.importSWDL=QAction(QIcon(None),u"Importuj z SWDL...",self.iface.mainWindow())
            self.exportSWDL=QAction(QIcon(None),u"Eksportuj do SWDL...",self.iface.mainWindow())
            self.informacja = QAction(QIcon(None), u"Informacja o nadzorze...", self.iface.mainWindow())
            self.__przyciski=(self.etykiety,self.warstwy,self.kontrolaOpisuTaksacyjnego,self.kontrolaGeometrii,self.dane,self.zestawienia,self.validacjaSWDL,self.importSWDL,self.exportSWDL,self.informacja)
            
            #menu glowne
            self.menu.addAction(self.utworz)
            self.menu.addAction(self.otworz)
            self.menu.addSeparator()
            self.menu.addMenu(self.etykiety)
            self.menu.addMenu(self.warstwy)
            self.menu.addSeparator()
            self.menu.addAction(self.kontrolaOpisuTaksacyjnego)
            self.menu.addAction(self.kontrolaGeometrii)
    
            self.menu.addAction(self.dane)
            #self.menu.addSeparator()
            #self.menu.addAction(self.zestawienia)
            self.menu.addSeparator()
            #self.menu.addAction(self.validacjaSWDL)
            self.menu.addAction(self.importSWDL)
            self.menu.addAction(self.exportSWDL)
            self.menu.addSeparator()
            self.menu.addAction(self.informacja)
            self.menu.addSeparator()
            self.menu.addAction(self.oProgramie)
            self.menu.addAction(self.pomoc)
            
            #Akcje menu
            
            self.utworz.setShortcut("Ctrl+U")
            self.iface.registerMainWindowAction(self.utworz, "Ctrl+U")
            self.utworz.triggered.connect(self.utworzProjekt)
            
            
            self.iface.registerMainWindowAction(self.otworz, "Ctrl+O")
            self.otworz.triggered.connect(self.otworzProjekt)
            
            self.kontrolaOpisuTaksacyjnego.triggered.connect(self.kontrolujOpisTaksacyjny)
            #self.iface.registerMainWindowAction(self.kontrolaGeometrii, "Ctrl+K")
            #QObject.connect(self.kontrolaGeometrii, pyqtpyqtSignal("triggered()"), self.kontrola_geometrii )
            self.kontrolaGeometrii.triggered.connect(self.kontrola_geometrii)
            
            #QObject.connect(self.dane, pyqtSignal("triggered()"), self.kontrolujDane)
            self.dane.triggered.connect(self.kontrolujDane)
            
            self.validacjaSWDL.triggered.connect(self.validujPlikSWDL)
            self.importSWDL.triggered.connect(self.importujSWDL)        
            self.exportSWDL.triggered.connect(self.eksportujDoSWDL)
            #
            
            #Akcje podmenu Etykiety
            self.obiektyPodstawowe=QAction(QIcon(None),u"Etykietuj obiekty podstawowe ...",self.iface.mainWindow())
            #QObject.connect(self.obiektyPodstawowe, pyqtSignal("triggered()"), self.etykietuj_obiekty_podstawowe)
            self.obiektyPodstawowe.triggered.connect(self.etykietuj_obiekty_podstawowe) 
                    
            self.obiektyLiniowe=QAction(QIcon(None),u"Etykietuj obiekty liniowe ...",self.iface.mainWindow())
            #QObject.connect(self.obiektyLiniowe, pyqtSignal("triggered()"), self.etykietuj_obiekty_liniowe)
            self.obiektyLiniowe.triggered.connect(self.etykietuj_obiekty_liniowe)
            
            self.obiektyPNSW=QAction(QIcon(None),u"Etykietuj PNSW ...",self.iface.mainWindow())
            #QObject.connect(self.obiektyPNSW, pyqtSignal("triggered()"), self.etykietuj_obiekty_PNSW)
            self.obiektyPNSW.triggered.connect(self.etykietuj_obiekty_PNSW)
            
            self.obiektyPowierzchniowe=QAction(QIcon(None),u"Etykietuj osobliwości przyrodnicze powierzchniowe ...",self.iface.mainWindow())
            #QObject.connect(self.obiektyPowierzchniowe, pyqtSignal("triggered()"), self.etykietuj_osobliwosci_powierzchniowe)
            self.obiektyPowierzchniowe.triggered.connect(self.etykietuj_osobliwosci_powierzchniowe)
            
            self.obiektyPunktowe=QAction(QIcon(None),u"Etykietuj osobliwości przyrodnicze punktowe ...",self.iface.mainWindow())
            #QObject.connect(self.obiektyPunktowe, pyqtSignal("triggered()"), self.etykietuj_osobliwosci_punktowe)
            self.obiektyPunktowe.triggered.connect(self.etykietuj_osobliwosci_punktowe)
            #
            
            #Akcje podmenu generuj warstwy
            #PU008 generuj oddzialy:
            self.generujOddzialyAction=QAction(QIcon(None),u'Generuj Oddziały',self.iface.mainWindow())
            #QObject.connect(self.generujOddzialyAction, pyqtSignal("triggered()"), self.generujOddzialy)
            self.generujOddzialyAction.triggered.connect(self.generujOddzialy)
            
            #PU009 generuj pododdzialy::
            self.generujPododdzialyAction=QAction(QIcon(None),u'Generuj Pododdziały',self.iface.mainWindow())
            #QObject.connect(self.generujPododdzialyAction, pyqtSignal("triggered()"), self.generujPodOddzialy)
            self.generujPododdzialyAction.triggered.connect(self.generujPodOddzialy)
            #
            
            self.generujLokalizacjeOpisowOddzialy=QAction(QIcon(None),u'Generuj lokalizacje opisów oddziałów',self.iface.mainWindow())
            self.generujLokalizacjeOpisowOddzialy.triggered.connect(partial(self.generujCentroidy,'ODDZIAL','OP_ODDZ',['ID','ADR_BDL']))
            #QObject.connect(self.generujLokalizacjeOpisowOddzialy, pyqtSignal("triggered()"), partial(self.generujCentroidy,'ODDZIAL','OP_ODDZ',['ID','ADR_BDL']))
            
            self.generujLokalizacjeOpisowPododdzialy=QAction(QIcon(None),u'Generuj lokalizacje opisów pododdziałów',self.iface.mainWindow())
            #QObject.connect(self.generujLokalizacjeOpisowPododdzialy, pyqtSignal("triggered()"), partial(self.generujCentroidy,'POW','OP_POW',['ID','ADR_BDL']))
            self.generujLokalizacjeOpisowPododdzialy.triggered.connect(partial(self.generujCentroidy,'POW','OP_POW',['ID','ADR_BDL']))
            
            #QObject.connect(self.zestawienia, pyqtSignal("triggered()"), self.generujRaporty)
            self.zestawienia.triggered.connect(self.generujRaporty)
            
            #QObject.connect(self.informacja, pyqtSignal("triggered()"),  self.informacjaNadzor)
            self.informacja.triggered.connect(self.informacjaNadzor)
            
            #QObject.connect(self.pomoc, pyqtSignal("triggered()"), self.pokazPomoc)
            self.pomoc.triggered.connect(self.pokazPomoc)
            
            #QObject.connect(self.oProgramie,pyqtSignal("triggered()"),self.pokazOProgramie)
            self.oProgramie.triggered.connect(self.pokazOProgramie)
                      
            #podmenu Etykietuj
            
            self.etykiety.addAction(self.obiektyPodstawowe)
            self.etykiety.addAction(self.obiektyLiniowe)
            self.etykiety.addAction(self.obiektyPNSW)
            self.etykiety.addAction(self.obiektyPunktowe)
            self.etykiety.addAction(self.obiektyPowierzchniowe)
            
            #podmenu Generuj warstwy
            
            self.warstwy.addAction(self.generujOddzialyAction)
            self.warstwy.addAction(self.generujPododdzialyAction)
            self.warstwy.addSeparator()
            self.warstwy.addAction(self.generujLokalizacjeOpisowOddzialy)
            self.warstwy.addAction(self.generujLokalizacjeOpisowPododdzialy)  
            #
            #QObject.connect(self.menu, pyqtSignal("aboutToShow()"), self.kontrolujDostepnoscPrzyciskow)
            self.menu.triggered.connect(self.kontrolujDostepnoscPrzyciskow)
            
            #kontrola modułu zewnętrznego do odczytu biblioteki dotnet 
            self.kontrolujDostepnoscPrzyciskow()
            #komunikat o module dotnet
           
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Błąd wczytania gui użytkownika',traceback.format_exc())
#             komunikaty.blad_systemowy(e,"Błąd wczytania gui użytkownika")
            
    @property
    def konfiguracja(self):
        u"""obiekt konfiguracji z sciezkami"""
        return self._konfiguracja

    @konfiguracja.setter
    def konfiguracja(self,wartosc):
        self._konfiguracja=wartosc
        
    @konfiguracja.getter
    def konfiguracja(self):
        return self._konfiguracja

    @property
    def mapa(self):
        u"""obiekt mapy projektu"""
        return self._mapa

    @mapa.setter
    def mapa(self,wartosc):
        self._mapa=wartosc
        
    @mapa.getter
    def mapa(self):
        return self._mapa

    @property
    def projekt(self):
        return self._projekt

    @projekt.setter
    def projekt(self,wartosc):
        self._projekt=wartosc
    
    @projekt.getter
    def projekt(self):
        return self._projekt

    def udostepnij(self,przyciski,wartosc=False):
        for self.object in przyciski:
            self.object.setEnabled(wartosc)
       

    def unload(self):
        u"""Removes the plugin menu item and icon from QGIS GUI."""
        self.menu.deleteLater()

    def get_table_data(self):
        stdouterr = os.popen4("dir c:\\")[1].read()
        lines = stdouterr.splitlines()
        lines = lines[5:]
        lines = lines[:-2]
        self.tabledata = [re.split(r"\s+", line, 4)
                     for line in lines]
    
    def utworzProjekt(self):
        u"""Obsługa utworzenia pliku projektu"""
        try:
            #Marcin Śliwa
            #Kontrola modulu adodbapi
#             if self.kontrolujAdodbapi()==False:
#                 self.komunikatAdodbapi()
#                 return
            #Kontrola i zapis projektu obecnego 
            if self.kontrolaPlikuProjektu()==True:
                if komunikaty.pytanie_tak_nie('Projekt', u'Czy zapisać obecny projekt ?')==0:
                    if self.mapa!=None:
                        self.mapa.zapisz()
                if self.mapa!=None:
                    self.mapa.wyczyscProjekt()         
            
            #
            self.projekt=Projekt(self.iface,self.plugin_dir)
            
            self.konfiguracja=self.projekt.nowy()
            
            if self.konfiguracja==None:
                return
                   
            #Utworzenie katalogów
            self.projekt.utworzKatalogi(self.konfiguracja)
            
            #Kopiowanie pliku projektu UPUL.QGS
            #sciezka szablonu
            szablon=self.projekt.szablony+"UPUL.qgs"
            #sciezka docelowa
            plikProjektu=self.konfiguracja.sciezka+"//UPUL.QGS"
            metody_globalne.kopiuj(szablon,plikProjektu)
            
            #Generowanie wrstw
            self.warstwy=Warstwy(self.konfiguracja)
            self.warstwy.generujWarstwy()
            
            #Kopiowanie pliku Taksatora
            while True:
                plikTaksatora,typ=QFileDialog.getOpenFileName(self.iface.mainWindow(),u'Proszę wskazać plik bazy programu TaksatorPU',self.konfiguracja.katalog,"Plik TaksatorPU (*.mdb *.MDB)")
                if plikTaksatora=='':
                    komunikaty.ostrzezenie(u"Brak bazy",u"Dla prawidłowego działania programu proszę o skopiowanie pliku bazy Taksator PU do katalogu '%s' i zmianę nazwy bazy na UPUL.MDB. Następnie proszę skorzystać z Otwórz mapę dla UPUL" % self.konfiguracja.taksator)
                    return
                else:
                    #Kontrola czy jest to baza taksatora
                    if self.projekt.kontrolaBazyTaksator(plikTaksatora)==False:
                       komunikaty.blad(u"Błędna baza",u'Wskazana baza nie jest poprawną bazą Taksator PU w wersji %s lub wyższej.' % taksator_PU)
                       continue
                    
                       
                
                taksatorDocelowy=self.konfiguracja.taksator+"//UPUL.MDB"
                
                metody_globalne.kopiuj(plikTaksatora,taksatorDocelowy)
                
                komunikaty.informacja('Kopiowanie bazy',u'Przekopiowano wskazaną bazę Taksator PU o nazwie '+os.path.basename(plikTaksatora)+u' do katalogu TaksatorPU w projekcie '
                                  +self.konfiguracja.taksator+u' i zmieniono nazwę na UPUL.MDB')
                
                #wyjscie z petli 
                break
                
            
            #Załadowanie projektu do mapy
            self.mapa=Mapa(self.konfiguracja.plikQgs,self.iface)
          
            self.mapa.otworzProjekt()
            #Komunikat koncowy
            komunikaty.informacja(u"Utworzono projekt",u"Utworzono katalog projektu "+self.konfiguracja.sciezka)
            #Odblokowanie przycisków
            
            self.kontrolujDostepnoscPrzyciskow()
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Nie udało się utworzyć projektu',traceback.format_exc())
    
        
    def otworzProjekt(self):
        u"""Obsługa otwarcia projektu"""
        
        try:
            #Kontrola i zapis projektu obeego 
            if self.kontrolaPlikuProjektu()==True:
                if komunikaty.pytanie_tak_nie(u'Projekt', u'Czy zapisać obecny projekt ?')==0:
                   if self.mapa!=None:       
                       self.mapa.zapisz()
                       self.mapa.wyczyscProjekt()         
                
            #    
            self.projekt=Projekt(self.iface,self.plugin_dir)
            
            self.konfiguracja=self.projekt.otworz()
            
            if  self.konfiguracja==None:
                return
            self.mapa=Mapa(self.konfiguracja.plikQgs,self.iface)
            self.mapa.otworzProjekt()
            
            self.mapa.usunWarstwyMemory()
            #self.udostepnij(self.__przyciski, True)
            
            self.kontrolujDostepnoscPrzyciskow()
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Błąd otwarcia projektu',traceback.format_exc())
        
    def kontrolujDane(self):
        u"""wywołanie kontroli danych"""
        try:
            #PU010
            
            self.kontrola=Kontroluj(root,swdl_version,self.mapa,self.konfiguracja,self.iface,version)
            self.kontrola.start()
             
          
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Błąd kontroli danych',traceback.format_exc())
    
    def generujCentroidy(self,nazwaWarstwy,nazwaWarstwyOpisowej,nazwyPol):
        u"""generuje centroidy"""
        try:
            #PU015
            opisy=Centroid(self.iface,self.konfiguracja.warstwy,self.mapa)
            opisy.generuj_opis(nazwaWarstwy, nazwaWarstwyOpisowej, nazwyPol)
            #self.iface.mapCanvas().refresh() 
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Błąd generowania centroidów',traceback.format_exc())
    
    
    def etykietuj_obiekty_podstawowe(self):
        u"""etykietuje obiekty podstawowe"""
        try:
            
            etykietownik=Etykietownik(self.iface,self.konfiguracja,self.mapa)
            etykietownik.etykietuj_obiekty_podstawowe()
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Błąd etykietowania obiektów podstawowych',traceback.format_exc())
                
    def etykietuj_obiekty_liniowe(self):
        u"""etykietuje obiekty podstawowe"""
        try:
            etykietownik=Etykietownik(self.iface,self.konfiguracja,self.mapa)
            etykietownik.etykietuj_obiekty_liniowe()
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Błąd etykietowania obiektów liniowych',traceback.format_exc())
                
    def etykietuj_obiekty_PNSW(self):
        u"""etykietuje obiekty podstawowe"""
        try:
            etykietownik=Etykietownik(self.iface,self.konfiguracja,self.mapa)
            etykietownik.etykietuj_PNSW()
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Błąd etykietowania obiektów PNSW',traceback.format_exc())
            
    def etykietuj_osobliwosci_punktowe(self):
        u"""etykietuje obiekty podstawowe"""
        try:
            etykietownik=Etykietownik(self.iface,self.konfiguracja,self.mapa)
            etykietownik.etykietuj_osobliwosci_punktowe()
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Błąd etykietowania obiektów podstawowych',traceback.format_exc())
            
    def etykietuj_osobliwosci_powierzchniowe(self):
        u"""etykietuje obiekty podstawowe"""
        try:
            etykietownik=Etykietownik(self.iface,self.konfiguracja,self.mapa)
            etykietownik.etykietuj_osobliwosci_powierzchniowe()
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Błąd etykietowania osobliwości powierzchniowych',traceback.format_exc())
    
    def generujOddzialy(self):
        u"""generuje oddziały"""
        try:
            _generuj_oddzialy = GenerujOddzialy(self.iface,self.mapa)
            _generuj_oddzialy.showGenerujOddzialyDialog()
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Błąd generowania oddziałów',traceback.format_exc())
            
    def generujPodOddzialy(self):
        u"""generuje pododdziały"""
        try:
            _generuj_pododdzialy = GenerujPodOddzialy(self.iface,self.mapa)
            _generuj_pododdzialy.showGenerujPodOddzialyDialog()
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Błąd generowania pododdziałów',traceback.format_exc())
        
    def kontrola_geometrii(self):
        u"""Kontrola Geometrii"""
        try:    
            #komunikaty.czekanie('Kontrola geometrii')
            kontrola=KontrolaGeometrii(self.iface,root,self.konfiguracja,self.mapa,self.projekt,version,self.baza_kontroli)
            #kontrola.kontrola_podstawowa()
            kontrola.start()
            komunikaty.usun()
#             from Mapa_PU.kontroler.task_helper import TaskProgress
#             t=TaskProgress(self.iface)
#             t.start("Testowy",kontrola)
        except Exception:
            komunikaty.usun()
            komunikaty.wiadomoscBlad(self.iface,u'Kontrole geometrii zakończyła się błędem',traceback.format_exc())
#         except Exception as e:
#             komunikaty.blad_systemowy(e)     
    def kontrolujOpisTaksacyjny(self):
        """Kontrola opisu taksacyjnego"""
        try:
            kontrola=KontroleOpisuTaksacyjnego(root,self.konfiguracja,version,self.iface)
            kontrola.start()
            komunikaty.usun()
        except Exception as e:
            komunikaty.usun()
            komunikaty.wiadomoscBlad(self.iface,u'Kontrole opisu taksacyjnego zakończyła się błędem',traceback.format_exc())
            
    def kontrolaPlikuProjektu(self):
        u"""Kontroluje czy wczytany jest plik projektu upul .qgis"""
        try:
            instancja=QgsProject.instance()
            return instancja.readBoolEntry("TypProjektu", "typ")[0]
          
        except Exception as e:
            komunikaty.blad_systemowy(e)    
    
    def kontrolaKonfiguracji(self):
        u"""sprawdza stan konfiguracji"""
        if self.konfiguracja==None or self.mapa==None:
            return False
        return True
    
    def kontrolujDostepnoscPrzyciskow(self):
        u"""Kontroluje dostępnośc przycisków"""
        self.udostepnij(self.__przyciski,(self.kontrolaPlikuProjektu() and self.kontrolaKonfiguracji()))
    
    def validujPlikSWDL(self):
        u"""Wywołuje sprawdzenie pliku SWDL"""
        try:
            swdl=Swdl(root,swdl_version,self.plugin_dir,self.konfiguracja,self.mapa,self.iface,self.projekt,version,self.baza_kontroli)
            
            swdl.validuj(root)
        except Exception as e:
            raise e
    
    def eksportujDoSWDL(self):
        u"""Wywołuje eksport do bazy SWDL"""
        try:
            #Kontrola warstw w projekcie
            lista=[nazwa for nazwa in list(Projekt.listaWarstw) if self.mapa.czyWarstwaJestwWidoku(nazwa)==False]
            if lista:
                komunikaty.blad(u"Brak warstw", u"Do wkonania eksportu do pliku swdl wymagane są wszystkie warstwy w projekcie.\nDodaj warstwy:\n{}".format(', '.join(lista)))
                return
            swdl=Swdl(root,swdl_version,self.plugin_dir,self.konfiguracja,self.mapa,self.iface,self.projekt,version,self.baza_kontroli)
            
            swdl.eksportuj()
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Eksport danych do pliku SWDL zakończył się błędem',traceback.format_exc())
        
    
    def importujSWDL(self):
        u"""Importuje dane z bazy swdl"""
#         
        try:
            #Kontrola warstw w projekcie
            lista=[nazwa for nazwa in list(Projekt.listaWarstw) if self.mapa.czyWarstwaJestwWidoku(nazwa)==False]
            if lista:
                komunikaty.blad(u"Brak warstw", u"Do wkonania importu pliku swdl wymagane są wszystkie warstwy w projekcie.\nDodaj warstwy:\n{}".format(', '.join(lista)))
                return
            
            swdl=Swdl(root,swdl_version,self.plugin_dir,self.konfiguracja,self.mapa,self.iface,self.projekt,version,self.baza_kontroli)
            swdl.importuj(root)
            
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Import danych z pliku SWDL zakończył się błędem',traceback.format_exc())
    
   
    
   
    
    def generujRaporty(self):
        u"""Generuje raporty"""
        try:
            if self.kontrolujDotnet()==False:
                self.komunikatDotnet()
                return

            raporty=Raporty(self.mapa,self.iface,self.konfiguracja)
            if raporty.can_start:
                raporty.run()
            else:
                return
            
            #raporty.pokazDostepneRaporty()
        except Exception:
            komunikaty.wiadomoscBlad(self.iface,u'Nie udało się utworzyć projektu',traceback.format_exc())
            
            
    
    
            
    def informacjaNadzor(self):
        u""" Ustawienia informacji o nadzorze. """
        info = Informacja(self.konfiguracja)
        info.run()
    
#     def komunikatDotnet(self):
#         u"""Wyswietla komunikat o braku biblioteki dotnet"""
#         import sys
#         sciezkaAplikacji=sys.executable.split('bin')[0]
#         modulyAplikacji="%sapps\\python27\\lib\\site-packages" % sciezkaAplikacji 
#         py_architecture = platform.architecture()[0]
#         if py_architecture == "64bit":
#             zasob='%s\moduly\dotnet_64' % root
#         else:
#             zasob='%s\moduly\dotnet_32' % root
#         komunikaty.blad(u'Brak biblioteki',u"Wybrana funkcja wymaga dodatkowej biblioteki. Należy zainstalować moduł 'dotnet' w lokalizacji:\n'%s'.\nMożna go skopiować z katalogu:\n'%s'\nlub zainstalować ze strony https://bitbucket.org/pydotnet/pydotnet/wiki/Home." % (os.path.normpath(modulyAplikacji),os.path.normpath(zasob)))
        
#     def kontrolujDotnet(self):
#         u"""Kontroluje wczytanie biblioteki dotnet
#             W razie braku kopiuje z zasobów do apps\\python27\\lib\\site-packages
#         """
#         try: 
#             import dotnet.seamless
#             return True
#         except ImportError:
#           
#             return False
    
#     def kontrolujAdodbapi(self):
#         u"""Kontrola modulu obslugi bazy danych"""
#         try:
#             import adodbapi
#             return True
#         except ImportError:
#             return False      
        
#     def komunikatAdodbapi(self):
#         u""""Komunikat braku modulu Aodbapi"""
#         import sys
#         root=os.path.dirname(__file__)
#         sciezkaAplikacji=sys.executable.split('bin')[0]
#         modulyAplikacji="%sapps\\python3*\\lib\\site-packages" % sciezkaAplikacji 
#         py_architecture = platform.architecture()[0]
#         zasob='%s\moduly\adodbapi' % root
#         komunikaty.blad(u'Brak biblioteki',u"Program wymaga dodatkowej biblioteki 'adodbapi'. Należy zainstalować moduł 'adodbapi' w lokalizacji:\n'%s'.\nMożna go skopiować z katalogu:\n'%s'\nlub zainstalować ze strony https://pypi.org/project/adodbapi/." % (os.path.normpath(modulyAplikacji),os.path.normpath(zasob)))

 
    def pokazPomoc(self):
        u"""Wyswietla pomoc dla użytkownika"""  
        try:
            plik="%s\\pomoc\\pomoc.pdf" % root
            os.startfile(plik)
            
        except Exception:
            komunikaty.blad(u"Brak przeglądarki", u"Proszę zainstalować przeglądarkę plików pdf")
        
        
    def pokazOProgramie(self):
        u"""informacje o programie"""
        self.oProgramie=OProgramieDialog()
        self.oProgramie.show()
        
        
        
        
    def installAcessDrivers(self):
        """Instalacja sterowników acces"""
        #1 Sprawdzenie istnienia sterowników
        list=[]
        for x in pyodbc.drivers():
            if x.startswitch('Microsoft Access Driver'):
                list.append(str(x))
                
        
    