#! python3

import rhinoscriptsyntax as rs
import math as math
rs.DeleteObjects(rs.AllObjects())


# Parameter ###########################################################################################################################################################################
rad = 2535.257                                              #Radius der Grundmauer
w_height = 1000                                          #Höhe der Grundmauer
wall_width = 60                                             #Dicke der Grundmauer
cor_num = 7                                                #Anzahl der Türme
cor_num *= 2                                                #gibt an, dass cor_num/2 gleich Anzahl der Türme ist
radius_difference = 500                                     #gibt an, wie tief die äußeren Türme sind
tower_slope = 1200                                          #gibt an, um wie viel die inneren Türme nach innen abfallen
inner_towers_rad = 1000                                     # Radius der inneren Türme
inner_tower_height = 3000                                   #Höhe der inneren Türme
inner_tower_lenght = 700                                   #Länge der inneren Türme
inner_tower_width = 300                                     #Breite der inneren Türme
inner_tower_roof_height = 400                              #gibt Neigung der Öffnungsseite der inneren Türme an
inner_tower_roof_lenght_divider = 4                         #bestimmt die Größe der Öffnung der inneren Türme

side1 = 0
side2 = 0
# Funktionen, um die Grundmauer aufzubauen #############################################################################################################################################################################
def CreatePointFromAngle(radius, angle, z_cord):

    x = radius * math.cos(angle * (math.pi/180))
    y = radius * math.sin(angle * (math.pi/180))
    return [x, y, z_cord]

def break_the_cycle(base, len1, len2, offset, height):
    points = []
    for i in range(-2, 2):

        ymod = -1 if i < 0 else 1
        xmod = 1 if i % 2 == 0 else 0

        point = [base[0] + ((len1/2 * xmod) + (len2/2 * xmod - 1)), base[1] + offset/2 * ymod,base[2] + (height / 2 * (ymod + 1))]
        points.append(point)

    temp = points[3]
    points[3] = points[2]
    points[2] = temp
    points.append(points[0])
    return points

def CreatePolygon(base, radius, cor_num):
    points = []
    angle = 360/cor_num

    for i in range(0,cor_num+1):
        currentangle = angle * i
        points.append(CreatePointFromAngle(radius, currentangle, base[2]))
    
    return points

def CreateFoundation(base, inner_radius, outer_radius, cor_num):
    angle = 360/cor_num
    points = []
    lines = []
    for i in range(0, cor_num):
        point = [0,0]
        for temp in range(1,3):
            radius = inner_radius if temp % 2 == 0 else outer_radius
            currentangle = angle * i
            point[temp - 1] = (CreatePointFromAngle(radius, currentangle, base[2]))

        points.append(point)
        lines.append(rs.AddLine(point[0], point[1]))
    	
    for p in range(0, cor_num):
        index = 0 if p % 2 == 0 else 1
        p2_i = p + 1 if p < cor_num - 1 else 0
        p1 = points[p][index]
        p2 = points[p2_i][index]
        lines.append(rs.AddLine(p1,p2))

    global side1
    global side2
    side2 = rs.Distance(points[0][0], points[1][0]) - 2
    side1 = rs.Distance(points[0][1], points[1][1]) - 2
    return rs.JoinCurves(lines, True)

inner = CreateFoundation((0,0,w_height), rad , rad + radius_difference, cor_num)
outer = CreateFoundation((0,0,w_height), rad , rad + radius_difference, cor_num)
outer = rs.OffsetCurve(outer, [1, 1, 0], wall_width)
rs.AddLoftSrf([inner,outer])
s1 = rs.ExtrudeCurveStraight(inner, (0,0,w_height), (0,0, 0))
s2 = rs.ExtrudeCurveStraight(outer, (0,0,w_height), (0,0, 0))
testy = rs.JoinSurfaces({s1,s2}, True)
polygon = CreatePolygon((0,0,w_height), rad, cor_num)
notquitethere = rs.AddPolyline(polygon)
quitethere = rs.MeshPolyline(notquitethere)
angle = math.radians(360/cor_num)

