# -*- coding: utf-8 -*-
"""
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.
"""

"""
Mod� konfiguracyjny
"""
from PyQt5.QtGui import *
from PyQt5.QtWidgets import QFileDialog
import os, sys
from Mapa_PU.widok.nazwa_projektu import NazwaProjektuDialog
from Mapa_PU.kontroler import metody_globalne
from Mapa_PU.kontroler import komunikaty
from Mapa_PU.model.baza_danych import Baza
from Mapa_PU.model.warstwy import Warstwy
from Mapa_PU.swdl.model.tags import TagsLayer
import Mapa_PU
import shutil

class Konfiguracja(object):
    """Klasa zawiera sciezki konfiguracyjne dla otwartego projektu"""
    #Marcin Śliwa
    def __init__(self):
        """Konstruktor"""
        self.__sciezka=None
        self.__taksatorPU=None
        self.__warstwy=None
        self.__rastry=None
        self.__plikQgs=None
        self.__plikBazaTaksator=None
        self.__plikBazaKontroli=None
        self.__tmp=None
        self.__kontrole=None
     
    @property
    def katalog(self):
        """Katalog nadrzędny"""
        pass
    
    @katalog.getter
    def katalog(self):
        return ('\\').join(self.sciezka.split("\\")[0:-1])
     
        
    @property
    def sciezka(self):
        """scieżka projektu"""
        return self.__sciezka
    
    @sciezka.setter
    def sciezka(self,wartosc):
        self.__sciezka=wartosc
        
    @sciezka.getter
    def sciezka(self):
        return self.__sciezka
    
    @property
    def taksator(self):
        """Katalofg do bazy taksatora PU"""
        return self.__taksatorPU
    
    @taksator.setter
    def taksator(self,wartosc):
        self.__taksatorPU=wartosc
        
    @taksator.getter
    def taksator(self):
        return self.__taksatorPU
    
    @property
    def warstwy(self):
        """katalog warstw"""
        return self.__warstwy
    
    @warstwy.setter
    def warstwy(self,wartosc):
        self.__warstwy=wartosc
        
    @warstwy.getter
    def warstwy(self):
        return self.__warstwy
    
    @property
    def rastry(self):
        """katalog rastrów"""
        return self.__rastry
    
    @rastry.setter
    def rastry(self,wartosc):
        self.__rastry=wartosc
        
    @rastry.getter
    def rastry(self):
        return self.__rastry
    
    @property
    def plikQgs(self):
        """sciezka do pliku projektu mapy"""
        return u'%s' % self.__plikQgs
    
    @plikQgs.setter
    def plikQgs(self,wartosc):
        self.__plikQgs=wartosc
        
    @plikQgs.getter
    def plikQgs(self):
        return self.__plikQgs
        
    @property
    def plikBazaTaksator(self):
        """sciezka do pliku bazy taksatora"""
        return self.__plikBazaTaksator
    
    @plikBazaTaksator.setter
    def plikBazaTaksator(self,wartosc):
        self.__plikBazaTaksator=wartosc
    
    @plikBazaTaksator.getter
    def plikBazaTaksator(self):
        return self.__plikBazaTaksator
    
    @property
    def tmp(self):
        """katalog tymczasowy"""
        return self.__tmp
    
    @tmp.setter
    def tmp(self,wartosc):
        self.__tmp=wartosc
    
    @tmp.getter
    def tmp(self):
        return self.__tmp
    
    @property
    def kontrole(self):
        """Katalog kontroli"""
        return self.__kontrole
    
    @kontrole.setter
    def kontrole(self,wartosc):
        self.__kontrole=wartosc
    @kontrole.getter
    def kontrole(self):
        return self.__kontrole
    
