from ezdxf.entities import Line
import math
from pydantic import BaseModel, Field, field_validator
from typing import Optional
import plant2dxf 
from ezdxf.math import Matrix44
import re

class VarioFoerderer(BaseModel):
    teileid: str
    x: float = Field(description="X-Koordinate des Foerder-Zentrums")
    y: float = Field(description="Y-Koordinate des Foerder-Zentrums")
    laenge:float = Field(description = "Länge des Förderers")
    winkel: float = Field(description = "Winkel des Färderers")
    h0: float = Field(description="Höhe Anfang in Merkmale")
    h1: float = Field(description="Höhe Ende in Merkmale")
    hat_motor: bool = Field(description="Überprüft ob der Vörderer ein Motor hat")
    hat_umlenk: bool = Field(description="Überprüft ob der Vörderer eine Umlenkstation hat")
    drehung: float = Field(default=0.0, description="Drehung/Winkel in Grad")
    foerderer_richtung : str= Field(description="In welche richtung geförderd wird") 
    gefaelle_laenge: Optional [float] = Field(default=0.0,description="Länge der zusätzlichen Gefälle Strecke falls vorhanden")
    gefaelle_winkel: Optional [float] = Field(default=0.0,description="Winkel der Gefällestrecke, falls diese Vorhanden ist")
    anzahl_scanner: int = Field(default=0, description="Anzahl der Scanner")
    anzahl_separatoren: int = Field(default=0, description="Anzahl der Separatoren")
    
    @property
    def hight_zwischen(self):
        return ((self.h0 + self.h1) /2)
    
    
    @classmethod
    def from_merkmale(cls, teileid: str, x: float, y: float, merkmale: dict) -> 'VarioFoerderer':
        
        h0 = float(merkmale.get("Höhe Anfang")) * 1000
        h1 = float(merkmale.get("Höhe Ende")) * 1000
        laenge = float(merkmale.get("Länge in Meter")) * 1000
        gefaelle_laenge = merkmale.get("Laenge_Gefaellestrecke")
        if gefaelle_laenge == None:
            gefaelle_laenge = 0.0
            gefaelle_winkel = 0.0
        else:
            gefaelle_laenge = float(gefaelle_laenge)
            gefaelle_winkel = float(merkmale.get("Winkel_Gefaellestrecke")),
        return cls(
        teileid = teileid,
        laenge = laenge,
        x = x,
        y = y,
        
        foerderer_richtung =merkmale.get("Förderrichtung"),
        winkel = float(merkmale.get("Winkel")),
        hat_motor = bool(merkmale.get("hatMotor")),
        hat_umlenk = bool(merkmale.get("hatUmlenkung")),
        h0 = h0,
        h1 =h1,
        drehung = float(merkmale.get("Drehung")),
        gefaelle_laenge = gefaelle_laenge,
        gefalle_winkel = gefaelle_winkel,
        anzahl_scanner = int(merkmale.get("Anzahl der Scanner")),
        anzahl_separatoren = int(merkmale.get("Anzahl der Separatoren"))

        )
    def get_offset_of_Vario_line(doc, lib_doc, foerderer, gefaellestrecke_vario):
        winkel_VP_offset_vorne = None
        winkel_VP_offset_hinten = None
        voerder_richtung = foerderer.foerderer_richtung
        winkel = int(foerderer.winkel)
        rotation = foerderer.drehung
        upper_hoehe_vario= foerderer.h1
        lower_hoehe_vario = foerderer.h0
        if (gefaellestrecke_vario.get("Winkel") != None or gefaellestrecke_vario.get("Kurvenrichtung") != None) and  ((winkel == 3 and voerder_richtung == "Ab")or voerder_richtung == "Horizontal"):
        # Überprüfung wo es verbunden ist und mit welchen fördere vorne ist ende der Fahrrichtung
            if gefaellestrecke_vario.get("h0") != None :
                if  float(gefaellestrecke_vario.get("h0")) == lower_hoehe_vario  and voerder_richtung != "Horizontal":
                    if (gefaellestrecke_vario.get("Foerderrichtung") == "Auf"):
                        # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte
                        winkel_vorne_plusbogen = int(gefaellestrecke_vario.get("Winkel")) +3
                        winkel_vorne = int(gefaellestrecke_vario.get("Winkel")) 
                        blockname = (f"Vario_Bogen_auf_{winkel_vorne_plusbogen}°")
                        att_vorne =plant2dxf.import_block(blockname,lib_doc,doc)
                        SP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_0"]))
                        VP_1_nachbar_vorne =  list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_0"]))
                        # Ausrechnen des Offsets
                        winkel_VP_offset_hinten = (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.cos(math.radians(3)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.sin(math.radians(3)), VP_1_nachbar_vorne[1],- (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.sin(math.radians(3)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.cos(math.radians(3))

                    elif gefaellestrecke_vario.get("Foerderrichtung") == "Ab" :
                    # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte
                        winkel_vorne_minusbogen = int(gefaellestrecke_vario.get("Winkel")) -3
                        winkel_vorne = int(gefaellestrecke_vario.get("Winkel")) 

                        blockname = (f"Vario_Bogen_ab_{winkel_vorne_minusbogen}°")
                        att_vorne =plant2dxf.import_block(blockname,lib_doc,doc)
                        SP_0_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_0"]))
                        VP_0_nachbar_vorne =  list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_0"]))
                        # Ausrechnung des Offsets
                        winkel_VP_offset_hinten = (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.sin(math.radians(3)), VP_0_nachbar_vorne[1],- (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.cos(math.radians(3))
                      
                elif  float(gefaellestrecke_vario.get("h1")) == upper_hoehe_vario  and voerder_richtung != "Horizontal":
                    if (gefaellestrecke_vario.get("Foerderrichtung") == "Auf" ):
                        # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte
                        winkel_hinten_plusbogen = int(gefaellestrecke_vario.get("Winkel")) +3
                        winkel_hinten = int(gefaellestrecke_vario.get("Winkel")) 

                        blockname = (f"Vario_Bogen_ab_{winkel_hinten_plusbogen}°")
                        att_hinten =plant2dxf.import_block(blockname,lib_doc,doc)
                        SP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_1"]))
                        VP_0_nachbar_hinten =  list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_1"]))
                        # Ausrechnung des Offsets
                        winkel_VP_offset_vorne = (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.cos(math.radians(-winkel_hinten)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.sin(math.radians(-winkel_hinten)), VP_0_nachbar_hinten[1],- (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.sin(math.radians(-winkel_hinten)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.cos(math.radians(-winkel_hinten))

                    elif gefaellestrecke_vario.get("Foerderrichtung") == "Ab":
                        # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte
                        winkel_hinten_minusbogen = int(gefaellestrecke_vario.get("Winkel")) -3
                        winkel_hinten = int(gefaellestrecke_vario.get("Winkel")) 

                        blockname = (f"Vario_Bogen_auf_{winkel_hinten_minusbogen}°")
                        att_hinten =plant2dxf.import_block(blockname,lib_doc,doc)
                        SP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_1"]))
                        VP_1_nachbar_hinten =  list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_1"]))
                        # Ausrechnung des Offsets
                        winkel_VP_offset_vorne = (SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.cos(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.sin(math.radians(winkel_hinten)), VP_1_nachbar_hinten[1],- (SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.sin(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.cos(math.radians(winkel_hinten))
                elif voerder_richtung == "Horizontal":
                    winkel_vorne_plusbogen = int(gefaellestrecke_vario.get("Winkel")) +3
                    winkel_hinten = int(gefaellestrecke_vario.get("Winkel")) 
                    blockname = (f"Vario_Bogen_auf_{winkel_vorne_plusbogen}°")
                    att_vorne =plant2dxf.import_block(blockname,lib_doc,doc)
                    SP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_1"]))
                    VP_0_nachbar_hinten =  list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_1"]))
                    SP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_0"]))
                    VP_1_nachbar_vorne =  list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_0"]))
                    x_foerderer =gefaellestrecke_vario.get("X_foerderer")
                    y_foerderer =gefaellestrecke_vario.get("Y_foerderer")
                    x = foerderer.x
                    y = foerderer.y
                    rotation_zwischen = rotation
                    if rotation_zwischen == 0.0:
                        rotation_zwischen = -360.0
                    if (((-360.0<= rotation_zwischen< -270.0)and y > y_foerderer) or ((-90.0< rotation< 0.0)and y > y_foerderer) or
                    ((-270.0< rotation_zwischen< -90.0)and y < y_foerderer)  or 
                    (rotation == -90.0 and x < x_foerderer) or ((rotation == -270.0)and x<x_foerderer)):
                        blockname = (f"Vario_Bogen_auf_{winkel_vorne_plusbogen}°")
                        att_vorne =plant2dxf.import_block(blockname,lib_doc,doc)
                        SP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_0"]))
                        VP_1_nachbar_vorne =  list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_0"]))
                        winkel_VP_offset_vorne = (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.cos(math.radians(3)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.sin(math.radians(3)), VP_1_nachbar_vorne[1],- (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.sin(math.radians(3)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.cos(math.radians(3))
                    else:
                        blockname = (f"Vario_Bogen_ab_{winkel_vorne_plusbogen}°")
                        att_hinten =plant2dxf.import_block(blockname,lib_doc,doc)
                        SP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_1"]))
                        VP_0_nachbar_hinten =  list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_1"]))
                        winkel_VP_offset_hinten = (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.cos(math.radians(-winkel_hinten)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.sin(math.radians(-winkel_hinten)), VP_0_nachbar_hinten[1],- (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.sin(math.radians(-winkel_hinten)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.cos(math.radians(-winkel_hinten))

            
            else:
                blockname = (f"Vario_Kurve_{gefaellestrecke_vario.get("Kurvenrichtung")}_{gefaellestrecke_vario.get("Kurvenwinkel")}°_TEF_{gefaellestrecke_vario.get("Tefkurve")}")
                att_kurve = plant2dxf.import_block(blockname,lib_doc,doc)
                SP_0_nachbar = list(float(att)for att in re.split(r"[;,]", att_kurve["DELTA_SP_0"]))
                VP_0_nachbar =  list(float(att)for att in re.split(r"[;,]", att_kurve["DELTA_VP_0"]))
                SP_1_nachbar = list(float(att)for att in re.split(r"[;,]", att_kurve["DELTA_SP_1"]))
                VP_1_nachbar=  list(float(att)for att in re.split(r"[;,]", att_kurve["DELTA_VP_1"]))
                if voerder_richtung == "Ab":
                    if float(gefaellestrecke_vario.get("vario_hoehe_1")) == lower_hoehe_vario:
                        winkel_VP_offset_hinten = (SP_1_nachbar[0] -VP_1_nachbar[0] ),0,( SP_1_nachbar[2]- VP_1_nachbar[2])
                    else:
                        winkel_VP_offset_vorne = (SP_1_nachbar[0] -VP_1_nachbar[0] ),0,( SP_1_nachbar[2]- VP_1_nachbar[2])
                else:
                    x_angetrieben = gefaellestrecke_vario.get("X_angetrieben")
                    y_angetrieben = gefaellestrecke_vario.get("Y_angetrieben")
                    x = foerderer.x
                    y = foerderer.y
                    rotation_zwischen = rotation
                    if rotation_zwischen == 0.0:
                        rotation_zwischen = -360.0
                    if (((-360.0<= rotation_zwischen< -270.0)and y > y_angetrieben) or ((-90.0< rotation< 0.0)and y > y_angetrieben) or
                    ((-270.0< rotation_zwischen< -90.0)and y < y_angetrieben)  or 
                    (rotation == -90.0 and x < x_angetrieben) or ((rotation == -270.0)and x < x_angetrieben)):
                        winkel_VP_offset_hinten = winkel_VP_offset_hinten = (SP_1_nachbar[0] -VP_1_nachbar[0] ),0,( SP_1_nachbar[2]- VP_1_nachbar[2])
                    else:
                        winkel_VP_offset_vorne = (SP_1_nachbar[0] -VP_1_nachbar[0] ),0,( SP_1_nachbar[2]- VP_1_nachbar[2])

                    

    # Das gleiche falls der 3 grad Förderer mit zwei Förderer Verbunden ist
        if (gefaellestrecke_vario.get("Winkel_2") != None or gefaellestrecke_vario.get("Kurvenrichtung_1") != None) and  ((winkel == 3 and voerder_richtung == "Ab")or voerder_richtung == "Horizontal"):
        # Überprüfung wo es verbunden ist und mit welchen fördere vorne ist ende der Fahrrichtung
            if gefaellestrecke_vario.get("h0_2") != None:
                if  float(gefaellestrecke_vario.get("h0_2")) == lower_hoehe_vario and voerder_richtung != "Horizontal":
                    if (gefaellestrecke_vario.get("Foerderrichtung_2") == "Auf"):
                        # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte
                        winkel_vorne_plusbogen = int(gefaellestrecke_vario.get("Winkel_2")) +3
                        winkel_vorne = int(gefaellestrecke_vario.get("Winkel_2")) 
                        blockname = (f"Vario_Bogen_auf_{winkel_vorne_plusbogen}°")
                        att_vorne =plant2dxf.import_block(blockname,lib_doc,doc)
                        SP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_0"]))
                        VP_1_nachbar_vorne =  list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_0"]))
                        # Ausrechnen des Offsets
                        winkel_VP_offset_hinten = (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.cos(math.radians(3)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.sin(math.radians(3)), VP_1_nachbar_vorne[1],- (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.sin(math.radians(3)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.cos(math.radians(3))

                    elif gefaellestrecke_vario.get("Foerderrichtung_2") == "Ab":
                    # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte
                        winkel_vorne_minusbogen = int(gefaellestrecke_vario.get("Winkel_2")) -3
                        winkel_vorne = int(gefaellestrecke_vario.get("Winkel_2")) 

                        blockname = (f"Vario_Bogen_ab_{winkel_vorne_minusbogen}°")
                        att_vorne =plant2dxf.import_block(blockname,lib_doc,doc)
                        SP_0_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_0"]))
                        VP_0_nachbar_vorne =  list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_0"]))
                        # Ausrechnung des Offsets
                        winkel_VP_offset_hinten = (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.cos(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.sin(math.radians(3)), VP_0_nachbar_vorne[1],- (SP_0_nachbar_vorne[0] - VP_0_nachbar_vorne[0]) * math.sin(math.radians(3)) + (SP_0_nachbar_vorne[2] - VP_0_nachbar_vorne[2])*math.cos(math.radians(3))
                        
                elif  float(gefaellestrecke_vario.get("h1_2")) == upper_hoehe_vario  and voerder_richtung != "Horizontal":
                    if (gefaellestrecke_vario.get("Foerderrichtung_2") == "Auf"):
                        # Nehmen des winkels und diesen plus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte
                        winkel_hinten_plusbogen = int(gefaellestrecke_vario.get("Winkel_2")) +3
                        winkel_hinten = int(gefaellestrecke_vario.get("Winkel_2")) 

                        blockname = (f"Vario_Bogen_ab_{winkel_hinten_plusbogen}°")
                        att_hinten =plant2dxf.import_block(blockname,lib_doc,doc)
                        SP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_1"]))
                        VP_0_nachbar_hinten =  list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_1"]))
                        # Ausrechnung des Offsets
                        winkel_VP_offset_vorne = (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.cos(math.radians(-winkel_hinten)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.sin(math.radians(-winkel_hinten)), VP_0_nachbar_hinten[1],- (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.sin(math.radians(-winkel_hinten)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.cos(math.radians(-winkel_hinten))

                    elif gefaellestrecke_vario.get("Foerderrichtung") == "Ab":
                            # Nehmen des winkels und diesen minus 3 nehmen, um den Bogen zu imporieren für heraufinden der Delta werte
                            winkel_hinten_minusbogen = int(gefaellestrecke_vario.get("Winkel_2")) -3
                            winkel_hinten = int(gefaellestrecke_vario.get("Winkel_2")) 

                            blockname = (f"Vario_Bogen_auf_{winkel_hinten_minusbogen}°")
                            att_hinten =plant2dxf.import_block(blockname,lib_doc,doc)
                            SP_1_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_1"]))
                            VP_1_nachbar_hinten =  list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_1"]))
                            # Ausrechnung des Offsets
                            winkel_VP_offset_vorne = (SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.cos(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.sin(math.radians(winkel_hinten)), VP_1_nachbar_hinten[1],- (SP_1_nachbar_hinten[0] - VP_1_nachbar_hinten[0]) * math.sin(math.radians(winkel_hinten)) + (SP_1_nachbar_hinten[2] - VP_1_nachbar_hinten[2])*math.cos(math.radians(winkel_hinten))
                elif voerder_richtung == "Horizontal":
                    winkel_vorne_plusbogen = int(gefaellestrecke_vario.get("Winkel_2")) +3
                    winkel_hinten = int(gefaellestrecke_vario.get("Winkel_2")) 
                    blockname = (f"Vario_Bogen_auf_{winkel_vorne_plusbogen}°")
                    att_vorne =plant2dxf.import_block(blockname,lib_doc,doc)
                    SP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_1"]))
                    VP_0_nachbar_hinten =  list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_1"]))
                    SP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_0"]))
                    VP_1_nachbar_vorne =  list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_0"]))
                    x_foerderer =gefaellestrecke_vario.get("X_foerderer_2")
                    y_foerderer =gefaellestrecke_vario.get("Y_foerderer_2")
                    x = foerderer.x
                    y = foerderer.y
                    rotation_zwischen = rotation
                    if rotation_zwischen == 0.0:
                        rotation_zwischen = -360.0
                    if (((-360.0<= rotation_zwischen< -270.0)and y > y_foerderer) or ((-90.0< rotation< 0.0)and y > y_foerderer) or
                    ((-270.0< rotation_zwischen< -90.0)and y < y_foerderer)  or 
                    (rotation == -90.0 and x < x_foerderer) or ((rotation == -270.0)and x<x_foerderer)):
                        blockname = (f"Vario_Bogen_auf_{winkel_vorne_plusbogen}°")
                        att_vorne =plant2dxf.import_block(blockname,lib_doc,doc)
                        SP_1_nachbar_vorne = list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_SP_0"]))
                        VP_1_nachbar_vorne =  list(float(att)for att in re.split(r"[;,]", att_vorne["DELTA_VP_0"]))
                        winkel_VP_offset_vorne = (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.cos(math.radians(3)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.sin(math.radians(3)), VP_1_nachbar_vorne[1],- (SP_1_nachbar_vorne[0] - VP_1_nachbar_vorne[0]) * math.sin(math.radians(3)) + (SP_1_nachbar_vorne[2] - VP_1_nachbar_vorne[2])*math.cos(math.radians(3))
                    else:
                        blockname = (f"Vario_Bogen_ab_{winkel_vorne_plusbogen}°")
                        att_hinten =plant2dxf.import_block(blockname,lib_doc,doc)
                        SP_0_nachbar_hinten = list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_SP_1"]))
                        VP_0_nachbar_hinten =  list(float(att)for att in re.split(r"[;,]", att_hinten["DELTA_VP_1"]))
                        winkel_VP_offset_hinten = (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.cos(math.radians(-winkel_hinten)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.sin(math.radians(-winkel_hinten)), VP_0_nachbar_hinten[1],- (SP_0_nachbar_hinten[0] - VP_0_nachbar_hinten[0]) * math.sin(math.radians(-winkel_hinten)) + (SP_0_nachbar_hinten[2] - VP_0_nachbar_hinten[2])*math.cos(math.radians(-winkel_hinten))
            else:
                blockname = (f"Vario_Kurve_{gefaellestrecke_vario.get("Kurvenrichtung_1")}_{gefaellestrecke_vario.get("Kurvenwinkel_1")}°_TEF_{gefaellestrecke_vario.get("Tefkurve_1")}")
                att_kurve = plant2dxf.import_block(blockname,lib_doc,doc)
                SP_0_nachbar = list(float(att)for att in re.split(r"[;,]", att_kurve["DELTA_SP_0"]))
                VP_0_nachbar =  list(float(att)for att in re.split(r"[;,]", att_kurve["DELTA_VP_0"]))
                SP_1_nachbar = list(float(att)for att in re.split(r"[;,]", att_kurve["DELTA_SP_1"]))
                VP_1_nachbar=  list(float(att)for att in re.split(r"[;,]", att_kurve["DELTA_VP_1"]))
                if voerder_richtung == "Ab":
                    if float(gefaellestrecke_vario.get("vario_hoehe_1")) == lower_hoehe_vario:
                        winkel_VP_offset_hinten = (SP_1_nachbar[0] -VP_1_nachbar[0] ),0,( SP_1_nachbar[2]- VP_1_nachbar[2])
                    else:
                        winkel_VP_offset_vorne = (SP_1_nachbar[0] -VP_1_nachbar[0] ),0,( SP_1_nachbar[2]- VP_1_nachbar[2])
                else:
                    x_angetrieben = gefaellestrecke_vario.get("X_angetrieben_1")
                    y_angetrieben = gefaellestrecke_vario.get("Y_angetrieben_1")
                    x = foerderer.x
                    y = foerderer.y
                    rotation_zwischen = rotation
                    if rotation_zwischen == 0.0:
                        rotation_zwischen = -360.0
                    if (((-360.0<= rotation_zwischen< -270.0)and y > y_angetrieben) or ((-90.0< rotation< 0.0)and y > y_angetrieben) or
                    ((-270.0< rotation_zwischen< -90.0)and y < y_angetrieben)  or 
                    (rotation == -90.0 and x < x_angetrieben) or ((rotation == -270.0)and x<x_angetrieben)):
                        winkel_VP_offset_hinten = winkel_VP_offset_hinten = (SP_1_nachbar[0] -VP_1_nachbar[0] ),0,( SP_1_nachbar[2]- VP_1_nachbar[2])
                    else:
                        winkel_VP_offset_vorne = (SP_1_nachbar[0] -VP_1_nachbar[0] ),0,( SP_1_nachbar[2]- VP_1_nachbar[2])
           
        return winkel_VP_offset_vorne,winkel_VP_offset_hinten
    def vario_erstellung(foerderer, doc, lib_doc, config, block, block_name_links, start, ende, voerder_richtung, winkel_VP_offset_vorne, winkel_VP_offset_hinten ):
        # Entnehmen der Motor und Umlenk station um die Gefähle auzurechnen und ob man diese tatsächlich einfügen muss
        winkel_motor = float(config.get("Ils 2.0 core winkel","winkel_motor"))
        winkel_umlenk = float(config.get("Ils 2.0 core winkel","winkel_umlenk"))
        umlenk_laenge = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Umlenkstation")).split(","))
        motor_laenge = tuple(float(x) for x in(config.get("ILS 2.0 Variofoerderer","Motorstation")).split(","))
        
        vario_abstand = float(config.get("ILS 2.0 Variofoerderer","vario_abstand"))
        motor_vorhanden = foerderer.hat_motor
        umlenk_vorhanden = foerderer.hat_umlenk
        gefahellewinkel =foerderer.gefaelle_winkel
        gefaelle = foerderer.gefaelle_laenge
        x = foerderer.x
        y = foerderer.y
        hoehe_vario = foerderer.hight_zwischen
        winkel = int(foerderer.winkel)
        # Aktueller offset des motors und Umlenkungstation, wird wahrscheinlich später einfach berechnet (sobald man entschieden hat ob wir nur 3 grad neigung erlauben oder nicht)

        motor_offset_x = umlenk_laenge[0]* math.cos(math.radians(winkel_motor))
        motor_offset_z = umlenk_laenge[0]* math.sin(math.radians(winkel_motor))
        umlenk_offset_x = motor_laenge[0]* math.cos(math.radians(winkel_umlenk))
        umlenk_offset_z = motor_laenge[0]* math.sin(math.radians(winkel_umlenk))
        # Berechnung des Gefälles
        if motor_vorhanden  == True:
            gefaelle = gefaelle - motor_offset_x
        if umlenk_vorhanden == True:
            gefaelle = gefaelle - umlenk_offset_x

        #Erstellung des Förderes falls er auf ist oder Horizontal da diese gleich aufgebaut werden
        if voerder_richtung== "Auf" or voerder_richtung== "Horizontal":
            # erstellung des gefälles falls es nicht null ist (also keins angegeben ist oder es durch andere Sachen wie Motor ersetzt wird)
            if gefaelle > 0:
                # Setzng die hälfte des Gefälles auf beide seiten falls dieser nicht mit einem anderen Förder verbunden ist was durch die abwesenheit eines motors/umlenkung gezeigt wird
                halbesgefaelle = gefaelle/2
                if motor_vorhanden == True and umlenk_vorhanden == True:
                    halbesgefaelle = gefaelle/2
                    gefaelle_ende = ende[0], ende[1] +halbesgefaelle, ende[2] -math.sin(math.radians(gefahellewinkel))* halbesgefaelle
                    line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende})
                    line_ende_gefaelle.dxf.layer = "6-SP"
                    copy_ende = line_ende_gefaelle.copy()
                    copy_ende.translate(-x,-y,-hoehe_vario)
                    block.add_entity(copy_ende)
                    ende = gefaelle_ende
                    
                    gefaelle_start = start[0], start[1] -halbesgefaelle, start[2] +math.sin(math.radians(gefahellewinkel)) * halbesgefaelle
                    line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start})
                    line_start_gefaelle.dxf.layer = "6-SP"
                    copy_start = line_start_gefaelle.copy()
                    copy_start.translate(-x,-y,-hoehe_vario)
                    block.add_entity(copy_start)
                    start = gefaelle_start

                elif motor_vorhanden== True:
                    gefaelle_start = start[0], start[1] -gefaelle, start[2] +math.sin(math.radians(gefahellewinkel)) * gefaelle
                    line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start})
                    line_start_gefaelle.dxf.layer = "6-SP"
                    copy_start = line_start_gefaelle.copy()
                    copy_start.translate(-x,-y,-hoehe_vario)
                    block.add_entity(copy_start)
                    start = gefaelle_start

                elif umlenk_vorhanden== True:
                    gefaelle_ende = ende[0], ende[1] +gefaelle, ende[2] -math.sin(math.radians(gefahellewinkel))* gefaelle
                    line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende})
                    line_ende_gefaelle.dxf.layer = "6-SP"
                    copy_ende = line_ende_gefaelle.copy()
                    copy_ende.translate(-x,-y,-hoehe_vario)
                    block.add_entity(copy_ende)
                    ende = gefaelle_ende
            
            # Den Motorstaton und Umlenkstation auf die richtige position in block einfügen falls nötig
            block_Vario_Umlenkstation_500mm ="Vario_Umlenkstation_500mm"
            block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm"
            plant2dxf.import_block(block_Vario_Motorstation_500mm, lib_doc, doc)
            plant2dxf.import_block(block_Vario_Umlenkstation_500mm , lib_doc, doc)
            layer_motor, color_motor = plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Motorstation_500mm)
            layer_umlenk, color_umlenk = plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Umlenkstation_500mm)
            block_Vario_Motorstation_500mm = plant2dxf.dreh_block(block_Vario_Motorstation_500mm,doc,lib_doc,math.radians(winkel_motor))
            block_Vario_Umlenkstation_500mm = plant2dxf.dreh_block( block_Vario_Umlenkstation_500mm, doc,lib_doc,math.radians(winkel_umlenk))
            if umlenk_vorhanden == True:
                block.add_blockref(block_Vario_Umlenkstation_500mm,(ende[0]  -x,ende[1] -y + umlenk_offset_x/2,ende[2] - hoehe_vario -umlenk_offset_z/2 ),dxfattribs={"rotation": 90, "layer":layer_umlenk,"color": color_umlenk})
                ende = (ende[0] ,ende[1] + umlenk_offset_x,ende[2] - umlenk_offset_z)
            if motor_vorhanden == True:
                block.add_blockref(block_Vario_Motorstation_500mm, (start[0]-x , start[1] - motor_offset_x/2 -y ,start[2] - hoehe_vario +motor_offset_z/2),dxfattribs={"rotation": 90, "layer":layer_motor,"color": color_motor})
                start = start[0]  , start[1] - motor_offset_x,start[2] + motor_offset_z
                
            # Einfügen der 51 grad Bogen und deren notwendigen Werten von den attributen des bogens in den block
            winkel_core = int(config.get("Ils 2.0 core winkel","winkel_boegen"))
            winkel_plus = winkel + winkel_core
            block_Vario_Bogen_auf = (f"Vario_Bogen_auf_{winkel_plus}°")
            block_Vario_Bogen_ab = (f"Vario_Bogen_ab_{winkel_plus}°")
        
            auf_attrib =plant2dxf.import_block(block_Vario_Bogen_auf, lib_doc, doc)
            ab_attrib =plant2dxf.import_block(block_Vario_Bogen_ab, lib_doc, doc)
            layer_auf,color_auf = plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Bogen_auf)
            layer_ab,color_ab =plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Bogen_ab)
            block_Vario_Bogen_auf = plant2dxf.dreh_block(block_Vario_Bogen_auf, doc,lib_doc,math.radians(winkel_core))
            block_Vario_Bogen_ab = plant2dxf.dreh_block(block_Vario_Bogen_ab, doc,lib_doc,math.radians(-winkel))
        

            Vario_Bogen_auf_Delta_SP_0  = list(float(att)for att in re.split(r"[;,]", auf_attrib["DELTA_SP_0"]))
            Vario_Bogen_auf_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_SP_1"]))
            Vario_Bogen_ab_Delta_SP_0  = list(float(att) for att in  re.split(r"[;,]", ab_attrib["DELTA_SP_0"]))
            Vario_Bogen_ab_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_1"]))
            Vario_Bogen_auf_Delta_VP_1 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_VP_1"]))
            Vario_Bogen_ab_Delta_VP_0= list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_VP_0"]))
            
            Vario_Bogen_auf_Delta_SP_0 = [Vario_Bogen_auf_Delta_SP_0 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_0[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_SP_0[1],-Vario_Bogen_auf_Delta_SP_0[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_0[2] * math.cos(math.radians(winkel_core)) ]
            Vario_Bogen_auf_Delta_SP_1 = [Vario_Bogen_auf_Delta_SP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_SP_1[1],-Vario_Bogen_auf_Delta_SP_1[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_SP_1[2] * math.cos(math.radians(winkel_core)) ]
            Vario_Bogen_ab_Delta_SP_0 = [Vario_Bogen_ab_Delta_SP_0 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_0[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_SP_0[1],-Vario_Bogen_ab_Delta_SP_0[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_0[2] * math.cos(math.radians(-winkel)) ]
            Vario_Bogen_ab_Delta_SP_1 =[ Vario_Bogen_ab_Delta_SP_1 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_1[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_SP_1[1],-Vario_Bogen_ab_Delta_SP_1[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_SP_1[2] * math.cos(math.radians(-winkel)) ]
            Vario_Bogen_auf_Delta_VP_1 = [Vario_Bogen_auf_Delta_VP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_VP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_auf_Delta_VP_1[1],-Vario_Bogen_auf_Delta_VP_1[0] * math.sin(math.radians(winkel_core))+ Vario_Bogen_auf_Delta_VP_1[2] * math.cos(math.radians(winkel_core)) ]
            Vario_Bogen_ab_Delta_VP_0 = [Vario_Bogen_ab_Delta_VP_0 [0] * math.cos(math.radians(-winkel))+ Vario_Bogen_ab_Delta_VP_0[2]* math.sin(math.radians(-winkel)) ,Vario_Bogen_ab_Delta_VP_0[1],-Vario_Bogen_ab_Delta_VP_0[0] * math.sin(math.radians(-winkel))+ Vario_Bogen_ab_Delta_VP_0[2] * math.cos(math.radians(-winkel)) ]
            
        # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss)
            for i, wert  in enumerate(Vario_Bogen_auf_Delta_SP_0):
                    if i< 2 and wert < 0:
                        Vario_Bogen_auf_Delta_SP_0[i] = abs(wert)
            for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_1):
                if i< 2 and  wert< 0:
                    Vario_Bogen_auf_Delta_SP_1[i] = abs(wert) 
            for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_0):
                if i< 2 and  wert< 0:
                    Vario_Bogen_ab_Delta_SP_0[i] = abs(wert)
            for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_1):
                if i< 2 and  wert< 0:
                    Vario_Bogen_ab_Delta_SP_1[i] = abs(wert)
            for i, wert in enumerate(Vario_Bogen_auf_Delta_VP_1):
                if i< 2 and  wert< 0:
                    Vario_Bogen_auf_Delta_VP_1[i] = abs(wert)
            for i, wert in enumerate(Vario_Bogen_ab_Delta_VP_0):
                if i< 2 and  wert< 0:
                    Vario_Bogen_ab_Delta_VP_0[i] = abs(wert)

            #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
            if voerder_richtung == "Auf":
                block.add_blockref(block_Vario_Bogen_auf,(ende[0] -x ,ende[1] +Vario_Bogen_auf_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90,"layer": layer_auf,"color": color_auf})
                ende_VP = (ende[0] +Vario_Bogen_auf_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_Delta_VP_1[0]+Vario_Bogen_auf_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_Delta_VP_1[2]- Vario_Bogen_auf_Delta_SP_0[2])
                ende = (ende[0]  ,ende[1] +Vario_Bogen_auf_Delta_SP_1[0] + Vario_Bogen_auf_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_Delta_SP_1[2] - Vario_Bogen_auf_Delta_SP_0[2])
                #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
                block.add_blockref(block_Vario_Bogen_ab ,(start[0]-x,start[1]  - Vario_Bogen_ab_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_Delta_SP_1[2]),dxfattribs={"rotation": 90,"layer": layer_ab,"color": color_ab})

                start_VP = start[0] +Vario_Bogen_ab_Delta_VP_0[1],start[1]-Vario_Bogen_ab_Delta_VP_0[0] - Vario_Bogen_ab_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_Delta_VP_0[2] - Vario_Bogen_ab_Delta_SP_1[2]
                start = start[0] ,start[1] - Vario_Bogen_ab_Delta_SP_0[0] - Vario_Bogen_ab_Delta_SP_1[0],start[2] - Vario_Bogen_ab_Delta_SP_1[2]+  Vario_Bogen_ab_Delta_SP_0[2]
                
                # Erstellung der VARIO Line
                line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP})
                line_VP.dxf.layer = "VARIO"
                copy_VP = line_VP.copy()

                copy_VP.translate(-x,-y,-hoehe_vario)
                block.add_entity(copy_VP)
                # Erstellung der zwischen Line
                line = Line.new(dxfattribs={"start": start, "end": ende})
                line.dxf.layer = "6-SP"

                copy= line.copy()

                copy.translate(-x,-y,-hoehe_vario)
                block.add_entity(copy)
            
            else:
                if umlenk_vorhanden == True:
                    block.add_blockref(block_Vario_Bogen_ab ,(start[0]-x,start[1]  - Vario_Bogen_ab_Delta_SP_1[0] -y ,start[2] - hoehe_vario-Vario_Bogen_ab_Delta_SP_1[2]),dxfattribs={"rotation": 90,"layer": layer_ab,"color": color_ab})
                    start_VP = start[0] +Vario_Bogen_ab_Delta_VP_0[1],start[1]-Vario_Bogen_ab_Delta_VP_0[0] - Vario_Bogen_ab_Delta_SP_1[0] ,start[2]+Vario_Bogen_ab_Delta_VP_0[2] - Vario_Bogen_ab_Delta_SP_1[2]
                    start = start[0] ,start[1] - Vario_Bogen_ab_Delta_SP_0[0] - Vario_Bogen_ab_Delta_SP_1[0],start[2] - Vario_Bogen_ab_Delta_SP_1[2]+  Vario_Bogen_ab_Delta_SP_0[2]
                    
                else:
                    start_VP = start[0]  +Vario_Bogen_auf_Delta_VP_1[1] ,start[1] + winkel_VP_offset_vorne[0], start[2] - winkel_VP_offset_vorne[2]

                #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
                if motor_vorhanden == True:
                    block.add_blockref(block_Vario_Bogen_auf,(ende[0] -x ,ende[1] +Vario_Bogen_auf_Delta_SP_0[0] -y ,ende[2] - Vario_Bogen_auf_Delta_SP_0[2]- hoehe_vario ),dxfattribs={"rotation": 90,"layer": layer_auf,"color": color_auf})
                    ende_VP = (ende[0] +Vario_Bogen_auf_Delta_VP_1[1], ende[1]+Vario_Bogen_auf_Delta_VP_1[0]+Vario_Bogen_auf_Delta_SP_0[0],ende[2] + Vario_Bogen_auf_Delta_VP_1[2]- Vario_Bogen_auf_Delta_SP_0[2])
                    ende = (ende[0]  ,ende[1] +Vario_Bogen_auf_Delta_SP_1[0] + Vario_Bogen_auf_Delta_SP_0[0] ,ende[2] + Vario_Bogen_auf_Delta_SP_1[2] - Vario_Bogen_auf_Delta_SP_0[2])
                else:
                    ende_VP = ende[0]  +Vario_Bogen_ab_Delta_VP_0[1],ende[1] - winkel_VP_offset_vorne[0], ende[2] - winkel_VP_offset_vorne[2]
                # Erstellung der VARIO Line
                line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP})
                line_VP.dxf.layer = "VARIO"
                copy_VP = line_VP.copy()

                copy_VP.translate(-x,-y,-hoehe_vario)
                block.add_entity(copy_VP)
            
                # Erstellung der zwischen Line
                line = Line.new(dxfattribs={"start": start, "end": ende})
                line.dxf.layer = "6-SP"

                copy= line.copy()

                copy.translate(-x,-y,-hoehe_vario)
                block.add_entity(copy)

        elif voerder_richtung == "Ab":
            # Setzng die hälfte des Gefälles auf beide seiten falls dieser nicht mit einem anderen Förder verbunden ist was durch die abwesenheit eines motors/umlenkung gezeigt wird

            if gefaelle > 0:
                if motor_vorhanden == True and umlenk_vorhanden == True:
                    halbesgefaelle = gefaelle/2
                    gefaelle_ende = ende[0], ende[1] +halbesgefaelle, ende[2] +math.sin(math.radians(gefahellewinkel))* halbesgefaelle
                    line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende})
                    line_ende_gefaelle.dxf.layer = "6-SP"
                    copy_ende = line_ende_gefaelle.copy()
                    copy_ende.translate(-x,-y,-hoehe_vario)
                    block.add_entity(copy_ende)
                    ende = gefaelle_ende
                    
                    gefaelle_start = start[0], start[1] -halbesgefaelle, start[2] -math.sin(math.radians(gefahellewinkel)) * halbesgefaelle
                    line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start})
                    line_start_gefaelle.dxf.layer = "6-SP"
                    copy_start = line_start_gefaelle.copy()
                    copy_start.translate(-x,-y,-hoehe_vario)
                    block.add_entity(copy_start)
                    start = gefaelle_start
                elif motor_vorhanden == True:
                    gefaelle_ende = ende[0], ende[1] +gefaelle, ende[2] +math.sin(math.radians(gefahellewinkel))* gefaelle
                    line_ende_gefaelle = Line.new(dxfattribs={"start": ende,"end": gefaelle_ende})
                    line_ende_gefaelle.dxf.layer = "6-SP"
                    copy_ende = line_ende_gefaelle.copy()
                    copy_ende.translate(-x,-y,-hoehe_vario)
                    block.add_entity(copy_ende)
                    ende = gefaelle_ende
                elif umlenk_vorhanden == True:
                    gefaelle_start = start[0], start[1] -gefaelle, start[2] -math.sin(math.radians(gefahellewinkel)) * gefaelle
                    line_start_gefaelle = Line.new(dxfattribs={"start": start,"end": gefaelle_start})
                    line_start_gefaelle.dxf.layer = "6-SP"
                    copy_start = line_start_gefaelle.copy()
                    copy_start.translate(-x,-y,-hoehe_vario)
                    block.add_entity(copy_start)
                    start = gefaelle_start

            # Importieren und setzen der UMlenkungstation oder Motorstation falls nötig
            block_Vario_Umlenkstation_500mm ="Vario_Umlenkstation_500mm"
            block_Vario_Motorstation_500mm = "Vario_Motorstation_500mm"
            plant2dxf.import_block( block_Vario_Motorstation_500mm, lib_doc, doc)
            plant2dxf.import_block( block_Vario_Umlenkstation_500mm , lib_doc, doc)
            layer_motor, color_motor = plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Motorstation_500mm)
            layer_umlenk, color_umlenk = plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Umlenkstation_500mm)
            block_Vario_Motorstation_500mm =  plant2dxf.dreh_block( block_Vario_Motorstation_500mm, doc,lib_doc,math.radians(winkel_motor))
            block_Vario_Umlenkstation_500mm = plant2dxf.dreh_block( block_Vario_Umlenkstation_500mm ,  doc,lib_doc,math.radians(winkel_umlenk))
            if umlenk_vorhanden == True:
                block.add_blockref(block_Vario_Umlenkstation_500mm,(start[0]  -x,start[1] -y - umlenk_offset_x/2, start[2] - hoehe_vario -umlenk_offset_z/2 ),dxfattribs={"rotation": 270,"layer": layer_umlenk,"color": color_umlenk})
                start_Umlenkstation_VP = start[0] - vario_abstand, start[1] -500 *math.cos(math.radians(-winkel_umlenk))+ math.sin(math.radians(-winkel_umlenk))* -45,start[2] + math.sin(math.radians(-winkel_umlenk))*500+ math.cos(math.radians(-winkel_umlenk))*-45
                start = (start[0] ,start[1] - umlenk_offset_x,start[2] -umlenk_offset_z)
            elif winkel == 3:
                start_Umlenkstation_VP = start[0] - vario_abstand, start[1]+ winkel_VP_offset_vorne[0],start[2] -winkel_VP_offset_vorne[2]
            if motor_vorhanden == True:
                block.add_blockref(block_Vario_Motorstation_500mm, (ende[0]-x , ende[1] + motor_offset_x/2 -y ,ende[2] - hoehe_vario + motor_offset_z/2),dxfattribs={"rotation": 270,"layer": layer_motor,"color": color_motor})
                ende_Motor_VP = ende[0] - vario_abstand, ende[1] +500 *math.cos(math.radians(-winkel_motor))+ math.sin(math.radians(-winkel_motor))* -45,ende[2] - math.sin(math.radians(-winkel_motor))*500+ math.cos(math.radians(-winkel_motor))*-45

                ende = ende[0]  , ende[1] + motor_offset_x,ende[2] +motor_offset_z
            elif winkel == 3:
                ende_Motor_VP = ende[0] - vario_abstand, ende[1]- winkel_VP_offset_vorne[0] ,ende[2] - winkel_VP_offset_hinten[2]
            if winkel != 3:
                winkel_core = int(config.get("Ils 2.0 core winkel","winkel_boegen"))
                winkel_minus = winkel - winkel_core
                block_Vario_Bogen_auf = (f"Vario_Bogen_auf_{winkel_minus}°")
                block_Vario_Bogen_ab = (f"Vario_Bogen_ab_{winkel_minus}°")
                ab_attrib =plant2dxf.import_block( block_Vario_Bogen_ab , lib_doc, doc)
                auf_attrib =plant2dxf.import_block( block_Vario_Bogen_auf, lib_doc, doc)
                layer_auf,color_auf = plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Bogen_auf)
                layer_ab,color_ab =plant2dxf.get_insert_color_layer(lib_doc,block_Vario_Bogen_ab)
                block_Vario_Bogen_ab = plant2dxf.dreh_block( block_Vario_Bogen_ab, doc,lib_doc, math.radians(winkel_core))
                block_Vario_Bogen_auf= plant2dxf.dreh_block( block_Vario_Bogen_auf, doc,lib_doc, math.radians(winkel))
                Vario_Bogen_auf_Delta_SP_0  = list(float(att)for att in re.split(r"[;,]", auf_attrib["DELTA_SP_0"]))
                Vario_Bogen_auf_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_SP_1"]))
                Vario_Bogen_ab_Delta_SP_0  = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_0"]))
                Vario_Bogen_ab_Delta_SP_1  = list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_SP_1"]))
                Vario_Bogen_auf_Delta_VP_0 = list(float(att) for att in re.split(r"[;,]", auf_attrib["DELTA_VP_0"]))
                Vario_Bogen_ab_Delta_VP_1= list(float(att) for att in re.split(r"[;,]", ab_attrib["DELTA_VP_1"]))
                
                Vario_Bogen_auf_Delta_SP_0 = [Vario_Bogen_auf_Delta_SP_0 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_0[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_SP_0[1],-Vario_Bogen_auf_Delta_SP_0[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_0[2] * math.cos(math.radians(winkel)) ]
                Vario_Bogen_auf_Delta_SP_1 = [Vario_Bogen_auf_Delta_SP_1 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_1[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_SP_1[1],-Vario_Bogen_auf_Delta_SP_1[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_SP_1[2] * math.cos(math.radians(winkel)) ]
                Vario_Bogen_ab_Delta_SP_0 = [Vario_Bogen_ab_Delta_SP_0 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_SP_0[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_SP_0[1],-Vario_Bogen_ab_Delta_SP_0[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_SP_0[2] * math.cos(math.radians(winkel_core)) ]
                Vario_Bogen_ab_Delta_SP_1 =[ Vario_Bogen_ab_Delta_SP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_SP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_SP_1[1],-Vario_Bogen_ab_Delta_SP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_SP_1[2] * math.cos(math.radians(winkel_core)) ]
                Vario_Bogen_auf_Delta_VP_0 = [Vario_Bogen_auf_Delta_VP_0 [0] * math.cos(math.radians(winkel))+ Vario_Bogen_auf_Delta_VP_0[2]* math.sin(math.radians(winkel)) ,Vario_Bogen_auf_Delta_VP_0[1],-Vario_Bogen_auf_Delta_VP_0[0] * math.sin(math.radians(winkel))+ Vario_Bogen_auf_Delta_VP_0[2] * math.cos(math.radians(winkel)) ]
                Vario_Bogen_ab_Delta_VP_1 = [Vario_Bogen_ab_Delta_VP_1 [0] * math.cos(math.radians(winkel_core))+ Vario_Bogen_ab_Delta_VP_1[2]* math.sin(math.radians(winkel_core)) ,Vario_Bogen_ab_Delta_VP_1[1],-Vario_Bogen_ab_Delta_VP_1[0] * math.sin(math.radians(3))+ Vario_Bogen_ab_Delta_VP_1[2] * math.cos(math.radians(winkel_core)) ]
                
                # negative Zahlen für x und y positive setzen, damit man weniger nachdenken muss (theoretisch ist SP0 x immer negative und SP1 immer positive aber dies vereinfacht die konsistenz der Werte wann ich was addieren oder subtrahieren muss)

                for i, wert  in enumerate(Vario_Bogen_auf_Delta_SP_0):
                        if i< 2 and wert < 0:
                            Vario_Bogen_auf_Delta_SP_0[i] = abs(wert)
                for i, wert in enumerate(Vario_Bogen_auf_Delta_SP_1):
                    if i< 2 and  wert< 0:
                        Vario_Bogen_auf_Delta_SP_1[i] = abs(wert)
                for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_0):
                    if i< 2 and  wert< 0:
                        Vario_Bogen_ab_Delta_SP_0[i] = abs(wert)
                for i, wert in enumerate(Vario_Bogen_ab_Delta_SP_1):
                    if i< 2 and  wert< 0:
                        Vario_Bogen_ab_Delta_SP_1[i] = abs(wert)
                for i, wert in enumerate(Vario_Bogen_auf_Delta_VP_0):
                    if i< 2 and  wert< 0:
                        Vario_Bogen_auf_Delta_VP_0[i] = abs(wert)
                for i, wert in enumerate(Vario_Bogen_ab_Delta_VP_1):
                    if i< 2 and  wert< 0:
                        Vario_Bogen_ab_Delta_VP_1[i] = abs(wert)

                #einfügen des auf blockes und veränderund der start Punktes dementsprechend und erstellung von startVP für die VARIO linie
                block.add_blockref(block_Vario_Bogen_ab, (start[0]-x,start[1]-y- Vario_Bogen_ab_Delta_SP_0[0], start[2]- hoehe_vario- Vario_Bogen_ab_Delta_SP_0[2]),dxfattribs={"rotation": 270,"layer": layer_ab,"color": color_ab})
                start_VP = start[0] -Vario_Bogen_ab_Delta_VP_1[1],start[1]- Vario_Bogen_ab_Delta_VP_1[0]- Vario_Bogen_ab_Delta_SP_0[0] ,start[2]+Vario_Bogen_ab_Delta_VP_1[2]-Vario_Bogen_ab_Delta_SP_0[2]

                start =(start[0], start[1]- Vario_Bogen_ab_Delta_SP_0[0]- Vario_Bogen_ab_Delta_SP_1[0],start[2]-Vario_Bogen_ab_Delta_SP_0[2]+Vario_Bogen_ab_Delta_SP_1[2])
                
                #einfügen des auf blockes und veränderund der ende Punktes dementsprechend und erstellung von endeVP für die VARIO linie
                block.add_blockref(block_Vario_Bogen_auf, (ende[0]-x,ende[1]-y+ Vario_Bogen_auf_Delta_SP_1[0],ende[2]-hoehe_vario -Vario_Bogen_auf_Delta_SP_1[2]),dxfattribs={"rotation": 270,"layer": layer_auf,"color": color_auf})
                ende_VP = (ende[0] -Vario_Bogen_auf_Delta_VP_0[1], ende[1] + Vario_Bogen_auf_Delta_VP_0[0]+ Vario_Bogen_auf_Delta_SP_1[0],ende[2]+ Vario_Bogen_auf_Delta_VP_0[2]- Vario_Bogen_auf_Delta_SP_1[2])
                ende = (ende[0],ende[1]+ Vario_Bogen_auf_Delta_SP_1[0]+ Vario_Bogen_auf_Delta_SP_0[0],ende[2]- Vario_Bogen_auf_Delta_SP_1[2]+ Vario_Bogen_auf_Delta_SP_0[2])
            
                # Erstellung der VARIO Line

                line_VP = Line.new(dxfattribs={"start":start_VP,"end": ende_VP})
                line_VP.dxf.layer = "VARIO"
                copy_VP = line_VP.copy()

                copy_VP.translate(-x,-y,-hoehe_vario)
                block.add_entity(copy_VP)
                # Erstellung der zwischen Line

                line = Line.new(dxfattribs={"start":start,"end":ende })
                line.dxf.layer = "6-SP"
                copy = line.copy()
                copy.translate(-x,-y,-hoehe_vario)
                block.add_entity(copy)

            elif winkel == 3:
                # Nur erstellung der zwischen und Vario linie weil der Bogen hier nicht nötig ist
                line_VP = Line.new(dxfattribs={"start": start_Umlenkstation_VP,"end": ende_Motor_VP})
                line_VP.dxf.layer = "VARIO"
                copy_VP = line_VP.copy()
                copy_VP.translate(-x,-y,-hoehe_vario)
                block.add_entity(copy_VP)
                line = Line.new(dxfattribs={"start": start, "end": ende})
                line.dxf.layer = "6-SP"

                copy= line.copy()

                copy.translate(-x,-y,-hoehe_vario)
                block.add_entity(copy)

    # Erstellung einer Spiegelung an der y achse (hier wird es ausgeführt durch -x) für die erstellung des Förderers mit den vario stationen links
        matrix = Matrix44.scale(-1,1,1)
        block_links = doc.blocks.new(block_name_links, base_point=(0,0,0))
        #spiegelung aller elemente außer es und as elemente falls diese vorhanden sind um die logik wie die platziert werden nicht zu zerstören
        for entity in block:
            clone= entity.copy()
            if entity.dxftype() == "INSERT":
                if (entity.dxf.name.startswith("400102632_ES-Element_90_links") or entity.dxf.name.startswith("200000146_ES-Element_90_rechts")  or
                    entity.dxf.name.startswith("200000241_AS-Element_90_rechts") or entity.dxf.name.startswith("200000217_AS-Element_90_links")
                    ):
                    block_links.add_entity(clone)
                else:
                    clone.transform(matrix)
                    block_links.add_entity(clone)
            else:
                clone.transform(matrix)
                block_links.add_entity(clone)