############################ HU_09 ############################
import rhinoscriptsyntax as rs
import sys, csv, ast  # csv und ast zum listen import
sys.path.append("P:\\WWW\\mraontu\\dm2")
import DM_lib as dm
#reload(dm)
rs.UnitSystem(4)  # km = 5, meters = 4, cm = 3 etc
rs.ShowGrid(None, 0)
rs.ShowGridAxes(None, 0)
rs.ViewDisplayMode(rs.CurrentView(), "shaded")
rs.DeleteObjects(rs.AllObjects())
rs.EnableRedraw(False)
############################

### Datei importieren ###
def import_closed_curves(file_path="P:\\WWW\\mraontu\\dm2\\09\\Lists\\kontur_curves.csv", layer_name="Imported_Kontur_Curves"):
    if not rs.IsLayer(layer_name):
        rs.AddLayer(layer_name, [0, 0, 0])

    with open(file_path, "r") as f:
        reader = csv.reader(f)
        for row in reader:
            points = [ast.literal_eval(pt) for pt in row]  # string-coords in listen
            crv = rs.AddCurve(points, degree=1)  # Kurven Grad einstellen 
            if crv:
                rs.ObjectLayer(crv, layer_name)

    print("fin import [file_path]")

import_closed_curves("P:\\WWW\\mraontu\\dm2\\09\\Lists\\kontur_curves.csv", "Imported_Kontur_Curves")  # Datei Pfad P:\WWW\mraontu\dm2\09\Lists

### Get main crv  ###
curves = rs.ObjectsByLayer("Imported_Kontur_Curves")
ref_punkt = [-6517.71, 69205.71, 0]
main_curve_layer = "main_curve"

if curves:
    main_crv = min(curves, key=lambda crv: rs.Distance(ref_punkt, rs.CurveAreaCentroid(crv)[0]))
    
    if not rs.IsLayer(main_curve_layer):
        rs.AddLayer(main_curve_layer, [255, 0, 0])# layer main_curve
    rs.ObjectLayer(main_crv, main_curve_layer)


### Get path crv for helix ###
def create_path_curves(path_crv, Eckpunkte, path_layer="path_curves", z_offset=5, divisions=6):
    if not rs.IsLayer(path_layer):
        rs.AddLayer(path_layer, [255, 0, 0])

    all_points = rs.CurvePoints(path_crv)

    base_points = [all_points[i] for i in Eckpunkte if i < len(all_points)]  # Eckpunkte

    created_curves = []
    divided_points = []

    for i in range(len(base_points) - 1):
        p1_offset = [base_points[i][0], base_points[i][1], base_points[i][2] + z_offset]
        p2_offset = [base_points[i + 1][0], base_points[i + 1][1], base_points[i + 1][2] + z_offset]

        curve = rs.AddCurve([p1_offset, p2_offset])
        if curve:
            rs.ObjectLayer(curve, path_layer)
            created_curves.append(curve)

            if divisions > 0:
                div_pts = rs.DivideCurve(curve, divisions, create_points=True)
                divided_points.extend(div_pts)

    return created_curves, divided_points  # output path_crv + div pts = helix startpts

# Parameter
Eckpunkte = [2, 3, 4, 5]  # Welche Punkte genutzt werden sollen
path_layer = "path_curve"

curves, helix_startpoints = create_path_curves(path_crv=main_crv,Eckpunkte=Eckpunkte,path_layer=path_layer, z_offset=6,divisions=5)


### Doppelhelix ###
dm.esc()
def generate_dna_helix(base_pt, spiral_size=28, z_scale_factor=1, anz_spiral=40, num_turns=4, radius=4, A_color=[0, 222, 0], B_color=[0, 150, 0], C_color=[0, 200, 0]):
    vecX = [radius, 0, 0]
    vecY = [-radius, 0, 0]
    spiral_points_1 = []
    spiral_points_2 = []
    
    # Spirale A
    for i in range(anz_spiral):
        angle = (360 / anz_spiral) * num_turns * i
        rotated_vecX = rs.VectorRotate(vecX, angle, [0, 0, 1])  # rotiert um Z
        z_shift = (i / float(anz_spiral)) * spiral_size * z_scale_factor
        rotated_vecX[2] = z_shift
        # Verschiebe relativ zu Basispunkt
        final_point = rs.VectorAdd(base_pt, rotated_vecX)
        spiral_points_1.append(final_point)
        point_A = rs.AddPoint(final_point)
        rs.ObjectLayer(point_A, "Helix")  # helix layer
        rs.ObjectColor(point_A, A_color)
    
    # Spirale B
    for i in range(anz_spiral):
        angle = (360 / anz_spiral) * num_turns * i
        rotated_vecY = rs.VectorRotate(vecY, angle, [0, 0, 1])  # rotiert um Z
        z_shift = (i / float(anz_spiral)) * spiral_size * z_scale_factor
        rotated_vecY[2] = z_shift
        # Verschiebe relativ zu Basispunkt
        final_point = rs.VectorAdd(base_pt, rotated_vecY)
        spiral_points_2.append(final_point)
        point_B = rs.AddPoint(final_point)
        rs.ObjectLayer(point_B, "Helix")  # helix layer
        rs.ObjectColor(point_B, B_color)
    
    # Verbindungen zwischen den Spiralen
    for i in range(len(spiral_points_1)):
        start = spiral_points_1[i]
        end = spiral_points_2[i]
        crv_verbindung = rs.AddLine(start, end)
        rs.ObjectLayer(crv_verbindung, "Helix_Connections")  # connections layer
        rs.ObjectColor(crv_verbindung, C_color)
    
    # crv helix
    crv_A = rs.AddCurve(spiral_points_1, 1)
    rs.ObjectLayer(crv_A, "Helix")  # helix layer
    rs.ObjectColor(crv_A, A_color)
    
    crv_B = rs.AddCurve(spiral_points_2, 1)
    rs.ObjectLayer(crv_B, "Helix")  # helix layer
    rs.ObjectColor(crv_B, B_color)
#
helix_layer = dm.newEmptyLayer("Helix", color=[0, 222, 0])                     # layer Helix
connections_layer = dm.newEmptyLayer("Helix_Connections", color=[0, 150, 0])   # layer Connections

# Doppelhelix bei Punkten
for point in helix_startpoints:
        generate_dna_helix(base_pt=point,spiral_size=28, z_scale_factor=1, anz_spiral=60, num_turns=2, radius=2, A_color=[0, 200, 20], B_color=[0, 100, 40], C_color=[0, 200, 0])


############################

rs.EnableRedraw(True)