'''
Created on 2 nov 2019

@author: Emanuele Trabattoni
TODO LIST
1. rendere threaded lo splitter.. tentativo colore 100..

'''
import sys
import copy
import json
import os
import platform

from mainwindow import Ui_mainwin
from selezout import Ui_selezout
from titolow import Ui_titolo
from avanzatetitolo3 import Ui_advtitolo3 as Ui_advtitolo
from advopt import Ui_editconf
from about import Ui_about

from libfancylogger import fancyLogger
from libconfload import bananaCONF
from libsplit import bananaSPLITTER

import PyQt5.QtGui
from PyQt5.QtCore import QDir, QSize, QTranslator, pyqtSlot, pyqtSignal
from PyQt5.QtWidgets import QMessageBox, QSizePolicy, QInputDialog

#modo brutto per mettere la lista delle lingue in un posto solo
langlist = ['it', 'en']


class bananaMain(PyQt5.QtWidgets.QMainWindow):
    def __init__(self, logger=None, confloader=None):
        PyQt5.QtWidgets.QMainWindow.__init__(self)
        self.logger = logger
        self.conf = confloader
        # inizializzazione interfaccia
        self.ui = Ui_mainwin()
        self.ui.setupUi(self)
        self.titolo = bananaTitolo(self.conf, self.logger)
        self.titoloav = bananaTitoloAvanzate(self.conf, self.logger)
        self.selezout = bananaSelezOut(self.conf, self.logger)
        self.advopt = bananaAdvOpt(self.conf, self.logger)
        #popola le tab con le finestre giuste
        self.ui.wgt_main.addTab(self.titolo, self.tr("Impostazioni Titolo"))
        self.ui.wgt_main.addTab(self.selezout, self.tr("Selezione Output"))
        # connetti bottoni avanti
        self.ui.btn_avanti.clicked.connect(self.nextTab)
        self.titolo.titoloui.btn_avanti.clicked.connect(self.nextTab)
        #connetti bottoni indietro
        self.titolo.titoloui.btn_indietro.clicked.connect(self.prevTab)
        self.selezout.selezoutui.btn_indietro.clicked.connect(self.prevTab)
        #connetti bottoni selezione cartelle
        self.ui.btn_cartellasorg.clicked.connect(self.selezSorg)
        self.ui.btn_cartelladest.clicked.connect(self.selezDest)
        #connetti action tab
        self.ui.actionLingua.triggered.connect(self.openLanguage)
        self.ui.actionAvanzate.triggered.connect(self.openAdvOpt)
        self.ui.actionCarica_Preset.triggered.connect(self.openLoadPreset)
        self.ui.actionSalva_Preset.triggered.connect(self.openSavePreset)
        self.ui.actionAbout_SPEx.triggered.connect(self.openAbout)
        #connetti i radbutton versione
        self.ui.rad_fileNew.clicked.connect(self.selezVers)
        self.ui.rad_fileOld.clicked.connect(self.selezVers)
        #connetti segnali delle sottointerfacce
        self.advopt.update.connect(self.fillAllInterfaces)
        self.logger.sendLog.connect(self.appendLog)
        #riempi pagine di interfaccia
        self.fillAllInterfaces()
        self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
        self.setFixedSize(QSize(self.conf.getParam(
            'settings', 'winW'), self.conf.getParam('settings', 'winH')))

    def fillInterface(self):
        #pagina principale
        try:
            self.ui.lbl_preset.setText(self.conf.inUse.replace('.json', ''))
            self.ui.lbl_sorg.setText(self.conf.getParam('paths', 'INworkPath'))
            self.ui.lbl_dest.setText(self.conf.getParam('paths', 'OUTworkPath'))
            self.ui.rad_fileNew.setChecked(
                self.conf.getParam('docStruct', 'fileVersNew'))
            self.ui.rad_fileOld.setChecked(
                not self.conf.getParam('docStruct', 'fileVersNew'))
            self.fillFileList()
        except:
            self.log.critical(self.tr("MainWindow: Configurazione non accettata"))

    def fillAllInterfaces(self):
        self.fillInterface()
        self.titolo.fillInterface()
        self.titoloav.fillInterface()
        self.selezout.fillInterface()
        self.advopt.fillInterface()

    def fillFileList(self):
        fl = QDir(self.conf.getParam('paths', 'INworkPath'))
        fl.setNameFilters(['*.txt', '*.TXT'])
        fl = fl.entryList(QDir.NoDotAndDotDot | QDir.Files)
        self.ui.lst_files.clear()
        for f in fl:
            self.ui.lst_files.addItem(PyQt5.QtWidgets.QListWidgetItem(f))
        self.conf.setParam(('paths', 'fileList'), fl)

    def nextTab(self):
        self.ui.wgt_main.setCurrentIndex(self.ui.wgt_main.currentIndex()+1)
        self.logger.debug(self.tr("Prossima Tab"))

    def prevTab(self):
        self.ui.wgt_main.setCurrentIndex(self.ui.wgt_main.currentIndex()-1)
        self.logger.debug(self.tr("Tab Precedente"))

    def openLoadPreset(self):
        self.logger.debug(self.tr("Apri Carica Preset"))
        lf = PyQt5.QtWidgets.QFileDialog(self, self.tr(
            "Carica Preset"), self.conf.getParam('paths', 'configurationPath'))
        lf.setAcceptMode(PyQt5.QtWidgets.QFileDialog.AcceptOpen)
        lf.setFileMode(PyQt5.QtWidgets.QFileDialog.ExistingFile)
        lf.setNameFilter("bananaCONF (*.json)")
        if lf.exec():
            cf = str(lf.selectedFiles()[0].split('/')[-1])
            self.logger.info(self.tr(f"Apro la configurazione: {cf}"))
            self.conf.open()
            self.conf.use(cf)
            self.logger.debug(self.tr("Riempio tutte le tab"))
            self.fillAllInterfaces()

    def openSavePreset(self):
        self.logger.debug(self.tr("Apri Salva Preset"))
        self.applicaTutto()
        sf = PyQt5.QtWidgets.QFileDialog(
            self, "Salva Preset", self.conf.getParam('paths', 'configurationPath'))
        sf.setAcceptMode(PyQt5.QtWidgets.QFileDialog.AcceptSave)
        sf.setNameFilter("bananaCONF (*.json)")
        if sf.exec():
            rv = str(sf.selectedFiles()[0].split('/')[-1])
            self.conf.setParam(('paths', 'lastUsed'), rv)
            #scrivi quale file e' stato usato per ultimo nel default
            prev = self.conf.inUse
            self.conf.use("defaults.json")
            self.conf.setParam(('paths', 'lastUsed'), rv)
            self.conf.save(fName="defaults.json")
            self.conf.use(prev)
            ##
            self.logger.debug(self.tr(f"Scrivo la configurazione: {rv}"))
            self.conf.save(fName=rv)

    def openAdvOpt(self):
        self.logger.debug(self.tr("Apri Opzioni Avanzate"))
        self.advopt.fillInterface()
        self.advopt.show()

    def openLanguage(self):
        global langlist
        self.logger.debug(self.tr("Apri Opzioni Lingua"))
        flag = False
        lang, flag = QInputDialog.getItem(self, self.tr(
            "Lingua"), self.tr("Disponibili"), langlist, 0, False)
        if flag:
            self.conf.setParam(('settings', 'uiLang'), lang)
        else:
            pass

    def openAbout(self):
        self.logger.debug(self.tr("Apri Finestra About"))
        self.spxabt = spexAbout(confloader=self.conf)

    def selezSorg(self):
        rv = PyQt5.QtWidgets.QFileDialog.getExistingDirectory(self, self.tr(
            "Seleziona Cartella Sorgente"), self.conf.getParam('paths', 'INworkPath'))
        if rv != "":
            self.conf.setParam(keys=('paths', 'INworkPath',), val=rv+"/")
            self.ui.lbl_sorg.setText(rv)
            self.logger.info(
                self.tr("Selezionata Cartella Sorgente: {}").format(rv+"/"))
            self.fillFileList()

    def selezDest(self):
        rv = PyQt5.QtWidgets.QFileDialog.getExistingDirectory(self, self.tr(
            "Seleziona Cartella Destinazione"), self.conf.getParam('paths', 'OUTworkPath'))
        if rv != "":
            self.conf.setParam(keys=('paths', 'OUTworkPath',), val=rv+"/")
            self.ui.lbl_dest.setText(rv)
            self.logger.info(
                self.tr("Selezionata Cartella Destinazione: {}").format(rv+"/"))

    def selezVers(self):
        self.conf.setParam(('docStruct', 'fileVersNew'),
                           self.ui.rad_fileNew.isChecked())
        self.logger.debug(self.tr(f"Selezionata Versione File"))

    def openFileDialog(self, name, path):
        self.log.debug(self.tr("Apro in directory: {}").format(path))
        return

    def applicaTutto(self):
        self.titolo.applica()
        self.selezout.applica()

    def appendLog(self, msg):
        self.ui.txt_log.append(msg)

