__copyright__ = "Copyright 2021, 3Liz"
__license__ = "GPL version 3"
__email__ = "info@3liz.org"


from qgis.core import QgsApplication
from qgis.PyQt.QtCore import Qt, QUrl, QSettings
from qgis.PyQt.QtGui import QDesktopServices, QIcon
from qgis.PyQt.QtWidgets import QAction
from qgis.utils import iface
import qgis

# include <QSettings>
'''
from pg_metadata.connection_manager import (
    store_connections,
    validate_connections_names,
)


from pg_metadata.locator import LocatorFilter
from pg_metadata.processing.provider import PgMetadataProvider
from pg_metadata.qgis_plugin_tools.tools.custom_logging import setup_logger
'''
import os
from .about_form import MetabaseAboutDialog
from .tools.resources import (
    # plugin_path,
    pyperclip,
    resources_path,
    maj_verif,
)
pyperclip()

try:
    from .dock import CenRa_Metabase
    from .editor import Metabase_Editor
except NameError:
    print('404')

# from CenRa_Metabase.issues import CenRa_Issues


class PgMetadata:
    def __init__(self):
        """ Constructor. """
        self.dock = None
        self.editor = None
#        self.issues = None
        self.provider = None
        self.locator_filter = None
        self.dock_action = None
        self.help_action = None
        plugin_dir = os.path.dirname(__file__)
        end_find = plugin_dir.rfind('\\') + 1
        global NAME
        NAME = plugin_dir[end_find:]
        maj_verif(NAME)

        # Display About window on first use
        version = qgis.utils.pluginMetadata('CenRa_METABASE', 'version')
        s = QSettings()
        versionUse = s.value("metadata/version", 1, type=str)
        if str(versionUse) != str(version):
            s.setValue("metadata/version", str(version))
            print(versionUse, version)
            self.open_about_dialog()
#        setup_logger('pg_metadata')

        # locale, file_path = setup_translation(
        #    folder=plugin_path("i18n"), file_pattern="CenRa_Metabase_{}.qm")
        # if file_path:
        #    self.translator = QTranslator()
        #    self.translator.load(file_path)
            # noinspection PyCallByClass,PyArgumentList
        #    QCoreApplication.installTranslator(self.translator)

    # noinspection PyPep8Naming
    # def initProcessing(self):
        # """ Add the QGIS Processing provider. """
        # if not self.provider:
            # self.provider = PgMetadataProvider()
            # QgsApplication.processingRegistry().addProvider(self.provider)

    # noinspection PyPep8Naming
    def initGui(self):
        """ Build the plugin GUI. """
        # self.initProcessing()

        # self.check_invalid_connection_names()

        self.toolBar = iface.addToolBar("CenRa_Metabase")
        self.toolBar.setObjectName("CenRa_Metabase")

        icon = QIcon(resources_path('icons', 'icon.png'))
        icon2 = QIcon(resources_path('icons', 'icon_2.png'))

        # Open the online help
        self.help_action = QAction(icon, 'CenRa_Metabase', iface.mainWindow())
        iface.pluginHelpMenu().addAction(self.help_action)
        self.help_action.triggered.connect(self.open_help)
        if not self.editor:
            self.editor = Metabase_Editor()

            self.editor_action = QAction(icon2, 'CenRa_Metabase', None)
            self.toolBar.addAction(self.editor_action)
            self.editor_action.triggered.connect(self.open_editor)

        if not self.dock:
            self.dock = CenRa_Metabase()
            iface.addDockWidget(Qt.DockWidgetArea(0x2), self.dock)

            # Open/close the dock from plugin menu
            self.dock_action = QAction(icon, 'CenRa_Metabase', iface.mainWindow())
            iface.pluginMenu().addAction(self.dock_action)
            self.dock_action.triggered.connect(self.open_dock)
#        if not self.issues:
#            self.issues = CenRa_Issues()


#            self.issues_action = QAction(icon, 'CenRa_Metabase',None)
#            self.toolBar.addAction(self.issues_action)
#            self.issues_action.triggered.connect(self.open_issues)
    '''
        if not self.locator_filter:
            self.locator_filter = LocatorFilter(iface)
            iface.registerLocatorFilter(self.locator_filter)

    @staticmethod
    def check_invalid_connection_names():
        """ Check for invalid connection names in the QgsSettings. """
        valid, invalid = validate_connections_names()
        n_invalid = len(invalid)

        if n_invalid == 0:
            return

        invalid_text = ', '.join(invalid)
        msg = QMessageBox()
        msg.setIcon(QMessageBox.Warning)
        msg.setWindowTitle(tr('PgMetadata: Database connection(s) not available'))
        msg.setText(tr(
            f'{n_invalid} connection(s) listed in PgMetadata’s settings are invalid or '
            f'no longer available: {invalid_text}'))
        msg.setInformativeText(tr(
            'Do you want to remove these connection(s) from the PgMetadata settings? '
            '(You can also do this later with the “Set Connections” tool.)'))
        msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
        clicked = msg.exec()

        if clicked == QMessageBox.Yes:
            iface.messageBar().pushSuccess('PgMetadata', tr(f'{n_invalid} invalid connection(s) removed.'))
            store_connections(valid)
        if clicked == QMessageBox.No:
            iface.messageBar().pushInfo('PgMetadata', tr(f'Keeping {n_invalid} invalid connections.'))
    '''
    def open_about_dialog(self):
        """
        About dialog
        """
        dialog = MetabaseAboutDialog(iface)
        dialog.exec()

    def open_help():
        """ Open the online help. """
        QDesktopServices.openUrl(QUrl('https://plateformesig.cenra-outils.org/'))

    def open_dock(self):
        """ Open the dock. """
        self.dock.show()
        self.dock.raise_()

    def open_editor(self):
        self.editor.show()
        self.editor.raise_()

#    def open_issues(self):
#        self.issues.show()
#        self.issues.raise_()

    def unload(self):
        """ Unload the plugin. """
        # if self.editor:
        # iface.removePluginMenu('CenRa_Metabase',self.editor_action)
        # self.editor.removeToolBarIcon(self.editor_action)

        if self.dock:
            iface.removeDockWidget(self.dock)
            self.dock.deleteLater()

        if self.provider:
            QgsApplication.processingRegistry().removeProvider(self.provider)
            del self.provider

        if self.locator_filter:
            iface.deregisterLocatorFilter(self.locator_filter)
            del self.locator_filter

        if self.help_action:
            iface.pluginHelpMenu().removeAction(self.help_action)
            del self.help_action

        if self.dock_action:
            iface.pluginMenu().removeAction(self.dock_action)
            del self.dock_action

    @staticmethod
    def run_tests(pattern='test_*.py', package=None):
        """Run the test inside QGIS."""
        try:
            from pathlib import Path

            from pg_metadata.qgis_plugin_tools.infrastructure.test_runner import (
                test_package,
            )
            if package is None:
                package = '{}.__init__'.format(Path(__file__).parent.name)
            test_package(package, pattern)
        except (AttributeError, ModuleNotFoundError):
            message = 'Could not load tests. Are you using a production package?'
            print(message) # NOQA
