# -*- coding: utf-8 -*-
from ezdxf.entities import Line
import math
from lib import plant2dxf
from lib import block_methoden

RADIUS = 400


def vertausch_der_höhe(objekt):
    upper_hoehe_objekt = objekt.h1
    lower_hoehe_objekt = objekt.h0
    rotation = objekt.drehung
    """Vertausch der Höhen, für ausrechnung blöcke mit as elemente oder andere Berücksichtigungen"""
    if upper_hoehe_objekt < lower_hoehe_objekt:
        hoehe2 = upper_hoehe_objekt
        upper_hoehe_objekt = lower_hoehe_objekt
        objekt.h1 = upper_hoehe_objekt
        lower_hoehe_objekt = hoehe2
        objekt.h0 = lower_hoehe_objekt
        rotation = rotation - 180
        objekt.drehung = rotation
        objekt.h1 = upper_hoehe_objekt
        objekt.h0 = lower_hoehe_objekt


def erstellung_gefaelle_block_verbunden_an_einen(
    msp,
    x,
    y,
    doc,
    lib_doc,
    upper_hoehe_gefaelle,
    lower_hoehe_gefaelle,
    hoehe_gefaelle,
    drehung0,
    laenge,
    blockname,
    config,
    hight=None,
    block_vario=None,
    vario_richtung=None,
    verbunden_höher=None,
    gefaelle_block=None,
    start=None,
    ende=None,
    mit_horizontal_verbunden=None,
    as_es_rotation=None,
):
    """Tut ein as/es element in den Block für Gefällestrecken wird auch überprüft ob nur ein as es Element vorhanden ist"""
    halbe_laenge = laenge / 2
    dy = halbe_laenge * math.cos(0)
    asoffset = float(config.get("ILS 2.0 Gefällestrecke", "asoffset"))
    esoffset = float(config.get("ILS 2.0 Gefällestrecke", "esoffset"))
    winkel_as = float(config.get("Ils 2.0 core winkel", "winkel_as"))
    winkel_es = float(config.get("Ils 2.0 core winkel", "winkel_es"))
    asoffset_y = asoffset * math.cos(math.radians(winkel_as))
    asoffset_z = asoffset * math.sin(math.radians(winkel_as))
    esoffset_y = esoffset * math.cos(math.radians(winkel_es))
    esoffset_z = esoffset * math.sin(math.radians(winkel_es))
    block_as = None
    block_es = None
    if (
        (hight == "higher" and drehung0 == "GUZS")
        or (vario_richtung == "Auf" and verbunden_höher == False and drehung0 == "GUZS")
        or (vario_richtung == "Ab" and verbunden_höher == True and drehung0 == "GUZS")
        or (
            vario_richtung == "Horizontal"
            and drehung0 == "GUZS"
            and (
                mit_horizontal_verbunden == "unten_drehung_0_or_-90"
                or mit_horizontal_verbunden == "oben_drehung_-180_or_-270"
            )
        )
    ):
        block_as = "200000241_AS-Element_90_rechts"
        block_methoden.import_block(block_as, lib_doc, doc)
        layer, color = block_methoden.get_insert_color_layer(lib_doc, block_as)

    elif (
        (hight == "lower" and drehung0 == "GUZS")
        or (vario_richtung == "Auf" and verbunden_höher == True and drehung0 == "GUZS")
        or (vario_richtung == "Ab" and verbunden_höher == False and drehung0 == "GUZS")
        or (
            vario_richtung == "Horizontal"
            and drehung0 == "GUZS"
            and (
                mit_horizontal_verbunden == "oben_drehung_0_or_-90"
                or mit_horizontal_verbunden == "unten_drehung_-180_or_-270"
            )
        )
    ):
        block_es = "200000146_ES-Element_90_rechts"
        block_methoden.import_block(block_es, lib_doc, doc)
        layer, color = block_methoden.get_insert_color_layer(lib_doc, block_es)

    elif (
        (hight == "higher" and drehung0 == "UZS")
        or (vario_richtung == "Auf" and verbunden_höher == False and drehung0 == "UZS")
        or (vario_richtung == "Ab" and verbunden_höher == True and drehung0 == "UZS")
        or (
            vario_richtung == "Horizontal"
            and drehung0 == "UZS"
            and (
                mit_horizontal_verbunden == "unten_drehung_0_or_-90"
                or mit_horizontal_verbunden == "oben_drehung_-180_or_-270"
            )
        )
    ):
        block_as = "200000217_AS-Element_90_links"
        block_methoden.import_block(block_as, lib_doc, doc)
        layer, color = block_methoden.get_insert_color_layer(lib_doc, block_as)

    elif (
        (hight == "lower" and drehung0 == "UZS")
        or (vario_richtung == "Auf" and verbunden_höher == True and drehung0 == "UZS")
        or (vario_richtung == "Ab" and verbunden_höher == False and drehung0 == "UZS")
        or (
            vario_richtung == "Horizontal"
            and drehung0 == "UZS"
            and (
                mit_horizontal_verbunden == "oben_drehung_0_or_-90"
                or mit_horizontal_verbunden == "unten_drehung_-180_or_-270"
            )
        )
    ):
        block_es = "400102632_ES-Element_90_links"
        block_methoden.import_block(block_es, lib_doc, doc)
        layer, color = block_methoden.get_insert_color_layer(lib_doc, block_es)

    if block_as != None:
        block_as = block_methoden.dreh_block(
            block_as, doc, lib_doc, math.radians(winkel_as)
        )
        if vario_richtung == "Auf" or vario_richtung == "Horizontal":
            start = (x, y + dy, upper_hoehe_gefaelle)
            ende = (x, y - dy + asoffset_y, lower_hoehe_gefaelle - asoffset_z)
            block_vario.add_blockref(
                block_as,
                (
                    ende[0] - x,
                    ende[1] - asoffset_y - y,
                    ende[2] - hoehe_gefaelle + asoffset_z,
                ),
                dxfattribs={"rotation": 180, "layer": layer, "color": color},
            )
            return start, ende
        elif vario_richtung == "Ab":
            start = (x, y + dy - asoffset_y, upper_hoehe_gefaelle - asoffset_z)
            ende = (x, y - dy, lower_hoehe_gefaelle)
            block_vario.add_blockref(
                block_as,
                (
                    start[0] - x,
                    start[1] + asoffset_y - y,
                    start[2] - hoehe_gefaelle + asoffset_z,
                ),
                dxfattribs={"layer": layer, "color": color},
            )
            return start, ende

        if laenge >= asoffset:
            start[1] = start[1] - asoffset_y
            start[2] = start[2] - asoffset_z
            line = Line.new(dxfattribs={"start": start, "end": ende})
            line.dxf.layer = "6-SP"
            copy = line.copy()
            copy.translate(-x, -y, -hoehe_gefaelle)
            gefaelle_block.add_entity(copy)
            gefaelle_block.add_blockref(
                block_as,
                (
                    start[0] - x,
                    start[1] + asoffset_y - y,
                    start[2] - hoehe_gefaelle + asoffset_z,
                ),
                dxfattribs={"layer": layer, "color": color},
            )
            return False
        else:
            msp.add_blockref(
                block_as,
                (start[0], start[1] + asoffset_y, upper_hoehe_gefaelle),
                dxfattribs={"layer": layer, "color": color},
            )
            return True
    elif block_es != None:
        block_es = block_methoden.dreh_block(
            block_es, doc, lib_doc, math.radians(winkel_es)
        )
        if vario_richtung == "Auf" or vario_richtung == "Horizontal":
            start = (x, y + dy - esoffset_y, upper_hoehe_gefaelle + esoffset_z)
            ende = (x, y - dy, lower_hoehe_gefaelle)
            block_vario.add_blockref(
                block_es,
                (
                    start[0] - x,
                    start[1] + esoffset_y - y,
                    start[2] - hoehe_gefaelle - esoffset_z,
                ),
                dxfattribs={"rotation": 180, "layer": layer, "color": color},
            )
            return start, ende
        elif vario_richtung == "Ab":
            start = (x, y + dy, upper_hoehe_gefaelle)
            ende = (x, y - dy + esoffset_y, lower_hoehe_gefaelle + esoffset_z)
            block_vario.add_blockref(
                block_es,
                (
                    ende[0] - x,
                    ende[1] - esoffset_y - y,
                    ende[2] - hoehe_gefaelle - esoffset_z,
                ),
                dxfattribs={"rotation": as_es_rotation, "layer": layer, "color": color},
            )
            return start, ende

        if laenge >= esoffset:
            ende[1] = ende[1] + esoffset_y
            ende[2] = ende[2] + esoffset_z
            line = Line.new(dxfattribs={"start": start, "end": ende})
            line.dxf.layer = "6-SP"
            copy = line.copy()
            copy.translate(-x, -y, -hoehe_gefaelle)
            gefaelle_block.add_entity(copy)
            gefaelle_block.add_blockref(
                block_es,
                (
                    ende[0] - x,
                    ende[1] - esoffset_y - y,
                    ende[2] - hoehe_gefaelle - esoffset_z,
                ),
                dxfattribs={"layer": layer, "color": color},
            )
            return False
        else:
            msp.add_blockref(
                block_es,
                (ende[0], ende[1] + esoffset_y, lower_hoehe_gefaelle),
                dxfattribs={"rotation": as_es_rotation, "layer": layer, "color": color},
            )
            return True