#############################################################
####################### INTERFACES ##########################
#############################################################


class bananaTitolo(PyQt5.QtWidgets.QWidget):
    def __init__(self, confloader=None, logger=None):
        PyQt5.QtWidgets.QWidget.__init__(self)
        self.titoloui = Ui_titolo()
        self.titoloui.setupUi(self)
        self.conf = confloader
        self.log = logger
        if self.conf is not None:
            self.titoloui.btn_avanzate.clicked.connect(self.spawnAvanzate)
            self.titoloui.btn_avanti.clicked.connect(self.applica)
            self.advtitolo = bananaTitoloAvanzate(confloader, self.log)
            self.fillInterface()

    def fillInterface(self):
        try:
            # imposta predefiniti interfaccia da file
            #Data (la piu complicata)
            self.titoloui.chk_data.setChecked(
                self.conf.getParam('docStruct', 'outDate'))
            self.titoloui.rad_datajpn.setChecked(
                self.conf.getParam('docStruct', 'outDateType') == 'jpn')
            self.titoloui.rad_dataita.setChecked(
                self.conf.getParam('docStruct', 'outDateType') == 'it')
            self.titoloui.rad_datausa.setChecked(
                self.conf.getParam('docStruct', 'outDateType') == 'usa')
            #Titolo
            self.titoloui.chk_titolo.setChecked(
                self.conf.getParam('docStruct', 'outTitle'))
            self.titoloui.spn_ncarat.setValue(
                self.conf.getParam('docStruct', 'maxTitleLen'))
            #Numero Documento
            self.titoloui.chk_docnum.setChecked(
                self.conf.getParam('docStruct', 'outNumber'))
            #Separatore
            found = False
            for itmn in range(self.titoloui.lyt_sep.count()):
                itm = self.titoloui.lyt_sep.itemAt(itmn).widget()
                if isinstance(itm, PyQt5.QtWidgets.QRadioButton):
                    if itm.text() == self.conf.getParam('docStruct', 'outNameSep'):
                        itm.setChecked(True)
                        found = True
            if not found:
                self.titoloui.rad_altro.setChecked(True)
            self.titoloui.lin_altro.setText(
                self.conf.getParam('docStruct', 'customSep'))
            #finestra avanzate
            self.advtitolo.fillInterface()
        except:
            self.log.critical(self.tr("Titolo: Configurazione non accettata"))

    def spawnAvanzate(self):
        self.log.debug(self.tr("Mostro la finestra avanzate titolo"))
        self.advtitolo.show()

    def applica(self):
        self.log.info(self.tr("Applico impostazioni Titolo"))
        self.conf.setParam(('docStruct', 'outDate'),
                           self.titoloui.chk_data.isChecked())
        self.conf.setParam(('docStruct', 'outNumber'),
                           self.titoloui.chk_docnum.isChecked())
        self.conf.setParam(('docStruct', 'outTitle'),
                           self.titoloui.chk_titolo.isChecked())
        if self.titoloui.rad_dataita.isChecked():
            self.conf.setParam(('docStruct', 'outDateType'), 'ita')
        elif self.titoloui.rad_datajpn.isChecked():
            self.conf.setParam(('docStruct', 'outDateType'), 'jpn')
        elif self.titoloui.rad_datausa.isChecked():
            self.conf.setParam(('docStruct', 'outDateType'), 'usa')
        self.conf.setParam(('docStruct', 'maxTitleLen'),
                           self.titoloui.spn_ncarat.value())
        self.conf.setParam(('docStruct', 'customSep'),
                           self.titoloui.lin_altro.text())
        for itmn in range(self.titoloui.lyt_sep.count()):
            itm = self.titoloui.lyt_sep.itemAt(itmn).widget()
            if isinstance(itm, PyQt5.QtWidgets.QRadioButton):
                if len(itm.text()) == 1 and itm.isChecked():
                    self.conf.setParam(('docStruct', 'outNameSep'), itm.text())
        self.advtitolo.applica()