class Projekt(object):
    """ obiekt projektu """
    #Marcin Śliwa
    listaWarstw=(TagsLayer.SUBAREA_PARCEL.value,TagsLayer.LINES.value,TagsLayer.BASIC_OBJECTS.value,
                        TagsLayer.COUNTY.value,TagsLayer.COUNTY_LABELS.value,TagsLayer.SUBAREA_LABELS.value,
                        TagsLayer.POINT_SINGULARITIES.value,TagsLayer.SURFACE_SINGULARITIES.value,
                        TagsLayer.PNSW.value,TagsLayer.SURFACE.value,TagsLayer.PARCEL_LAND_USE.value)
    
    def __init__(self,iface,katalog):
        """konstruktor"""        
        self.__iface=iface
       
        self.__filtr="Pliki Projektu (*.qgs *.QGS)"
        self.__szablony=katalog+"\\szablony\\"
               
                    
    @property
    def szablony(self):
        """katalog wtyczki z szablonami"""
        return self.__szablony 
    
    @szablony.getter
    def szablony(self):
        return self.__szablony
        
    def zapisz(self):
        """Ustawia sci�k� do katalogu projektu """
        self._sciezka=QFileDialog.getSaveFileName(self.__iface.mainWindow(), 'Zapisz Projekt',None,self.__filtr)
        
    def odczytaj(self):
        """Ustawia ścieżkę do katalogu projektu """
        self._sciezka=QFileDialog.getOpenFileName(self.__iface.mainWindow(),'Wybierz Projekt',None,self.__filtr)
        
    def nowy(self):
        """Przygotowywuje ścieżkę do katalogu projektu"""
        
        try:
            katalog=u''
            self.katalogProjektu=''
            
            #Ustawienie sciezek projektu
            #ustawienie katalogu projektu
            katalog=QFileDialog.getExistingDirectory(self.__iface.mainWindow(),'Wybierz katalog projektu','C:\\')
            if katalog=='':
                return None
            
            
            self.okno=NazwaProjektuDialog(katalog,self.__iface.mainWindow())
            ret=self.okno.exec_()
            if ret==0:
                return None
            nazwaProjektu=self.okno.nazwaProjektu.text()
            sciezka=katalog+'\\'+nazwaProjektu
            konfiguracja=self.__ustaw(sciezka)
            
            return konfiguracja
        except Exception as e:
            komunikaty.blad_systemowy(e)
    
    
    
    def otworz(self):
        """Ustawienie zmiennych dla wczytania projektu"""
        try:
            sciezka=QFileDialog.getExistingDirectory(self.__iface.mainWindow(),'Wybierz katalog projektu','C:\\')
            #Anulowanie wyboru
            if sciezka=='':
                return None
            
            konfiguracja=self.__ustaw(sciezka)
            
            #Kontrola katalogów i pliku QGS
            lista=self.__kontrolujKatalogi(konfiguracja)
            if len(lista)>0:
                 komunikaty.blad(u"Błędna struktura",u'Brak kluczowych elementów (%s) do prawidłowego działania programu.' % ', '.join(lista).strip())    
                 return None
              
             #kontrola warstw w katalogu
            lista=self.__kontroluj_warstwy(konfiguracja.warstwy)
            if len(lista)>0:
                 komunikaty.blad(u"Brak warstw",
                                 u'W katalogu \'WARSTWY\' stwierdzono brak warstwy (%s).\nWskazany projekt nie może zostać otwarty.' % ','.join(lista).strip())    
                 return None
              
            #kontrola pliku bazy
            if metody_globalne.czyJestPlik(konfiguracja.plikBazaTaksator)==False:
                 komunikaty.blad(u'Brak bazy',u'W katalogu \'TaksatorPU\' stwierdzono brak bazy UPUL.MDB.\nWskazany projekt nie może zostać otwarty.')
                 return None
              
            if self.kontrolaBazyTaksator(konfiguracja.plikBazaTaksator)==False:
                 komunikaty.blad(u"Błędna baza",u'W katalogu TaksatorPU znajduje się baza, która nie jest poprawną bazą Taksator PU w wersji %s lub wyższej. Wskazany projekt nie może zostać otwarty.' % Mapa_PU.upul_modul.taksator_PU)
                 return None
            
            #Kontrola katalogów i tworzenie
            self.sprawdzUtworzKatalog(konfiguracja.kontrole)
            
            return konfiguracja
        except Exception as e:
            komunikaty.blad_systemowy(e)
              
    def istniejeKatalogProjektu(self):
        """sprawdza czy �cie�ka projektu jest pusta"""
        return True if self.sciezka=="" else False 
    
    def utworzKatalogi(self,Konfiguracja):
        """Tworzy katalogi w katalogu projektu
        :param Konfiguracja: obiekt konfiguracji
        
        """
        try:
            self.utworzKatalog(Konfiguracja.sciezka)
            self.utworzKatalog(Konfiguracja.taksator)
            self.utworzKatalog(Konfiguracja.warstwy)
            self.utworzKatalog(Konfiguracja.rastry)
            self.utworzKatalog(Konfiguracja.tmp)
            self.utworzKatalog(Konfiguracja.kontrole)
            
        except Exception as e:
            komunikaty.blad_systemowy(e)
    
    def kontrolaBazyTaksator(self,plikTaksatora):
        """Kontroluje bazę taksatora
        :param plikTaksatora: plik bazy taksatora
        :return wynik kontroli
        """
        try:
            baza=Baza(plikTaksatora)
            baza.polaczOdbc()
            #Kontrola bazy taksatora PU
            kontrola=baza.czyIstniejeTabela('V_ADDRESS')
            pola=(baza.czyIstniejePole(u'F_PARAMETER',u'S_OrgName',u'S_Street',u'S_City',u'S_Code',u'S_Country',u'S_Phone',u'S_Fax',u'S_Email'
                                      ,u'DS_OrgName',u'DS_Street',u'DS_City',u'DS_Code',u'DS_Country',u'DS_Phone',u'DS_Fax',u'DS_Email') 
                  and baza.czyIstniejePole('F_ARODES',u'TEMP_RAPORT'))
            
            baza.zamknijPolaczenie()
            return kontrola and pola
        except Exception as e:
            komunikaty.blad_systemowy(e)
    
    def sprawdzUtworzKatalog(self,katalog):
        """Sprawdza istnienie katalogu, jeżeli go nie ma to tworzy
        :params katalog:Katalog do sprawdzenia
        """
        try:
            if not os.path.exists(katalog):
                self.utworzKatalog(katalog)
        except Exception as e:
            raise e
        
    def utworzKatalog(self,katalog):
        """Tworzy katalog
        :params katalog: nazwa katalogu
        """
        try:
            os.mkdir(katalog)
        except Exception as e:
            komunikaty.blad_systemowy(e)

    def przenies_plik(self,file,target_file):
        """Przenosi pliki do katalogu docelowego
        :params file: plik do przeniesienia
        :params target_file:plik docelowy
        """
        try:
            shutil.move(file, target_file)
            
        except Exception as e:
            raise e
            
    def __ustaw(self,sciezka):
        """Ustawia zmienne konfiguracyjne
        :return obiekt konfiguracji
        """
        try:
            
            konfiguracja=Konfiguracja()
            konfiguracja.sciezka=sciezka
            konfiguracja.taksator='%s\\TaksatorPU' % sciezka
            konfiguracja.warstwy='%s\\Warstwy' % sciezka
            konfiguracja.rastry='%s\\Rastry' % sciezka
            konfiguracja.plikQgs='%s\\UPUL.QGS' % sciezka
            konfiguracja.plikBazaTaksator='%s\\TaksatorPU\\UPUL.MDB' % sciezka
            konfiguracja.tmp='%s\\Tmp' % sciezka
            konfiguracja.kontrole='%s\\Kontrole' % sciezka
                          
            return konfiguracja
            
        except Exception as e:
            komunikaty.blad_systemowy(e)
            
    def __kontrolujKatalogi(self,Konfiguracja):
        """Kontroluje istnienie katalogów i pliku projektu
        :param Konfiguracja: obiekt konfiguracji
        :return lista błedów
        """
        try:
            
            lista=[]
            if metody_globalne.czyJestKatalog(Konfiguracja.warstwy)==False:
                lista.append('katalog \'Warstwy\'')
            
            if metody_globalne.czyJestKatalog(Konfiguracja.taksator)==False:
                lista.append('katalog \'TaksatorPU\'')
                      
            
            if metody_globalne.czyJestPlik(Konfiguracja.plikQgs)==False:
                lista.append('projekt \'UPUL.QGS\'')
           
            
            return lista
        except Exception as e:
            komunikaty.blad_systemowy(e)
            
    def __kontroluj_warstwy(self,warstwy):
        """Kontroluje warstwy
        :param warstwy: warstwy do kontroli
        :return lista brakujących warstw
        """
        try:
            braki=[]
            lista=[i.upper() for i in os.listdir(warstwy)]
            
            for warstwa in Projekt.listaWarstw:
                if (warstwa.upper()+'.SHP' in lista)==False:
                    braki.append(' \''+warstwa+'\' ')
            return braki
        except Exception as e:
            komunikaty.blad_systemowy(e)
      
    
            
    