import  os
"""
Contains the logic for the MVC of CreoMigrate Gui
"""
# Infos und Fehlermeldungen die ausgelöst werden können
messages = { 
          "rüstcode_infos": 'Bitte Rüstcode auswählen!',
          "beschaffungsart_infos": ' Komponenten der Schweißbaugruppe müssen eigene Teilenummern erhalten, falls diese aktuell als Underline-Nummern in der Creo-Baugruppe vorliegen, aber keine eigenen Teilenummern in SIVAS besitzen!',
          "mengeneinheit_infos":'Bitte prüfen, ob Mengeneinheit ≠ "M - Meter" korrekt ist!',
          "material_infos":'Werkstoffvorschlag nicht möglich, da das Material nicht in der Mappingdatei "Materialübersetzung.json" enthalten ist.\nBitte Werkstoff in dieser Datei nachfpflegen und prüfen, ob der Werkstoff in den nachfolgenden Systemen vorhanden ist:\n- RuleDesigner\n- SIVAS-Produktiv- und Schulungsdatenbank\n- Solid Edge\nWenn nicht, bitte in diesen Systemen ebenfalls nachpflegen!',
          "unzulaessige_zeichen":'Unzulässige Zeichen identifiziert:\nZeichen:   {Zeichentyp}   -> Feld: {Feldname}',
          "bezeichnung_zu_gross":'Bezeichnung besitzt mehr als 50 Zeichen. Bitte verkürzen!',
          "konflikt_ruestcode_saegeliste":'In Sivas prüfen, wieso Haken bei "Halbzeug ohne Sägeliste" trotz Rüstcode "SRC Standard Rüstcode" gesetzt ist.',
          "teilenummre_ohne_ruestcode":'Teilenummer darf nicht ohne Rüstcode migriert werden!',
          "fertigungsart":'Fertigungsart falsch. Bitte berichtigen!',
          "fos_gruppe":'FOS-Gruppe falsch. Bitte berichtigen!',
          "kalkulations_art":'Kalkulationsart falsch. Bitte berichtigen!',
          "beschaffungsart":'Beschaffungsart falsch. Bitte berichtigen!',
          "mengeneinheit":'Mengeneinheit falsch. Bitte berichtigen!',
          "teilenummer_halbzeug":'Teilenummer kann kein Halbzeug sein. Bitte berichtigen!',
          "tos_gruppe_not_exist":'TOS-Gruppe exisitert nicht. Bitte eingetragene Gruppennummer korrigieren oder ergänzen!',
          "dispo_not_exist":'Datensatz kann nicht ohne Dispogruppe migriert werden. Bitte nachpflegen!',
          "dispolauf_not_exist":'Datensatz kann nicht ohne Dispolaufgruppe migriert werden. Bitte nachpflegen!',
          "teilenummer_not_exist_infos":'Ersetzte Teilenummer {Ersetzte Teilenummer} exisitert noch nicht in RuleDesigner. Migration trotzdem durchführen?',
          "ersatzteilenummer_not_exist_infos":'Ersatz-Teilenummer {Ersatz-Teilenummer} exisitert noch nicht in RuleDesigner. Migration trotzdem durchführen?',
          "werkstofftyp_not_exist":'Eingetragener Werkstofftyp exisitert nicht. Bitte korrigeren!',
          "werkstoff_not_exist":'Werkstoff falsch. Bitte korrigieren!',
          "color_not_defined":'Teilenummer kann nicht ohne festgelegte Farbe migriert werden!',
          "aenderungstext_too_long":'Änderungstext_weist zu viele Zeichen auf. Bitte auf 400 Zeichen verkürzen!',
          }