class bananaTitoloAvanzate(PyQt5.QtWidgets.QWidget):
    def __init__(self, confloader=None, logger=None):
        PyQt5.QtWidgets.QWidget.__init__(self)
        self.titoloavui = Ui_advtitolo()
        self.titoloavui.setupUi(self)
        self.titoloavui.btn_OK.clicked.connect(self.returnOk)
        self.titoloavui.btn_annulla.clicked.connect(self.returnKo)

        self.titoloavui.rad_dataprimo.clicked.connect(self.gestisciBottoni)
        self.titoloavui.rad_datasecondo.clicked.connect(self.gestisciBottoni)
        self.titoloavui.rad_dataterzo.clicked.connect(self.gestisciBottoni)
        self.titoloavui.rad_numeroprimo.clicked.connect(self.gestisciBottoni)
        self.titoloavui.rad_numerosecondo.clicked.connect(self.gestisciBottoni)
        self.titoloavui.rad_numeroterzo.clicked.connect(self.gestisciBottoni)
        self.titoloavui.rad_titoloprimo.clicked.connect(self.gestisciBottoni)
        self.titoloavui.rad_titolosecondo.clicked.connect(self.gestisciBottoni)
        self.titoloavui.rad_titoloterzo.clicked.connect(self.gestisciBottoni)
        self.conf = confloader
        self.log = logger
        self.fillInterface()

    def fillInterface(self):
        try:
            #rimepi interfaccia
            self.titoloavui.rad_dataprimo.setChecked(
                self.conf.getParam('docStruct', 'datePos') == 1)
            self.titoloavui.rad_datasecondo.setChecked(
                self.conf.getParam('docStruct', 'datePos') == 2)
            self.titoloavui.rad_dataterzo.setChecked(
                self.conf.getParam('docStruct', 'datePos') == 3)
            self.titoloavui.rad_titoloprimo.setChecked(
                self.conf.getParam('docStruct', 'titlePos') == 1)
            self.titoloavui.rad_titolosecondo.setChecked(
                self.conf.getParam('docStruct', 'titlePos') == 2)
            self.titoloavui.rad_titoloterzo.setChecked(
                self.conf.getParam('docStruct', 'titlePos') == 3)
            self.titoloavui.rad_numeroprimo.setChecked(
                self.conf.getParam('docStruct', 'numberPos') == 1)
            self.titoloavui.rad_numerosecondo.setChecked(
                self.conf.getParam('docStruct', 'numberPos') == 2)
            self.titoloavui.rad_numeroterzo.setChecked(
                self.conf.getParam('docStruct', 'numberPos') == 3)
            self.titoloavui.txt_prefisso.setText(
                self.conf.getParam('docStruct', 'outPrefix'))
            self.titoloavui.txt_suffisso.setText(
                self.conf.getParam('docStruct', 'outSuffix'))
        except:
            self.log.critical(self.tr("AvanzateTitolo: Configurazione non accettata"))

    def gestisciBottoni(self):
        #PRIMO
        if self.titoloavui.rad_numeroprimo.isChecked():
            self.titoloavui.rad_dataprimo.setChecked(False)
            self.titoloavui.rad_titoloprimo.setChecked(False)
            self.titoloavui.rad_numerosecondo.setChecked(False)
            self.titoloavui.rad_numeroterzo.setChecked(False)
        if self.titoloavui.rad_dataprimo.isChecked():
            self.titoloavui.rad_numeroprimo.setChecked(False)
            self.titoloavui.rad_titoloprimo.setChecked(False)
            self.titoloavui.rad_datasecondo.setChecked(False)
            self.titoloavui.rad_dataterzo.setChecked(False)
        if self.titoloavui.rad_titoloprimo.isChecked():
            self.titoloavui.rad_numeroprimo.setChecked(False)
            self.titoloavui.rad_dataprimo.setChecked(False)
            self.titoloavui.rad_titolosecondo.setChecked(False)
            self.titoloavui.rad_titoloterzo.setChecked(False)
        #secondo
        if self.titoloavui.rad_numerosecondo.isChecked():
            self.titoloavui.rad_datasecondo.setChecked(False)
            self.titoloavui.rad_titolosecondo.setChecked(False)
            self.titoloavui.rad_numeroprimo.setChecked(False)
            self.titoloavui.rad_numeroterzo.setChecked(False)
        if self.titoloavui.rad_datasecondo.isChecked():
            self.titoloavui.rad_numerosecondo.setChecked(False)
            self.titoloavui.rad_titolosecondo.setChecked(False)
            self.titoloavui.rad_dataprimo.setChecked(False)
            self.titoloavui.rad_dataterzo.setChecked(False)
        if self.titoloavui.rad_titolosecondo.isChecked():
            self.titoloavui.rad_numerosecondo.setChecked(False)
            self.titoloavui.rad_datasecondo.setChecked(False)
            self.titoloavui.rad_titoloprimo.setChecked(False)
            self.titoloavui.rad_titoloterzo.setChecked(False)
        #terzo
        if self.titoloavui.rad_numeroterzo.isChecked():
            self.titoloavui.rad_dataterzo.setChecked(False)
            self.titoloavui.rad_titoloterzo.setChecked(False)
            self.titoloavui.rad_numeroprimo.setChecked(False)
            self.titoloavui.rad_numerosecondo.setChecked(False)
        if self.titoloavui.rad_dataterzo.isChecked():
            self.titoloavui.rad_numeroterzo.setChecked(False)
            self.titoloavui.rad_titoloterzo.setChecked(False)
            self.titoloavui.rad_dataprimo.setChecked(False)
            self.titoloavui.rad_datasecondo.setChecked(False)
        if self.titoloavui.rad_titoloterzo.isChecked():
            self.titoloavui.rad_numeroterzo.setChecked(False)
            self.titoloavui.rad_dataterzo.setChecked(False)
            self.titoloavui.rad_titoloprimo.setChecked(False)
            self.titoloavui.rad_titolosecondo.setChecked(False)

    def returnOk(self):
        self.log.info(self.tr("Avanzate Titolo Accettate"))
        self.applica()
        self.hide()

    def returnKo(self):
        self.log.info(self.tr("Avanzate Titolo Rifiutate"))
        self.hide()

    def applica(self):
        #data
        if self.titoloavui.rad_dataprimo.isChecked():
            self.conf.setParam(('docStruct', 'datePos'), 1)
        elif self.titoloavui.rad_datasecondo.isChecked():
            self.conf.setParam(('docStruct', 'datePos'), 2)
        elif self.titoloavui.rad_dataterzo.isChecked():
            self.conf.setParam(('docStruct', 'datePos'), 3)
        else:
            self.conf.setParam(('docStruct', 'datePos'), -1)
        #numero
        if self.titoloavui.rad_numeroprimo.isChecked():
            self.conf.setParam(('docStruct', 'numberPos'), 1)
        elif self.titoloavui.rad_numerosecondo.isChecked():
            self.conf.setParam(('docStruct', 'numberPos'), 2)
        elif self.titoloavui.rad_numeroterzo.isChecked():
            self.conf.setParam(('docStruct', 'numberPos'), 3)
        else:
            self.conf.setParam(('docStruct', 'numberPos'), -1)
        #titolo
        if self.titoloavui.rad_titoloprimo.isChecked():
            self.conf.setParam(('docStruct', 'titlePos'), 1)
        elif self.titoloavui.rad_titolosecondo.isChecked():
            self.conf.setParam(('docStruct', 'titlePos'), 2)
        elif self.titoloavui.rad_titoloterzo.isChecked():
            self.conf.setParam(('docStruct', 'titlePos'), 3)
        else:
            self.conf.setParam(('docStruct', 'titlePos'), -1)
        #prefisso e suffisso
        self.conf.setParam(('docStruct', 'outPrefix'),
                           self.titoloavui.txt_prefisso.text())
        self.conf.setParam(('docStruct', 'outSuffix'),
                           self.titoloavui.txt_suffisso.text())