# Funktionen, um Innen- und Außentürme und das Dach aufzubauen #################################################################################################################################################################################
def generate_uppert(center, width, width2, height, depth, xy_offset, z_offset):
    cx, cy, cz = center
    half_width = width/2
    half_width2 = width2 / 2
    half_depth = depth / 2

    points = [

        (cx + half_width2, cy - half_depth, cz),  # Front-bottom-left
        (cx + half_width, cy + half_depth, cz),  # Front-top-left
        (cx - half_width, cy + half_depth, cz),  # Front-top-right
        (cx - half_width2, cy - half_depth, cz),  # Front-bottom-right


        (cx + half_width2, cy - half_depth + xy_offset, cz + height + z_offset),  # Back-bottom-left
        (cx + half_width, cy + half_depth + xy_offset, cz + height),  # Back-top-left
        (cx - half_width, cy + half_depth + xy_offset, cz + height),   # Back-top-right
        (cx - half_width2, cy - half_depth + xy_offset, cz + height + z_offset)  # Back-bottom-right
    ]
    return points

def make_tower (center_pt, xsize_1, xsize_2, ysize, zsize, xy_offset, z_offset, multiplier, closed):
    box_outer = rs.AddBox(generate_uppert(center_pt, xsize_1, xsize_2, zsize, ysize, xy_offset * 0.7, z_offset))
    zsize = zsize + 80 if closed != True else zsize - 80
    box_inner = rs.AddBox(generate_uppert(center_pt, xsize_1 * multiplier, xsize_2 * multiplier, zsize, ysize - wall_width, xy_offset, z_offset))

    #rs.OffsetSurface(box_inner, -50, 0, True, True)

    return rs.BooleanDifference(box_outer, box_inner,True)

towers = []
walls = []
p1 = polygon[0]
p2 = polygon[1]
temp = rs.AddCurve((p1, p2), 0)
mid = rs.CurveMidPoint(temp)
dist = rs.Distance((0,0,0), mid) + (radius_difference/2) - wall_width*2
for i in range((int)(cor_num/2)):

    angle = ((360/cor_num)/2) + ((360/cor_num)/2) * (i * 4)
    pt = CreatePointFromAngle(dist, angle, w_height)
    pt2 = CreatePointFromAngle(inner_towers_rad, angle, w_height)
    pt3 = CreatePointFromAngle((inner_towers_rad + (inner_tower_lenght/2) + inner_tower_lenght/inner_tower_roof_lenght_divider/2), angle, w_height)
    outer_tower = make_tower(pt,side2,side1,radius_difference,w_height/4, 250, 120, 0.8, False)

    inner_tower = make_tower(pt2,inner_tower_width,inner_tower_width/2,inner_tower_lenght,inner_tower_height, 0, -tower_slope, 0.8, True)
    inner_tower2 = rs.AddBox(generate_uppert(pt3,inner_tower_width,inner_tower_width, inner_tower_height - inner_tower_roof_height,inner_tower_lenght/inner_tower_roof_lenght_divider, 0,  inner_tower_roof_height))
    inner_towerHole = rs.AddBox(generate_uppert(pt3,inner_tower_width/1.4,inner_tower_width/1.4, inner_tower_height,inner_tower_lenght/inner_tower_roof_lenght_divider/1.4, 0,  0))
    inner_tower2 = rs.BooleanDifference(inner_tower2, inner_towerHole, True)
    rs.RotateObject(outer_tower, pt, angle - 90)
    rs.RotateObject(inner_tower, pt2, angle - 90)
    rs.RotateObject(inner_tower2, pt3, angle - 90)
    towers.append(outer_tower)

for i in range((int)(cor_num/2)):
    points = []

    for x in range(2):
        angle = (360/(cor_num)) * ((i + x) * 2) + (360/cor_num/2)
        pt = CreatePointFromAngle((inner_towers_rad + inner_tower_lenght/2), angle, w_height)
        points.insert(0, pt)
        pt = CreatePointFromAngle((inner_towers_rad - inner_tower_lenght/2), angle, w_height + inner_tower_height/2)
        points.append(pt)

    points.append(points[0])
    line = rs.AddPolyline(points)
    rs.MeshPolyline(line)
    rs.DeleteObject(line)

rs.DeleteObjects([notquitethere, inner, outer, temp, line])       

#     walls.append(test[4])

# temp = walls[0]
# counter = 0
# for w in walls:
#     if(counter == 0):
#         counter += 1
#         continue

#     temp = rs.BooleanIntersection(temp, w)
#     rs.DeleteObjects(w)

# rs.DeleteObjects(walls)