# -*- 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.
"""
from Mapa_PU.kontroler.warstwa import listaFeatureId
from Mapa_PU.widok import nazwa_projektu
#from test.badsyntax_future3 import result

""" Moduł z metodami operacji na mapie"""
#Marcin Śliwa

from PyQt5.QtCore import *

from qgis.core import *
from qgis.gui import *
from Mapa_PU.model.konfiguracja import Projekt
from Mapa_PU.model import warstwy
from Mapa_PU.kontroler import warstwa, komunikaty
from qgis.utils import *

class Mapa:
    """Implementacja operacji na mapie"""
    def __init__(self,plikQgs,iface):
        """Konstruktor"""
        self.__iface=iface
        self.__mapa=iface.mapCanvas()
        self.__plik=plikQgs
        
        self.aplikacja=QgsProject.instance()
        self.clickMapa=None
        warstwa.rozszerzWarstwe()
        
       
    def warstwaZaznaczona(self):
        """Zwraca zaznaczoną warstwę
        :return warstwa zaznaczona
        """
        try:
            return self.__mapa.currentLayer()
      
        except Exception as e:
            raise e
            #komunikaty.blad_systemowy(e)
    
    def warstwa(self,nazwa):
        """Zwraca warstwę z mapy
          warstwa musi byc na mapie aktywna
        :param nazwa: nazwa warstwy
        :return warstwa
        """
        try:
            for warstwa in self.__mapa.layers():
                if warstwa.name()==nazwa:
                    return warstwa
            return None
        except Exception as e:
            raise e
            #komunikaty.blad_systemowy(e)
    
    def warstwa_rejestr(self,nazwa):
        """Zwraca kolekcję warstw z rejestru
        :param nazwa:nazwa warstwy
        :return lista warstw
        """
        lista=QgsProject.instance().mapLayersByName(nazwa)
        if len(lista)==0:
            return None
        return lista
        
    def warstwa_mapa(self,nazwa):
        """Zwraca kolekcje warstw z widoku
        :param nazwa:nazwa warstwy
        :return lista warstw
        """
        try:
            if self.__mapa.layerCount()==0:
                return None
            warstwy=self.__mapa.layers()
            lista=[]
            for warstwa in warstwy:
                if warstwa.name()==nazwa:
                    lista.append(warstwa)
                                        
            return lista
            
        except Exception as e:
            raise e
            #komunikaty.blad_systemowy(e)
        
    
    def warstwyRejestr(self,*nazwa):
        """Zwraca kolekcję warstw z rejestru
        :param nazwa: nazwa warstwy
        :return lista warstw
        """
        try:
          
            lista=[]
            for n in nazwa:
                warstwa=self.warstwaRejestr(n)
                if(warstwa!=None):
                    lista.append(warstwa)
                    
            return lista
        except Exception as e:
            raise e
            #komunikaty.blad_systemowy(e)
    
    def warstwaRejestr(self,nazwa):
        """Zwraca warstwę mapLayer z  QgsProject.instance() pierwszą na liście
        :param nazwa:nazwa warstwy
        :return warstwa
        """
        lista=QgsProject.instance().mapLayersByName(nazwa)
        if len(lista)==0:
            return None
        if lista[0].isValid():
            return QgsProject.instance().mapLayersByName(nazwa)[0]
        else:
            return None
    
    
    def czyWarstwaJestZaznaczona(self,warstwa):
        """Sprawdza czy warstwa jest na mapie
        :param warstwa:obiekt warstwy
        :return True/False
        """
        return (warstwa in self.__mapa.layers())
    
    def czyWarstwaJestWybrana(self,nazwa):
        """Sprawdza czy warstwa jest aktywna
        :param nazwa:nazwa warstwy
        :return True/False
        """
        try:
            warstwa=self.__mapa.currentLayer()
            if warstwa==None:
                return False
            return self.__nazwaWarstwy(warstwa,nazwa)
        except Exception as e:
            raise e
            #komunikaty.blad_systemowy(e)
    
    def czyWarstwaJestwWidoku(self,nazwa):
        """Sprawdza czy warstwa nazwa jest na liscie warstw
        :param nazwa:nazwa warstwy
        :return True/False
        """
        try:
            warstwy=self.__mapa.layers()
            for warstwa in warstwy:
                wynik=self.__nazwaWarstwy(warstwa, nazwa)
                if wynik==True:
                    return True
            return False
        except Exception as e:
            raise e
            #komunikaty.blad_systemowy(e)
    
    def otworzWarstwe(self,nazwa,sciezka):
        """Tworzy obiekt warstwy na podstawie pliku
        :param nazwa: nazwa warstwy
        :param sciezka: scieżka do pliku
        :return warstwa
        """
        try:
            warstwa = QgsVectorLayer(sciezka, nazwa, "ogr")
            if not warstwa.isValid():
                return None
            return warstwa
        except Exception as e:
            raise e
            #komunikaty.blad_systemowy(e) 
                
    def otworzProjekt(self):
        """Otwarcie projektu"""
        try:
            'czyszcenie warstw'
            QgsProject.instance().removeAllMapLayers ()
            self.aplikacja.read(self.__plik)
            self.aplikacja.setTitle(self.__plik)
            self.__iface.mainWindow().setWindowTitle(self.__plik)
            self.__mapa.zoomToFullExtent()

        except Exception as e:
            raise e
            #komunikaty.blad_systemowy(e)
     
    def wyczyscProjekt(self):
        """czyści warstwy z aplkacji""" 
       
        self.aplikacja.clear()
     
    def zapisz(self):
        """Zapisuje projekt qgis"""
        try:
            self.aplikacja.write()
        except Exception in e:
            raise e
            #komunikaty.blad_systemowy(e)
            
            
    def zaladujWarstwy(self,warstwy):
        """Wczytuje warstwy do mapy
        :param nazwa:nazwa warstwy
        """
        QgsProject.instance().addMapLayers(warstwy)
    
    def zaladujWarstwe(self,warstwa):
        """Wczytuje warstwe do mapy
        :param nazwa:nazwa warstwy
        """
        try:
            QgsProject.instance().addMapLayer(warstwa)
        except Exception as e:
            raise e
            #komunikaty.blad_systemowy(e)
        
    def zapiszProjekt(self):
        """Zapisuje projekt .QGS"""
        self.aplikacja.write(self.__plik)
        
    def podlaczMetode(self,metoda,zmianaNarzedzia=None):
        """Podłącza pod mapę metodę canvasClicked
        :param metoda: metoda do wykonania
        :param zmianaNarzędzia:metoda wykonywana w razie zmainy narzędzia na mapie
        """
        try:
            self.clickMapa=QgsMapToolEmitPoint(self.__mapa)
            result=self.clickMapa.canvasClicked.connect(metoda)
            #result = QtCore.QObject.connect(self.clickMapa, SIGNAL("canvasClicked(const QgsPoint &, Qt::MouseButton)"), metoda)
            self.__mapa.setMapTool(self.clickMapa)
            if zmianaNarzedzia!=None:
                self.clickMapa.deactivated.connect(zmianaNarzedzia)
                #QtCore.QObject.connect(self.clickMapa, SIGNAL("deactivated()"), zmianaNarzedzia)
        except Exception as e:
            raise e
            #komunikaty.blad_systemowy(e)
            
    def odlaczMetode(self,metoda,zmianaNarzedzia=None):
        """Odłącza metodę z mapy
        :param metoda: metoda do wykonania
        :param zmianaNarzędzia:metoda wykonywana w razie zmainy narzędzia na mapie
        """
        try:
            if self.clickMapa==None:
                return
            if zmianaNarzedzia!=None:
                self.clickMapa.deactivated.disconnect(zmianaNarzedzia)
                #QObject.disconnect(self.clickMapa, SIGNAL("deactivated()"), zmianaNarzedzia)
            #QObject.disconnect(self.clickMapa, SIGNAL("canvasClicked(const QgsPoint &, Qt::MouseButton)"), metoda)
            self.clickMapa.canvasClicked.disconnect(metoda)
            self.clickMapa=None
            self.__mapa.setCursor(Qt.ArrowCursor)
            
            
        except Exception as e:
            raise e
            #komunikaty.blad_systemowy(e)
        
    def __nazwaWarstwy(self,warstwa,nazwa):
        """Sprawdza czy nazwa warstwy z warstwa==nazwa
        :param warstwa: warstwa
        :param nazwa:nazwa warstwy
        """
        try:
            if warstwa.name()==nazwa:
                return True
            else:
                return False
        except Exception as e:
            raise e
            #komunikaty.blad_systemowy(e)
            
    
    def dodajWarstwe(self, sciezka_do_pliku,nazwa_warstwy="NEW_COPY"):
        """ dodaje warstwe do interfejsu za pomoca addVectorLayer() 
        :param sciezka_do_pliku: scieżka do pliku warstwy
        :param nazwa_warstwy: nazwa warstwy
        """
        try:
            self.__iface.addVectorLayer(sciezka_do_pliku, nazwa_warstwy, "ogr")      
        except Exception as e: 
            raise e
            #komunikaty.blad_systemowy(e)
            
    
    def usunWarstwyMemory(self):
        """ usuwa warstwy typu memory storage z atrybutem shortname = "error_log_mapa_pu" z okna mapy """
        #Michal
        try: 
            [QgsProject.instance().removeMapLayer(lay.id()) for lay in QgsProject.instance().mapLayers().values() if type(lay) is QgsVectorLayer and lay.storageType() == 'Memory storage' and lay.shortName() == "error_log_mapa_pu"]
#             for warstwa in QgsProject.instance().mapLayers().values():
#                 if  warstwa.isValid() and warstwa.storageType() == 'Memory storage' and warstwa.shortName() == "error_log_mapa_pu":
#                     QgsProject.instance().removeMapLayer(warstwa.id())
                    
        except Exception as e: 
            raise e
            #komunikaty.blad_systemowy(e)   

    def odswierzMape(self):
        """Odswierza widok na mapie"""
        try:
            self.__mapa.refreshAllLayers()
        except Exception as e:
            raise e
                