class bananaSelezOut(PyQt5.QtWidgets.QWidget):
    def __init__(self, confloader=None, logger=None):
        PyQt5.QtWidgets.QWidget.__init__(self)
        self.selezoutui = Ui_selezout()
        self.selezoutui.setupUi(self)
        self.conf = confloader
        self.log = logger
        if self.conf is not None:
            self.selezoutui.btn_split.clicked.connect(self.applica)
            self.selezoutui.btn_split.clicked.connect(self.splitta)
            self.fillInterface()

    def fillInterface(self):
        try:
            self.selezoutui.cmb_lingua.clear()
            self.selezoutui.cmb_lingua.addItems(
                self.conf.settingsList['languageconf.json'].keys())
            self.selezoutui.cmb_lingua.setCurrentIndex(
                self.conf.getParam('docStruct', 'languageIdx'))
            self.selezoutui.rad_mainbodyEFile.setChecked(self.conf.getParam(
                'settings', 'saveBodyFile') and self.conf.getParam('settings', 'saveSeparateFiles'))
            self.selezoutui.rad_file.setChecked(self.conf.getParam(
                'settings', 'saveSeparateFiles') and not self.conf.getParam('settings', 'saveBodyFile'))
            self.selezoutui.rad_mainbody.setChecked(self.conf.getParam(
                'settings', 'saveBodyFile') and not self.conf.getParam('settings', 'saveSeparateFiles'))
            self.selezoutui.chk_removeDuplicates.setChecked(
                self.conf.getParam('settings', 'removeDuplicates'))
            self.selezoutui.chk_includeTitle.setChecked(
                self.conf.getParam('settings', 'includeTitle'))
            self.selezoutui.chk_removeBreakWord.setChecked(
                self.conf.getParam('settings', 'delWordBreak'))
            self.selezoutui.chk_cleaDestFolder.setChecked(
                self.conf.getParam('settings', 'removeOldFiles'))
            self.selezoutui.lin_specialChars.setText(
                ''.join(self.conf.getParam('settings', 'delChars')))
        except:
            self.log.critical(self.tr("SelezUscita: Configurazione non accettata"))

    def applica(self):
        self.log.info(self.tr("Applico Impostazioni File Uscita"))
        self.conf.setParam(('docStruct', 'language'),
                           self.selezoutui.cmb_lingua.currentText())
        self.conf.setParam(('docStruct', 'languageIdx'),
                           self.selezoutui.cmb_lingua.currentIndex())
        self.conf.setParam(('settings', 'saveBodyFile'), self.selezoutui.rad_mainbody.isChecked()
                     | self.selezoutui.rad_mainbodyEFile.isChecked())
        self.conf.setParam(('settings', 'saveSeparateFiles'), self.selezoutui.rad_file.isChecked()
                     | self.selezoutui.rad_mainbodyEFile.isChecked())
        self.conf.setParam(('settings', 'removeDuplicates'),
                           self.selezoutui.chk_removeDuplicates.isChecked())
        self.conf.setParam(('settings', 'includeTitle'),
                           self.selezoutui.chk_removeDuplicates.isChecked())
        self.conf.setParam(('settings', 'delWordBreak'),
                           self.selezoutui.chk_removeBreakWord.isChecked())
        self.conf.setParam(('settings', 'removeOldFiles'),
                           self.selezoutui.chk_cleaDestFolder.isChecked())
        self.conf.setParam(('settings', 'delChars'), list(
            self.selezoutui.lin_specialChars.text()))

    def splitta(self):
        # costruisco il dizionario di configurazione
        prefile = self.conf.inUse
        splconf = copy.deepcopy(self.conf.dump())
        lang = copy.deepcopy(self.conf.use(
            'languageconf.json').getParam(splconf['docStruct']['language']))
        splconf['docStruct']['language'] = lang
        self.conf.use(prefile)

        #formato nome in uscita
        nametemp = []
        for i in range(1, 4):
            if i == splconf['docStruct']['numberPos'] and splconf['docStruct']['outNumber']:
                nametemp.append("{docnum}")
            if i == splconf['docStruct']['datePos'] and splconf['docStruct']['outDate']:
                nametemp.append(splconf['docStruct']['dateFormats']
                                [splconf['docStruct']['outDateType']])
            if i == splconf['docStruct']['titlePos'] and splconf['docStruct']['outTitle']:
                nametemp.append("{title}")
            pass
        if splconf['docStruct']['outPrefix'] != '':
            # inserisco prefisso e suffisso
            nametemp.insert(0, splconf['docStruct']['outPrefix'])
        if splconf['docStruct']['outSuffix'] != '':
            nametemp.append(splconf['docStruct']['outSuffix'])
        #unisco i pezzi
        splconf['docStruct']['outNameFormat'] = splconf['docStruct']['outNameSep'].join(
            nametemp)+splconf['docStruct']['outExt']

        #costruisco messageBox
        msgb = QMessageBox(parent=self, icon=QMessageBox.Warning,
                           text=self.tr("Sto SPLITTANDO, attendi.."))
        msgb.setWindowTitle(self.tr("Sto Splittando.."))
        msgb.show()

        @pyqtSlot()
        def updateState(msg):
            msgb.setText(msg)
        # costruisco i thread

        tDict = {}
        try:
            for f in splconf['paths']['fileList']:
                splconf['name'] = f
                tDict[f] = bananaSPLITTER(
                    fileParams=copy.deepcopy(splconf), logger=self.log)
                tDict[f].sendStatus.connect(updateState)
                tDict[f].run()
                #QThreadPool.globalInstance().start(tDict[f])
        except Exception as e:
            self.log.error(self.tr(f"Impossibile avviare lo splitter: {e}"))

        msgb.setText(self.tr("FINITO!"))


