# -*- coding: utf-8 -*-
import rhinoscriptsyntax as rs
import math
import random as ran

rs.EnableRedraw(False)
rs.DeleteObjects(rs.AllObjects())

def generiere_gebaeude(basis, hauptachse, nebenachse, schichten, dicke, luft, verformung, rohr_radius, versatz, stuetzen, min_groesse):
    ellipsen_objekte = []  
    ellipsen_punkte = []
    gebaeude_objekte = [] 
    ebenen = []

    for i in range(schichten):
        # Hoehe und Verformung
        z = basis[2] + i * (dicke + luft)
        skalierung = 1 + verformung * math.sin(2 * math.pi * i / schichten)
        verjuengung = 1 - i / schichten

        # Berechnete Achsenlaengen
        aktuelle_hauptachse = hauptachse * skalierung * verjuengung - versatz
        aktuelle_nebenachse = nebenachse * skalierung * verjuengung - versatz
        
        if aktuelle_hauptachse < min_groesse or aktuelle_nebenachse < min_groesse:
            break  # Zu kleine Ellipsen ueberspringen
        
        # Ellipse erstellen
        zentrum = (basis[0], basis[1], z)
        ebene = rs.PlaneFromFrame(zentrum, (1, 0, 0), (0, 1, 0))
        ellipse = rs.AddEllipse(ebene, aktuelle_hauptachse / 2, aktuelle_nebenachse / 2)
#        ran_rot = ran.randint(-10,10)
#        rs.RotateObject(ellipse, (0,0,0), ran_rot)
        if ellipse:
            #  Griffe optional
            rs.EnableObjectGrips(ellipse)  
            grips = rs.ObjectGripLocations(ellipse)  
            if grips:
                for i in range(len(grips)):
                    
                    if i % 2 == 0:  
                        neue_position = (
                            grips[i][0] + ran.uniform(0, 0.2),  
                            grips[i][1] + ran.uniform(0, 0.2),  
                            grips[i][2]  
                        )
                        grips[i] = neue_position 
                rs.ObjectGripLocations(ellipse, grips)  
            rs.EnableObjectGrips(ellipse, False) 
            
            ellipsen_objekte.append(ellipse)
            gebaeude_objekte.append(ellipse)  
            punkte = rs.DivideCurve(ellipse, stuetzen)
            ellipsen_punkte.append(punkte)
            # Extrusion der Ebene
            extrudiert = rs.ExtrudeCurveStraight(ellipse, zentrum, (zentrum[0], zentrum[1], z + dicke))
            if extrudiert:
                rs.CapPlanarHoles(extrudiert)
                ebenen.append(extrudiert)

    # Fassade 
    for j in range(stuetzen):
        pfade = [ellipsen_punkte[k][j] for k in range(len(ellipsen_punkte))]
        if len(pfade) > 1:
            kurve = rs.AddInterpCurve(pfade)
            if kurve:
                rohr = rs.AddPipe(kurve, 0, rohr_radius, cap=2)
                if rohr:
                    gebaeude_objekte.append(rohr)
                # Kurve loeschen Rohr behalten
                rs.DeleteObject(kurve)

    # Ellipsen loeschen
    for ellipse in ellipsen_objekte:
        rs.DeleteObject(ellipse)

    return (gebaeude_objekte, ebenen)


#  Gebaeude 1
(gebaeude_1, ebenen_1) = generiere_gebaeude(
    basis=(0, 0, 0),
    hauptachse=11,
    nebenachse=10,
    schichten=25,
    dicke=0.03,
    luft=0.2,
    verformung=0.6,
    rohr_radius=0.01,
    versatz=5,
    stuetzen=130,
    min_groesse=1)

box_1 = rs.BoundingBox(ebenen_1)

#  Gebaeude 2
(gebaeude_2, ebenen_2) = generiere_gebaeude(
    basis=(0.5, 0, box_1[4][2]),  
    hauptachse=8,
    nebenachse=9,
    schichten=25,
    dicke=0.04,
    luft=0.12,
    verformung=0.5,
    rohr_radius=0.01,
    versatz=4,
    stuetzen=120,
    min_groesse=1)

rs.RotateObjects(gebaeude_2 + ebenen_2, (0, 0, 0), 20, (0, 0, 1))

box_2 = rs.BoundingBox(ebenen_2)

#  Gebaeude 3
(gebaeude_3, ebenen_3) = generiere_gebaeude(
    basis=(0, 0.8, box_2[4][2]),  
    hauptachse=8,
    nebenachse=7,
    schichten=30,
    dicke=0.02,
    luft=0.12,
    verformung=1,
    rohr_radius=0.01,
    versatz=4,
    stuetzen=120,
    min_groesse=1)

rs.RotateObjects(gebaeude_3 + ebenen_3, (0, 0, 0), 20, (0, 0, 1))

box_3 = rs.BoundingBox(ebenen_3)

#  Gebaeude 4
(gebaeude_4, ebenen_4) = generiere_gebaeude(
    basis=(0, 0, box_3[4][2]),  
    hauptachse=6,
    nebenachse=7,
    schichten=30,
    dicke=0.02,
    luft=0.12,
    verformung=0.9,
    rohr_radius=0.01,
    versatz=4,
    stuetzen=120,
    min_groesse=1)

rs.RotateObjects(gebaeude_4 + ebenen_4, (0, 0, 0), 10, (0, 0, 1))

rs.EnableRedraw(True)