class Controller():
    """
    Class for manipulating the model and returning data for the view
    """
    def __init__(self, model, view):
        self.set_model(model)
        self.set_view(view)
        self.logic = None
        self.env = None

    def set_env(self, env):
        self.environment = env

    def get_env(self, env_path):
        if self.environment == None:
            raise Exception("No environment set")
        if env_path == "lib":
            ret = self.environment.lib_dir
        elif env_path == "data":
            ret = self.environment.data_dir
        elif env_path == "out":
            ret = self.environment.out_dir
        elif env_path == "cfg":
            ret = self.environment.cfg_dir
        else:
            raise Exception("this path is not defined  "+env_path)
        return ret

    def add_logic(self, logic):
        self.logic = logic
    def remove_logic(self):
        self.logic = None

    def set_model(self, model):
        self.model = model
    def set_view(self, view):
        self.view = view

    def refresh_gui(self):
        self.view.data_from_model()
    def data_from_model(self):
        self.view.data_from_model()

    def get_current_asm_id(self):
        self.model.get_current_asm_id()
    def set_current_asm_id(self, asm_id):
        self.model.set_current_asm_id(asm_id)

    
    def set_current_item_id(self, cid):
        """setze eine neue Item ID """
        # check before. change to given item just in case it is valid, e.g. name is a number of 9 digits
        if not cid.isnumeric():
            return 

        # TODO save current given data. In case, ask whether you should save or drop
        self.set_gui_data('teilenummer', cid)

        # falls eine .json Datei davon existiert, dann diese zuerst versuchen zu laden
        #self.model.load(demo_data)
        gui_dict = None
        loaded_json = self.model.sivas_data_from_json(cid)
        if loaded_json:
            # falls eine .json Datei dieser ID existiert, dann diese laden
            gui_dict = self.logic.csv2guidata(loaded_csv)
        else:
            # ansonsten die .csv Datei mit den SIVAS Infos holen
            # TODO
            loaded_csv = self.model.sivas_data_from_csv(cid)
            if loaded_csv:
                # und dann diese laden
                gui_dict = self.logic.csv2guidata(loaded_csv)
        if not gui_dict:
            print("no file found "+ cid)
        else:
            self.model.set_gui_dict(gui_dict)
            self.refresh_gui()
   
    def get_current_item_id(self):
        return self.get_gui_data('teilenummer')


    def set_red_ids(self, red_ids):
        self.model.set_red_ids(red_ids)
    def get_red_ids(self):
        return self.model.get_red_ids()

    def set_parent_children(self, parent_children_mapping):
        self.model.set_parent_children(parent_children_mapping)
    def get_parent_children(self):
        return self.model.get_parent_children()

    # merkt sich die reinen Daten zum Impfen
    def set_data_dict(self, data:dict):
        """merken der Daten zum Impfen"""
        for k,v in data:
            self.set_data(k,v)
    def set_data(self, key, value):
        """merken der Daten zum Impfen"""
        self.model.set_data(key, value)

    def get_data(self, key):
        return self.model.get_data(key)
    def get_all_data(self):
        return self.model.get_all_data()

    # merkt sich die Nutzereingaben, bzw. Daten für die GUI
    def set_gui_dict(self, data:dict):
        """merken der Eingaben des Nutzers der GUI """
        for k,v in data.items():
            self.set_gui_data(k,v)
    def set_gui_data(self, key, value):
        """merken der Eingaben des Nutzers der GUI """
        self.model.set_gui_data(key, value)

    def get_gui_data(self, key):
        return self.model.get_gui_data(key)
    def get_all_gui_data(self):
        return self.model.get_all_gui_data()

    def callback(self, key, value):
        if not self.logic:
            return 

        # Logik um neue Werte in Oberfläche oder Modell zu füllen
        model_values = self.logic.callback(key, value)
        if model_values:
            self.set_gui_dict(model_values)
            self.refresh_gui()
             
        # reine Aktionen
        if key == 'cb_speichern':
            self.save_to_file()
        elif key == 'cb_migrieren':
            pass
        elif key == 'cb_zurücksetzen':
            pass
        elif key == 'cb_suche_asm':
            pass
    
    def save_to_file(self):
        """speichert die bisherigen Eingaben beider Spalten in eine json Datei"""
        path = os.path.join(self.get_env("out"), str(self.get_current_item_id()) + '.json')
        # die Bauminfos und RedIds dazu werden standardmässig nicht mit gemerkt. 
        self.model.save(path, False)