class bananaAdvOpt(PyQt5.QtWidgets.QWidget):

    update = pyqtSignal()

    def __init__(self, confloader=None, logger=None):
        PyQt5.QtWidgets.QWidget.__init__(self)
        self.advoptui = Ui_editconf()
        self.advoptui.setupUi(self)
        self.conf = confloader
        self.log = logger
        self.errmsg = None
        if self.conf is not None:
            self.advoptui.btn_ok.clicked.connect(self.accetta)
            self.advoptui.btn_cancel.clicked.connect(self.rifiuta)
            self.fillInterface()

    def fillInterface(self):
        try:
            self.advoptui.txt_confFile.setPlainText(
                json.dumps(self.conf.dump(), indent=2))
        except:
            self.log.critical(self.tr("AdvancedOptions: Configurazione non accettata"))

    def accetta(self):
        self.errmsg = QMessageBox()
        self.errmsg.setModal(True)
        self.errmsg.setWindowTitle(self.tr("Avanzate Globali"))
        icon = PyQt5.QtGui.QIcon()
        icon.addPixmap(PyQt5.QtGui.QPixmap(":/icons/icons8-smartphone-ram-100.png"),
                       PyQt5.QtGui.QIcon.Normal, PyQt5.QtGui.QIcon.Off)
        self.errmsg.setWindowIcon(icon)
        try:
            self.conf.loads(self.advoptui.txt_confFile.toPlainText())
            self.log.info(
                self.tr("Parametri inseriti validi, configurazione accettata"))
            self.errmsg.setIcon(QMessageBox.Information)
            self.errmsg.setText(
                self.tr("Parametri inseriti validi, configurazione accettata"))
            self.errmsg.show()
            self.update.emit()
            self.hide()
        except Exception as e:
            self.log.error(self.tr(f"Errore nei parametri! {e}"))
            self.errmsg.setIcon(QMessageBox.Critical)
            self.errmsg.setText(self.tr(f"Errore nei parametri!\n{e}"))
            self.errmsg.show()

    def rifiuta(self):
        self.log.info(f"AdvancedOptions: Configurazione Rifiutata")
        self.hide()