def gefaellegerade_erstellung(
    objekt,
    doc,
    lib_doc,
    richtung2,
    drehung0,
    drehung1,
    hight_position,
    blockname,
    config,
    block_vario=None,
    am_kreisel=None,
    erster_kreisel_höher=None,
    y1=None,
    z1=None,
):
    """erstellung des blockes falls die gefaelle strecke mit einem kreisel verbunden ist, mehrere variation von selben weil diese nötig sind sobald man die richtigen inserts bekommen"""
    if hasattr(objekt, "foerderer_richtung"):
        foerder_richtung = objekt.foerderer_richtung
    else:
        foerder_richtung = None

    laenge = objekt.laenge
    upper_hoehe_gefaelle = objekt.h1
    lower_hoehe_gefaelle = objekt.h0
    x = objekt.x
    y = objekt.y
    hoehe_gefaelle = objekt.hight_zwischen

    asoffset = float(config.get("ILS 2.0 Gefällestrecke", "asoffset"))
    esoffset = float(config.get("ILS 2.0 Gefällestrecke", "esoffset"))
    winkel_as = float(config.get("Ils 2.0 core winkel", "winkel_as"))
    winkel_es = float(config.get("Ils 2.0 core winkel", "winkel_es"))
    asoffset_y = asoffset * math.cos(math.radians(winkel_as))
    asoffset_z = asoffset * math.sin(math.radians(winkel_as))
    esoffset_y = esoffset * math.cos(math.radians(winkel_es))
    esoffset_z = esoffset * math.sin(math.radians(winkel_es))
    block_as = None
    block_es = None
    halbe_laenge = laenge / 2
    dy = halbe_laenge * math.cos(0)
    if upper_hoehe_gefaelle < lower_hoehe_gefaelle:
        middle_hoehe = upper_hoehe_gefaelle
        upper_hoehe_gefaelle = lower_hoehe_gefaelle
        lower_hoehe_gefaelle = middle_hoehe
    # Entnehmung welches as/es element man braucht wenn es mit zwei Kreisel verbunden ist aber ein Kreisel direkt am Kopf hängt
    if richtung2 != "DEFAULT" or am_kreisel != None:
        # Schaut bei gleicher Orentierung
        if (
            (drehung0 == "GUZS" and drehung1 == "GUZS" and hight_position == "higher")
            or (
                foerder_richtung == "Auf"
                and (
                    (am_kreisel == 1 and erster_kreisel_höher == False)
                    or (am_kreisel == 2 and erster_kreisel_höher == True)
                )
                and drehung0 == "GUZS"
                and drehung1 == "GUZS"
            )
            or (
                foerder_richtung == "Ab"
                and (
                    (am_kreisel == 1 and erster_kreisel_höher == True)
                    or (am_kreisel == 2 and erster_kreisel_höher == False)
                )
                and drehung0 == "GUZS"
                and drehung1 == "GUZS"
            )
            or
            # Schaut bei ungleicher Orentierung
            ((drehung0 == "UZS" and drehung1 == "GUZS" and hight_position == "higher"))
            or (
                foerder_richtung == "Auf"
                and (
                    (am_kreisel == 1 and erster_kreisel_höher == False)
                    or (am_kreisel == 2 and erster_kreisel_höher == True)
                )
                and (drehung0 == "GUZS" and drehung1 == "UZS")
            )
            or (
                foerder_richtung == "Ab"
                and (
                    (am_kreisel == 1 and erster_kreisel_höher == True)
                    or (am_kreisel == 2 and erster_kreisel_höher == False)
                )
                and (drehung0 == "UZS" and drehung1 == "GUZS")
            )
        ):
            block_es = "200000146_ES-Element_90_rechts"
            block_methoden.import_block(block_es, lib_doc, doc)
            layer, color = block_methoden.get_insert_color_layer(lib_doc, block_es)

        elif (
            (drehung0 == "GUZS" and drehung1 == "GUZS")
            or (am_kreisel != None and drehung0 == "GUZS" and drehung1 == "GUZS")
            or (drehung0 == "UZS" and drehung1 == "GUZS" and hight_position == "lower")
            or (
                foerder_richtung == "Auf"
                and (
                    (am_kreisel == 1 and erster_kreisel_höher == True)
                    or (am_kreisel == 2 and erster_kreisel_höher == False)
                )
                and (drehung0 == "UZS" and drehung1 == "GUZS")
            )
            or (
                foerder_richtung == "Ab"
                and (
                    (am_kreisel == 1 and erster_kreisel_höher == False)
                    or (am_kreisel == 2 and erster_kreisel_höher == True)
                )
                and (drehung0 == "GUZS" and drehung1 == "UZS")
            )
        ):
            block_as = "200000241_AS-Element_90_rechts"
            block_methoden.import_block(block_as, lib_doc, doc)
            layer, color = block_methoden.get_insert_color_layer(lib_doc, block_as)

        elif (
            (drehung0 == "UZS" and drehung1 == "UZS" and hight_position == "higher")
            or (
                foerder_richtung == "Auf"
                and (
                    (am_kreisel == 1 and erster_kreisel_höher == False)
                    or (am_kreisel == 2 and erster_kreisel_höher == True)
                )
                and drehung0 == "UZS"
                and drehung1 == "UZS"
            )
            or (
                foerder_richtung == "Ab"
                and (
                    (am_kreisel == 1 and erster_kreisel_höher == True)
                    or (am_kreisel == 2 and erster_kreisel_höher == False)
                )
                and drehung0 == "UZS"
                and drehung1 == "UZS"
            )
            or (drehung0 == "GUZS" and drehung1 == "UZS" and hight_position == "higher")
            or (
                foerder_richtung == "Auf"
                and (
                    (am_kreisel == 1 and erster_kreisel_höher == False)
                    or (am_kreisel == 2 and erster_kreisel_höher == True)
                )
                and (drehung0 == "UZS" and drehung1 == "GUZS")
            )
            or (
                foerder_richtung == "Ab"
                and (
                    (am_kreisel == 1 and erster_kreisel_höher == True)
                    or (am_kreisel == 2 and erster_kreisel_höher == False)
                )
                and (drehung0 == "GUZS" and drehung1 == "UZS")
            )
        ):

            block_es = "400102632_ES-Element_90_links"
            block_methoden.import_block(block_es, lib_doc, doc)
            layer, color = block_methoden.get_insert_color_layer(lib_doc, block_es)

        elif (
            (
                (drehung0 == "UZS" and drehung1 == "UZS")
                or (am_kreisel != None and drehung0 == "UZS" and drehung1 == "UZS")
            )
            or (drehung0 == "GUZS" and drehung1 == "UZS" and hight_position == "lower")
            or (
                foerder_richtung == "Auf"
                and (
                    (am_kreisel == 1 and erster_kreisel_höher == True)
                    or (am_kreisel == 2 and erster_kreisel_höher == False)
                )
                and (drehung0 == "GUZS" and drehung1 == "UZS")
            )
            or (
                foerder_richtung == "Ab"
                and (
                    (am_kreisel == 1 and erster_kreisel_höher == False)
                    or (am_kreisel == 2 and erster_kreisel_höher == True)
                )
                and (drehung0 == "UZS" and drehung1 == "GUZS")
            )
        ):
            block_as = "200000217_AS-Element_90_links"
            block_methoden.import_block(block_as, lib_doc, doc)
            layer, color = block_methoden.get_insert_color_layer(lib_doc, block_as)

        # Erstellt den Block
        if block_es != None:
            block_es = block_methoden.dreh_block(
                block_es, doc, lib_doc, math.radians(winkel_es)
            )
            if foerder_richtung == "Auf":
                start = (x, y + dy - esoffset_y, upper_hoehe_gefaelle + esoffset_z)
                ende = (x, y1, z1)
                block_vario.add_blockref(
                    block_es,
                    (
                        start[0] - x,
                        start[1] + esoffset_y - y,
                        start[2] - esoffset_z - hoehe_gefaelle,
                    ),
                    dxfattribs={"rotation": 180, "layer": layer, "color": color},
                )
                return start, ende
            elif foerder_richtung == "Ab":
                start = (x, y1, z1)
                ende = (x, y - dy + esoffset_y, lower_hoehe_gefaelle + esoffset_z)
                block_vario.add_blockref(
                    block_es,
                    (
                        ende[0] - x,
                        ende[1] - esoffset_y - y,
                        ende[2] - esoffset_z - hoehe_gefaelle,
                    ),
                    dxfattribs={"layer": layer, "color": color},
                )
                return start, ende
            elif am_kreisel == None and blockname not in doc.blocks:
                block = doc.blocks.new(name=blockname, base_point=(0, 0, 0))
                start = (x, y + dy, upper_hoehe_gefaelle)
                ende = (x, y - dy + esoffset_y, lower_hoehe_gefaelle + esoffset_z)
                line = Line.new(dxfattribs={"start": start, "end": ende})
                line.dxf.layer = "6-SP"
                copy = line.copy()
                copy.translate(-x, -y, -hoehe_gefaelle)
                block.add_entity(copy)
                block.add_blockref(
                    block_es,
                    (ende[0] - x, ende[1] - esoffset_y - y, ende[2] - hoehe_gefaelle),
                    dxfattribs={"layer": layer, "color": color},
                )
        if block_as != None:
            block_as = block_methoden.dreh_block(
                block_as, doc, lib_doc, math.radians(winkel_as)
            )
            if foerder_richtung == "Auf":
                start = (x, y1, z1)
                ende = (x, y - dy + asoffset_y, lower_hoehe_gefaelle)
                block_vario.add_blockref(
                    block_as,
                    (
                        ende[0] - x,
                        ende[1] - asoffset_y - y,
                        ende[2] - esoffset_z - hoehe_gefaelle,
                    ),
                    dxfattribs={"rotation": 180, "layer": layer, "color": color},
                )
                return start, ende
            elif foerder_richtung == "Ab":
                start = (x, y + dy - asoffset_y, upper_hoehe_gefaelle - asoffset_z)
                ende = (x, y1, z1)
                block_vario.add_blockref(
                    block_as,
                    (
                        start[0] - x,
                        start[1] + asoffset_y - y,
                        start[2] + asoffset_z - hoehe_gefaelle,
                    ),
                    dxfattribs={"layer": layer, "color": color},
                )
                return start, ende
            elif am_kreisel == None and blockname not in doc.blocks:
                block = doc.blocks.new(name=blockname, base_point=(0, 0, 0))
                start = (x, y + dy - asoffset_y, upper_hoehe_gefaelle - asoffset_z)
                ende = (x, y - dy, lower_hoehe_gefaelle)
                line = Line.new(dxfattribs={"start": start, "end": ende})
                line.dxf.layer = "6-SP"

                copy = line.copy()
                copy.translate(-x, -y, -hoehe_gefaelle)

                block.add_entity(copy)
                block.add_blockref(
                    block_as,
                    (
                        start[0] - x,
                        start[1] + asoffset_y - y,
                        start[2] + asoffset_z - hoehe_gefaelle,
                    ),
                )
    else:
        if (drehung0 == "GUZS" and drehung1 == "GUZS") or (
            foerder_richtung != None and drehung0 == "GUZS" and drehung1 == "GUZS"
        ):
            block_as = "200000241_AS-Element_90_rechts"
            block_methoden.import_block(block_as, lib_doc, doc)
            block_es = "200000146_ES-Element_90_rechts"
            block_methoden.import_block(block_es, lib_doc, doc)
            as_layer, as_color = block_methoden.get_insert_color_layer(
                lib_doc, block_as
            )
            es_layer, es_color = block_methoden.get_insert_color_layer(
                lib_doc, block_es
            )
        elif (
            (
                (
                    drehung0 == "GUZS"
                    and drehung1 == "UZS"
                    and hight_position == "higher"
                )
                or (
                    drehung0 == "UZS"
                    and drehung1 == "GUZS"
                    and hight_position == "lower"
                )
            )
            or (foerder_richtung == "Auf" and drehung0 == "UZS" and drehung1 == "GUZS")
            or (foerder_richtung == "Ab" and drehung0 == "GUZS" and drehung1 == "UZS")
        ):
            block_as = "200000241_AS-Element_90_rechts"
            block_methoden.import_block(block_as, lib_doc, doc)
            block_es = "400102632_ES-Element_90_links"
            block_methoden.import_block(block_es, lib_doc, doc)
            as_layer, as_color = block_methoden.get_insert_color_layer(
                lib_doc, block_as
            )
            es_layer, es_color = block_methoden.get_insert_color_layer(
                lib_doc, block_es
            )
        elif (drehung0 == "UZS" and drehung1 == "UZS") or (
            foerder_richtung != None and drehung0 == "UZS" and drehung1 == "UZS"
        ):
            block_as = "200000217_AS-Element_90_links"
            block_methoden.import_block(block_as, lib_doc, doc)
            block_es = "400102632_ES-Element_90_links"
            block_methoden.import_block(block_es, lib_doc, doc)
            as_layer, as_color = block_methoden.get_insert_color_layer(
                lib_doc, block_as
            )
            es_layer, es_color = block_methoden.get_insert_color_layer(
                lib_doc, block_es
            )
        elif (
            (
                (
                    (
                        drehung0 == "UZS"
                        and drehung1 == "GUZS"
                        and hight_position == "higher"
                    )
                    or (
                        drehung0 == "GUZS"
                        and drehung1 == "UZS"
                        and hight_position == "lower"
                    )
                )
            )
            or (foerder_richtung == "Auf" and drehung0 == "GUZS" and drehung1 == "UZS")
            or (foerder_richtung == "Ab" and drehung0 == "UZS" and drehung1 == "GUZS")
        ):

            block_as = "200000217_AS-Element_90_links"
            block_methoden.import_block(block_as, lib_doc, doc)
            block_es = "200000146_ES-Element_90_rechts"
            block_methoden.import_block(block_es, lib_doc, doc)
            as_layer, as_color = block_methoden.get_insert_color_layer(
                lib_doc, block_as
            )
            es_layer, es_color = block_methoden.get_insert_color_layer(
                lib_doc, block_es
            )
        block_as = block_methoden.dreh_block(
            block_as, doc, lib_doc, math.radians(winkel_as)
        )
        block_es = block_methoden.dreh_block(
            block_es, doc, lib_doc, math.radians(winkel_es)
        )
        halbe_laenge = laenge / 2

        dy = halbe_laenge * math.cos(0)
        if hight_position != None and blockname not in doc.blocks:
            block = doc.blocks.new(name=blockname, base_point=(0, 0, 0))
            start = (x, y + dy - asoffset_y, upper_hoehe_gefaelle - asoffset_z)
            ende = (x, y - dy + esoffset_y, lower_hoehe_gefaelle + esoffset_z)
            line = Line.new(dxfattribs={"start": start, "end": ende})
            line.dxf.layer = "6-SP"

            copy = line.copy()

            copy.translate(-x, -y, -hoehe_gefaelle)
            block.add_entity(copy)
            block.add_blockref(
                block_as,
                (
                    start[0] - x,
                    start[1] + asoffset_y - y,
                    start[2] + asoffset_z - hoehe_gefaelle,
                ),
                dxfattribs={"layer": as_layer, "color": as_color},
            )
            block.add_blockref(
                block_es,
                (
                    ende[0] - x,
                    ende[1] - esoffset_y - y,
                    ende[2] - esoffset_z - hoehe_gefaelle,
                ),
                dxfattribs={"layer": es_layer, "color": es_color},
            )
            return
        if foerder_richtung == "Auf":
            start = (x, y + dy - esoffset_y, upper_hoehe_gefaelle + esoffset_z)
            ende = (x, y - dy + asoffset, lower_hoehe_gefaelle - asoffset_z)

            block_vario.add_blockref(
                block_es,
                (
                    start[0] - x,
                    start[1] + esoffset_y - y,
                    start[2] - esoffset_z - hoehe_gefaelle,
                ),
                dxfattribs={"rotation": 180, "layer": as_layer, "color": as_color},
            )
            block_vario.add_blockref(
                block_as,
                (
                    ende[0] - x,
                    ende[1] - asoffset_y - y,
                    ende[2] + asoffset_z - hoehe_gefaelle,
                ),
                dxfattribs={"rotation": 180, "layer": es_layer, "color": es_color},
            )
            return start, ende
        elif foerder_richtung == "Ab":
            start = (x, y + dy - asoffset_y, upper_hoehe_gefaelle - asoffset_z)
            ende = (x, y - dy + esoffset_y, lower_hoehe_gefaelle + esoffset_z)

            block_vario.add_blockref(
                block_as,
                (
                    start[0] - x,
                    start[1] + asoffset_y - y,
                    start[2] + asoffset_z - hoehe_gefaelle,
                ),
                dxfattribs={"layer": as_layer, "color": as_color},
            )
            block_vario.add_blockref(
                block_es,
                (
                    ende[0] - x,
                    ende[1] - esoffset_y - y,
                    ende[2] - esoffset_z - hoehe_gefaelle,
                ),
                dxfattribs={"layer": es_layer, "color": es_color},
            )
            return start, ende