class GuiLogic():
    """
    Class for business logic. implementing the dependencies between different user inputs
    """
    def __init__(self, model, configs):
        # das Modell soll hier nur verwendet werden um aktuell Zustände abzufragen!
        # alles weitere zum Setzen von Daten etc. muss über den Controller laufen, also zurück gegeben werden. 
        self.model = model 
        # hier holt man die Daten der Configs
        self.config = configs
        # hier sind alle Callbacks bzw. deren Comboboxen 

        # dies sind die Excel Headel der SIVAS csv Export Datei
        # und wie diese in das Datenmodell der Gui integriert werden kann
        self.excel_to_gui = {
            "Teilenummer":"teilenummer",  
            "Bezeichnung1":"bezeichnung1_sivas",
            "Bezeichnung2":"bezeichnung2_sivas", 
            "Beschaffungsart":"beschaffungsart_sivas",
            "Mengeneinheit":"mengeneinheit_sivas",
            "Halbzeug":"halbzeug_sivas",
            "TOS_Gruppe":"tosgruppe_sivas",
            "Dispogruppe":"dispolaufgruppe_sivas",
            "Dispolaufgruppe":"dispolaufgruppe_sivas",
            "ErsatzFuer":"ersatzfuer_neu",
            "ErsetztDurch":"ersetztdurch_neu",
            "AktuellerIndex":"aenderungsindex_sivas",
            "Hersteller":"hersteller_sivas",
            "HerstellerTeilenummer":"herstteilenr_sivas",
            "Version":"version_sivas",
            "HalbzeugExtern":"halbzeug_sivas",
            "Werkstoff":"werkstofftyp_sivas",
            "Oberfläche":"cb_oberflaeche_neu",
            # "Truemmer":"truemmer",
            # "HzOhneSaegeliste":"",
            "Ruestcode":"ruestcode_sivas",
            "Fertigungsart":"fertigungsart_sivas",
            "FosGruppe":"fosGruppe_sivas",
            "Kalkulationsart":"kalkulationsart_sivas",
            #"Indexerfasser":"",
            "Aenderungstext":"aenderungstext_sivas",
            "Freigabevermerk":"freigabevermerk_sivas",
            # "Indexbearbeiter":"in"
        }

    def csv2guidata(self, data):
        ret = dict()
        for k,v in data.items():
            if k in self.excel_to_gui and v is not None:
                ret[self.excel_to_gui[k]] = v

        # Spezial: Befüllung von Änderungstext mit dem Author, falls in der .csv vorhanden
        if "Indexerfasser" in data and "Aenderungstext" in data:
            ret["aenderungstext_sivas"] = '{aenderungstext} (von {author})'.format(aenderungstext=data["Aenderungstext"], author=data["Indexerfasser"])
            # Indexerfasser wird nicht in der gui verwaltet. Deshalb Modifikation aus den Rohdaten

        # set defaults from given logic
        r1 = self.callback("cb_neuaufbau", None)
        ret.update(r1)
        r2 = self.callback("cb_aus_halbzeug_neu", None)
        ret.update(r2)
        r3 = self.callback("cb_halbzeugoberflaeche", None)
        ret.update(r3)

        # add entry dependencies
        dep = self.entry_dependencies(ret)
        ret.update(dep)
        return ret

    def entry_dependencies(self, data):
        return {}


    def callback(self, key, value):
        """gibt ein dict zurück, welches neu im Modell gesetzt wird"""

        if key == 'cb_pdm_kategorie_neu':
            pass
        elif key == "cb_halbzeug_neu":
            pass
        elif key == "cb_halbzeugoberflaeche":
            return self.halbzeug_oberflaeche_neu(value)
        elif key == "cb_halbzeugfarbe":
            return self.halbzeug_farbe_neu(value)
        elif key == 'cb_neuaufbau':
            return self.neuaufbau(value)
        elif key == 'cb_aus_halbzeug_neu':
            return self.aus_halbzeug_neu(value)
        elif key == 'cb_lebenszyklus_status_neu':
            pass
        elif key == 'cb_3Dmodel_neu':
            pass
        elif key == 'cb_halbzeugOhneSaege_neu':
            pass
        elif key == 'cb_ruestcode_neu':
            pass
        elif key == 'cb_fertigungsart_neu':
            pass
        elif key == 'cb_allgemeintoleranz_neu':
            pass
        elif key == 'cb_fosGruppe_neu':
            pass
        elif key == 'cb_kalkulationsart_neu':
            pass
        elif key == 'cb_beschaffungsart_neu':
            pass
        elif key == 'cb_mengeneinheit_neu':
            pass
        elif key == 'cb_halbzeug_neu':
            pass
        elif key == 'cb_dispogruppe_neu':
            pass
        elif key == 'cb_dispolaufgruppe_neu':
            pass
        elif key == 'cb_hersteller_neu':
            pass
        elif key == 'cb_werkstoffdiskrepanz':
            pass
        elif key == 'cb_werkstofftyp_neu':
            pass
            # return self.werkstofftyp(value)
        elif key == 'cb_material_neu':
            pass
        elif key == 'cb_oberflaeche_neu':
            pass
        elif key == 'cb_farbe_neu':
            return self.farbe(value)
        elif key == 'cb_speichern':
            pass
        elif key == 'cb_migrieren':
            pass
        elif key == 'cb_zurücksetzen':
            pass
        elif key == 'cb_suche_asm':
            pass
        else:
            raise Exception("this callback does not exist "+key)

    def neuaufbau(self, trueOrfalse):
        ret = dict()
        pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
        if pdm_kat != "Einzelteil" or pdm_kat != "Kaufteil":
            ret["neuaufbau"] = False
        return ret
    
    def aus_halbzeug_neu(self, trueOrfalse):
        ret = dict()
        pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
        if pdm_kat == "Einzelteil":
            ret = self.callback("cb_halbzeugoberflaeche", None)
        else:
            ret["aus_halbzeug_neu"] = False
        return ret
    

    def farbe(self, selected):
        farben_alle = self.config.Farben.get_farbauswahl()
        farben_elox = self.config.Farben.get_farben_eloxieren()
        # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
        ret = { 
                # das Feld selbst mit dem Selektierten beschreiben
               'farbe_neu': selected,  
                # die neuen Inhalte der comboboxen setzen
               'cb_farben': farben_alle, 
                # der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
               'farbe_neu': farben_alle[0],  
        }
        return ret


    def halbzeug_oberflaeche_neu(self, selected):
        ret = dict()
        aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
        if aus_halbzeug == "True":
            oarten = self.config.Oberfläche.get_oberflächen_behandlungen()
            if not selected is None:
                ret['cb_halbzeugoberflaeche'] = selected
            else:     
                ret = { 
                    'halbzeugoberflaeche_neu': oarten[0], 
                    'cb_halbzeugoberflaeche': oarten,
                }
        else:
            ret = { 
                'halbzeugoberflaeche_neu': "",
                'cb_halbzeugoberflaeche': "",
            }
        return ret
    
    def halbzeug_farbe_neu(self, selected):
        ret = dict()
        data = self.model.get_gui_data("halbzeug_farbe_neu")
        if "halbzeugoberflaeche_neu" in data:
            halbzeugoberflaeche = data["halbzeugoberflaeche_neu"]
            if data["aus_halbzeug_neu"] == True:
                if halbzeugoberflaeche == "eloxieren" or halbzeugoberflaeche == "lackieren" or halbzeugoberflaeche == "pulverbeschichten":
                    if halbzeugoberflaeche == "eloxieren":
                        farben_elox = self.config.Farben.get_farben_eloxieren()
                        # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
                        ret = { 
                            # die neuen Inhalte der comboboxen setzen
                            'halbzeugfarbe_neu': farben_elox[0], 
                            'cb_halbzeugfarbe': farben_elox,

                        }
                    elif halbzeugoberflaeche == "lackieren" or halbzeugoberflaeche == "pulverbeschichten":
                        farbauswahl = self.config.Farben.get_farbauswahl()
                        # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
                        ret = { 
                            'halbzeugfarbe_neu': farbauswahl[0], 
                            'cb_halbzeugfarbe': farbauswahl,
                        }
                        
                else:
                    ret["halbzeugoberflaeche_neu"] = ''
            else:
                ret["halbzeugoberflaeche_neu"] = ''
        return ret


    # def werkstofftyp(self, selected_werkstoff):
        # """bekommt Aluminium, Stahl etc. und setzt dann die anderen Felder der Oberfläche"""

        # # Logik, die steuert, welcher Defaultwert gilt:

        # #    In den nachfolgenden Fällen darf kein Defaultwert eingetragen
        # #    werden (selbst wenn in from_siv.csv ein Wert in der Spalte
        # #    "Werkstoff" eingetragen sein sollte):
        # #        PDM-Kategorie == "Baugruppe"
        # #        PDM-Kategorie == "Schweissbaugruppe"
        # #        PDM-Kategorie == "Einzelteil" und Aus Halbzeug == True (Haken gesetzt)

        # #    Gilt PDM-Kategorie == "Kaufteil" soll der Defaultwert "siehe
        # #    Hersteller" eingetragen werden

        # #    Gilt PDM-Kategorie == "Einzelteil" und Aus Halbzeug == False (kein
        # #    Haken), dann wird der Defaultwert wie folgt bestimmt:
        # ret = dict()
        # # das Feld selbst mit dem Selektierten beschreiben
        # ret['werkstofftyp_neu']= selected_werkstoff

        # pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
        # aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")

        # if pdm_kat == 'Einzelteil' and aus_halbzeug is False:
            # wnamen = self.config.Werkstoffe.get_werkstoffe_of_name(selected_werkstoff)
            # # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
            # ret = { 
                    # # das Feld selbst mit dem Selektierten beschreiben
                   # 'werkstofftyp_neu': selected_werkstoff,  
                    # # die neuen Inhalte der comboboxen setzen
                   # 'cb_material_neu': wnamen, 
                    # # der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
                   # 'material_neu': wnamen[0],  
            # }
        # return ret

    # def oberfläche(self, selected):

        # ret = dict()
        # # das Feld selbst mit dem Selektierten beschreiben
        # ret['oberflaeche_neu']= selected

        # pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
        # aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")

        # if pdm_kat == 'Einzelteil' and aus_halbzeug is False:
            # onamen = self.config.Oberfläche.get_oberfläche_of_type(selected)
            # # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
            # ret = { 
                    # # die neuen Inhalte der comboboxen setzen
                   # 'cb_oberflaeche_neu': onamen, 
                    # # der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
                   # 'oberflaeche_neu': onamen[0],  
            # }
        # return ret


if __name__ == "__main__":
    pass