class bananaSplitterInterface(PyQt5.QtWidgets.QWidget):
    def __init__(self, confloader=None, logger=None):
        PyQt5.QtWidgets.QWidget.__init__(self)
        pass


class spexAbout(PyQt5.QtWidgets.QDialog):
    def __init__(self, confloader=None, logger=None):
        PyQt5.QtWidgets.QDialog.__init__(self)
        self.abt = Ui_about()
        self.abt.setupUi(self)
        self.abt.lbl_info.setText(self.abt.lbl_info.text().replace(
            '{ver}', confloader.getParam('version')))
        self.show()
#############################################################
####################### MAIN ################################
#############################################################


def except_hook(cls, exception, traceback):
    sys.__excepthook__(cls, exception, traceback)


if __name__ == '__main__':
    app = PyQt5.QtWidgets.QApplication(sys.argv)
    sys.excepthook = except_hook

    try:
        #print(f"Running directory {os.environ['WORKSPACELOC']}")
        #print(f"Pythonpath: {os.environ['PYTHONPATH']}")
        if platform.system() == 'Darwin':
            basePath = '/'+'/'.join(sys.executable.split('/')[1:-2])+'/Resources'
        else:
            basePath = './'
        LOGGER = fancyLogger(filepath=f"{basePath}/conf/loggerconf.json", fileLog=False)
        conf = bananaCONF(workdir=f"{basePath}/conf", logger=LOGGER)
        conf.open()
        conf.use("defaults.json")
        conf.use(conf.getParam('paths', 'lastUsed'))

        iflan = conf.getParam('settings', 'uiLang')
        trlist = [f":/tr/translations/guimain_{iflan}.qm",
                    f":/tr/translations/libconfload_{iflan}.qm",
                    f":/tr/translations/libsplit_{iflan}.qm",
                    f":/tr/translations/mainwindow_{iflan}.qm",
                    f":/tr/translations/avanzatetitolo3_{iflan}.qm",
                    f":/tr/translations/titolow_{iflan}.qm",
                    f":/tr/translations/selezout_{iflan}.qm",
                    f":/tr/translations/about_{iflan}.qm"]
        qtrlist = []

        if iflan != 'it':
            LOGGER.debug("Carico Traduzioni: ")
            for tr in trlist:
                qtr = QTranslator()
                print(qtr.load(tr), f" {tr}")
                app.installTranslator(qtr)
                qtrlist.append(qtr)

    except Exception as e:
        print(f"Errore main: {e}")
        sys.exit()

    window = bananaMain(logger=LOGGER, confloader=conf)
    window.show()
    rv = app.exec()
    print("ExitCode: {}".format(rv))
    sys.exit(rv)