def am_kreisel_direct_verbunden(
    x,
    y,
    upper_hoehe_gefaelle,
    lower_hoehe_gefaelle,
    x0_kreisel,
    y0_kreisel,
    richtung_rad0,
    abstand0,
    dx,
    dy,
    x1_kreisel,
    y1_kreisel,
    richtung_rad1,
    abstand1,
    kreisel_verbunden=None,
    richtung0=None,
    richtung1=None,
    richtung2=None,
):
    """Schaut ob das Element direkt am Kreisle Kopf hängt"""
    if kreisel_verbunden == None:
        kreisel_verbunden = 0
    unterschiedlich = False
    am_kreisel = 0
    halbabstand0 = abstand0 / 2
    dx0 = halbabstand0 * math.cos(richtung_rad0)
    dy0 = halbabstand0 * math.sin(richtung_rad0)
    pos0_0_floor = (math.floor(x0_kreisel + dx0), math.floor(y0_kreisel + dy0))
    pos0_1_floor = (math.floor(x0_kreisel - dx0), math.floor(y0_kreisel - dy0))
    pos0_0_round = (round(x0_kreisel + dx0), round(y0_kreisel + dy0))
    pos0_1_round = (round(x0_kreisel - dx0), round(y0_kreisel - dy0))
    if x1_kreisel != None:
        halbabstand1 = abstand1 / 2
        dx1 = halbabstand1 * math.cos(richtung_rad1)
        dy1 = halbabstand1 * math.sin(richtung_rad1)
        pos1_0_floor = (math.floor(x1_kreisel + dx1), math.floor(y1_kreisel + dy1))
        pos1_1_floor = (math.floor(x1_kreisel - dx1), math.floor(y1_kreisel - dy1))
        pos1_0_round = (round(x1_kreisel + dx1), round(y1_kreisel + dy1))
        pos1_1_round = (round(x1_kreisel - dx1), round(y1_kreisel - dy1))

    # berechnung der geraden einmal abgerunden und einmal gerunden zur negirung des offsets
    start_floor = (math.floor(x + dx), math.floor(y + dy), upper_hoehe_gefaelle)
    ende_floor = (math.floor(x - dx), math.floor(y - dy), lower_hoehe_gefaelle)
    start_round = (round(x + dx), round(y + dy), upper_hoehe_gefaelle)
    ende_round = (round(x - dx), round(y - dy), lower_hoehe_gefaelle)
    # verschiebund der endpunkte der gerade in richtung von dem potentiellen Kreisel für den vergleich wieder mit floor und rundung
    abstand_fuer_kreis_start_x_floor = start_floor[0] + RADIUS, start_floor[1]
    abstand_gegen_kreis_start_x_floor = start_floor[0] - RADIUS, start_floor[1]
    abstand_fuer_kreis_start_y_floor = start_floor[0], start_floor[1] + RADIUS
    abstand_gegen_kreis_start_y_floor = start_floor[0], start_floor[1] - RADIUS
    abstand_fuer_kreis_ende_x_floor = ende_floor[0] + RADIUS, ende_floor[1]
    abstand_gegen_kreis_ende_x_floor = ende_floor[0] - RADIUS, ende_floor[1]
    abstand_fuer_kreis_ende_y_floor = ende_floor[0], ende_floor[1] + RADIUS
    abstand_gegen_kreis_ende_y_floor = ende_floor[0], ende_floor[1] - RADIUS

    abstand_fuer_kreis_start_x_round = start_round[0] + RADIUS, start_round[1]
    abstand_gegen_kreis_start_x_round = start_round[0] - RADIUS, start_round[1]
    abstand_fuer_kreis_start_y_round = start_round[0], start_round[1] + RADIUS
    abstand_gegen_kreis_start_y_round = start_round[0], start_round[1] - RADIUS
    abstand_fuer_kreis_ende_x_round = ende_round[0] + RADIUS, ende_round[1]
    abstand_gegen_kreis_ende_x_round = ende_round[0] - RADIUS, ende_round[1]
    abstand_fuer_kreis_ende_y_round = ende_round[0], ende_round[1] + RADIUS
    abstand_gegen_kreis_ende_y_round = ende_round[0], ende_round[1] - RADIUS
    if richtung0 != None and richtung0 != None:
        if richtung0 != richtung1 and kreisel_verbunden == 1:
            if (
                (abstand_fuer_kreis_start_y_floor == pos0_0_floor)
                or (abstand_fuer_kreis_start_y_floor == pos0_1_floor)
                or (abstand_gegen_kreis_start_y_floor == pos0_0_floor)
                or (abstand_gegen_kreis_start_y_floor == pos0_1_floor)
                or (abstand_fuer_kreis_ende_y_floor == pos0_0_floor)
                or (abstand_fuer_kreis_ende_y_floor == pos0_1_floor)
                or (abstand_gegen_kreis_ende_y_floor == pos0_0_floor)
                or (abstand_gegen_kreis_ende_y_floor == pos0_1_floor)
                or (abstand_fuer_kreis_start_y_round == pos0_0_round)
                or (abstand_fuer_kreis_start_y_round == pos0_1_round)
                or (abstand_gegen_kreis_start_y_round == pos0_0_round)
                or (abstand_gegen_kreis_start_y_round == pos0_1_round)
                or (abstand_fuer_kreis_ende_y_round == pos0_0_round)
                or (abstand_fuer_kreis_ende_y_round == pos0_1_round)
                or (abstand_gegen_kreis_ende_y_round == pos0_0_round)
                or (abstand_gegen_kreis_ende_y_round == pos0_1_round)
                or (abstand_fuer_kreis_start_y_floor == pos1_0_floor)
                or (abstand_fuer_kreis_start_y_floor == pos1_1_floor)
                or (abstand_gegen_kreis_start_y_floor == pos1_0_floor)
                or (abstand_gegen_kreis_start_y_floor == pos1_1_floor)
                or (abstand_fuer_kreis_ende_y_floor == pos1_0_floor)
                or (abstand_fuer_kreis_ende_y_floor == pos1_1_floor)
                or (abstand_gegen_kreis_ende_y_floor == pos1_0_floor)
                or (abstand_gegen_kreis_ende_y_floor == pos1_1_floor)
                or (abstand_fuer_kreis_start_y_round == pos1_0_round)
                or (abstand_fuer_kreis_start_y_round == pos1_1_round)
                or (abstand_gegen_kreis_start_y_round == pos1_0_round)
                or (abstand_gegen_kreis_start_y_round == pos1_1_round)
                or (abstand_fuer_kreis_ende_y_round == pos1_0_round)
                or (abstand_fuer_kreis_ende_y_round == pos1_1_round)
                or (abstand_gegen_kreis_ende_y_round == pos1_0_round)
                or (abstand_gegen_kreis_ende_y_round == pos1_1_round)
            ):
                richtung2 = "Vertikal"
                unterschiedlich = True

            else:
                richtung2 = "Horizontal"
            unterschiedlich = True
            return richtung2, unterschiedlich
        return richtung2, unterschiedlich

    # vergleich mit einem kreisel von zwei
    if (
        (abstand_fuer_kreis_start_x_floor == pos0_0_floor)
        or (abstand_fuer_kreis_start_x_floor == pos0_1_floor)
        or (abstand_gegen_kreis_start_x_floor == pos0_0_floor)
        or (abstand_gegen_kreis_start_x_floor == pos0_1_floor)
        or (abstand_fuer_kreis_ende_x_floor == pos0_0_floor)
        or (abstand_fuer_kreis_ende_x_floor == pos0_1_floor)
        or (abstand_gegen_kreis_ende_x_floor == pos0_0_floor)
        or (abstand_gegen_kreis_ende_x_floor == pos0_1_floor)
        or (abstand_fuer_kreis_start_y_floor == pos0_0_floor)
        or (abstand_fuer_kreis_start_y_floor == pos0_1_floor)
        or (abstand_gegen_kreis_start_y_floor == pos0_0_floor)
        or (abstand_gegen_kreis_start_y_floor == pos0_1_floor)
        or (abstand_fuer_kreis_ende_y_floor == pos0_0_floor)
        or (abstand_fuer_kreis_ende_y_floor == pos0_1_floor)
        or (abstand_gegen_kreis_ende_y_floor == pos0_0_floor)
        or (abstand_gegen_kreis_ende_y_floor == pos0_1_floor)
        or (abstand_fuer_kreis_start_x_round == pos0_0_round)
        or (abstand_fuer_kreis_start_x_round == pos0_1_round)
        or (abstand_gegen_kreis_start_x_round == pos0_0_round)
        or (abstand_gegen_kreis_start_x_round == pos0_1_round)
        or (abstand_fuer_kreis_ende_x_round == pos0_0_round)
        or (abstand_fuer_kreis_ende_x_round == pos0_1_round)
        or (abstand_gegen_kreis_ende_x_round == pos0_0_round)
        or (abstand_gegen_kreis_ende_x_round == pos0_1_round)
        or (abstand_fuer_kreis_start_y_round == pos0_0_round)
        or (abstand_fuer_kreis_start_y_round == pos0_1_round)
        or (abstand_gegen_kreis_start_y_round == pos0_0_round)
        or (abstand_gegen_kreis_start_y_round == pos0_1_round)
        or (abstand_fuer_kreis_ende_y_round == pos0_0_round)
        or (abstand_fuer_kreis_ende_y_round == pos0_1_round)
        or (abstand_gegen_kreis_ende_y_round == pos0_0_round)
        or (abstand_gegen_kreis_ende_y_round == pos0_1_round)
    ):
        kreisel_verbunden = kreisel_verbunden + 1
        # setzung auf kreisel 1 für spätere ausrechnung der geraden form
        am_kreisel = 1
    if x1_kreisel == None:
        return am_kreisel, kreisel_verbunden

    if (
        (abstand_fuer_kreis_start_x_floor == pos1_0_floor)
        or (abstand_fuer_kreis_start_x_floor == pos1_1_floor)
        or (abstand_gegen_kreis_start_x_floor == pos1_0_floor)
        or (abstand_gegen_kreis_start_x_floor == pos1_1_floor)
        or (abstand_fuer_kreis_ende_x_floor == pos1_0_floor)
        or (abstand_fuer_kreis_ende_x_floor == pos1_1_floor)
        or (abstand_gegen_kreis_ende_x_floor == pos1_0_floor)
        or (abstand_gegen_kreis_ende_x_floor == pos1_1_floor)
        or (abstand_fuer_kreis_start_y_floor == pos1_0_floor)
        or (abstand_fuer_kreis_start_y_floor == pos1_1_floor)
        or (abstand_gegen_kreis_start_y_floor == pos1_0_floor)
        or (abstand_gegen_kreis_start_y_floor == pos1_1_floor)
        or (abstand_fuer_kreis_ende_y_floor == pos1_0_floor)
        or (abstand_fuer_kreis_ende_y_floor == pos1_1_floor)
        or (abstand_gegen_kreis_ende_y_floor == pos1_0_floor)
        or (abstand_gegen_kreis_ende_y_floor == pos1_1_floor)
        or (abstand_fuer_kreis_start_x_round == pos1_0_round)
        or (abstand_fuer_kreis_start_x_round == pos1_1_round)
        or (abstand_gegen_kreis_start_x_round == pos1_0_round)
        or (abstand_gegen_kreis_start_x_round == pos1_1_round)
        or (abstand_fuer_kreis_ende_x_round == pos1_0_round)
        or (abstand_fuer_kreis_ende_x_round == pos1_1_round)
        or (abstand_gegen_kreis_ende_x_round == pos1_0_round)
        or (abstand_gegen_kreis_ende_x_round == pos1_1_round)
        or (abstand_fuer_kreis_start_y_round == pos1_0_round)
        or (abstand_fuer_kreis_start_y_round == pos1_1_round)
        or (abstand_gegen_kreis_start_y_round == pos1_0_round)
        or (abstand_gegen_kreis_start_y_round == pos1_1_round)
        or (abstand_fuer_kreis_ende_y_round == pos1_0_round)
        or (abstand_fuer_kreis_ende_y_round == pos1_1_round)
        or (abstand_gegen_kreis_ende_y_round == pos1_0_round)
        or (abstand_gegen_kreis_ende_y_round == pos1_1_round)
    ):
        kreisel_verbunden = kreisel_verbunden + 1
        am_kreisel = 2
    return am_kreisel, kreisel_verbunden