import rhinoscriptsyntax as rs
import math

# delete everything and start from scratch
rs.DeleteObjects(rs.AllObjects())
rs.EnableRedraw(False)

# add base point
base_p = rs.AddPoint([0, 0, 0])

# create polygon
def create_polygon(center, num_sides, radius):
    if num_sides < 3:
        return None, None
    # calculate the angles
    angle_step = 2 * math.pi / num_sides
    vertices = []
    for i in range(num_sides):
        angle = i * angle_step
        x = center[0] + radius * math.cos(angle)
        y = center[1] + radius * math.sin(angle)
        z = center[2]
        vertices.append((x, y, z))
    # close polygon
    vertices.append(vertices[0])
    # create polygon as polyline
    polygon_id = rs.AddPolyline(vertices)
    return polygon_id, vertices

def add_line_from_polygon(vertices, line_length):
    # create sides
    start_pt = vertices[0]
    end_pt = vertices[1]
    # midpoint of the side
    midpoint = (
        (start_pt[0] + end_pt[0]) / 2,
        (start_pt[1] + end_pt[1]) / 2,
        (start_pt[2] + end_pt[2]) / 2
    )
    # add a line from midpoint
    line_end = (midpoint[0] + line_length, midpoint[1], 0)
    h_line = rs.AddLine(midpoint, line_end)
    rs.RotateObject(h_line, midpoint, 20, axis=None, copy=False)
    return midpoint, h_line 

# parameters for polygons
center = [0, 0, 0]
num_sides = 9

# radii for polygons
radii = [100, 1000, 1400]

# list of points of all polygons
polygon_points = {}

# create polygons
for radius in radii:
    polygon_id, vertices = create_polygon(center, num_sides, radius)
    if polygon_id:
        # save vertices
        polygon_points[radius] = vertices
    # add the line to the middle polygon
    midpoint_line_l = 900
    if radius == 1000:
        midpoint, h_line = add_line_from_polygon(vertices, midpoint_line_l)

# add a vertical line to the smallest polygon
smallest_polygon_points = polygon_points[100]
middle_polygon_points = polygon_points[1000]
largest_polygon_points = polygon_points[1400]

if len(smallest_polygon_points) > 3 and len(middle_polygon_points) > 3:
    start_point = smallest_polygon_points[num_sides]
    end_point = (start_point[0], start_point[1], start_point[2] + 1500)
    vertical_line_id = rs.AddLine(start_point, end_point)
    next_point = middle_polygon_points[num_sides]
    tilted_line_id = rs.AddLine(end_point, next_point)
    tilted_points = rs.DivideCurve(tilted_line_id, 2, create_points=False, return_points=True)
    if tilted_points:
        tilted_point = tilted_points[0]
        tilted_point = (
            tilted_point[0] + 770,  # move X
            tilted_point[1],        # keep Y
            tilted_point[2] - 585   # move Z
        )
        curve = rs.AddCurve([end_point, tilted_point, (middle_polygon_points[num_sides][0], middle_polygon_points[num_sides][1], 0)], degree=2)

# make petal_1 curves
p1_line1 = rs.AddLine(end_point, midpoint)
p1_line2 = rs.AddLine(midpoint, middle_polygon_points[num_sides])
p1_curves = [p1_line1, p1_line2, curve]

# create petal
petal1_1 = rs.AddNetworkSrf(p1_curves, continuity=1, edge_tolerance=0, interior_tolerance=0, angle_tolerance=0)

# mirror and rotate petals1 to create flower
petal1_2 = rs.MirrorObject(petal1_1, smallest_polygon_points[num_sides], middle_polygon_points[num_sides], copy=True)
all_petals1 = [petal1_1, petal1_2]

for i in range(num_sides):
    if i > 0:
        rotated_petals1 = rs.RotateObjects((petal1_1, petal1_2), base_p, 360 / num_sides * i, axis=None, copy=True)
        all_petals1.extend(rotated_petals1)

# create layer for petals1 with material
layer_name_1 = "Petal 1"
layer_color_1 = (191,80,255)
rs.AddLayer(layer_name_1, layer_color_1)

for petal1 in all_petals1:
    rs.ObjectLayer(petal1, layer_name_1)

if not rs.LayerMaterialIndex(layer_name_1):  
    material_index = rs.AddMaterialToLayer(layer_name_1)  
    rs.MaterialName(material_index, "Paint Material")
    rs.MaterialColor(material_index, layer_color_1)  
    rs.MaterialShine(material_index, 0.5)

# make door curves
d1_h1 = 300
d1_ep1 = (midpoint[0], midpoint[1], midpoint[2] + d1_h1)
d1_line1 = rs.AddLine(midpoint, d1_ep1)
d1_line2 = rs.AddLine(d1_ep1, largest_polygon_points[num_sides])
d1_line3 = rs.AddLine(midpoint, largest_polygon_points[num_sides])
door_curves = [d1_line1, d1_line2, d1_line3]

# create door
door_1 = rs.AddNetworkSrf(door_curves, continuity=1, edge_tolerance=0, interior_tolerance=0, angle_tolerance=0)

# mirror and rotate doors
door_2 = rs.MirrorObject(door_1, smallest_polygon_points[num_sides], middle_polygon_points[num_sides], copy=True)
all_doors = [door_1, door_2] 
for i in range(num_sides):
    if i > 0:
        rotated_doors = rs.RotateObjects((door_1, door_2), base_p, 360 / num_sides * i, axis=None, copy=True)
        all_doors.extend(rotated_doors)  

# create layer for doors with material
layer_doors = "Doors"
layer_color_doors = (255, 127, 255)
rs.AddLayer(layer_doors, layer_color_doors)

for door in all_doors:
    rs.ObjectLayer(door, layer_doors)

if not rs.LayerMaterialIndex(layer_doors):  
    material_index = rs.AddMaterialToLayer(layer_doors)  
    rs.MaterialName(material_index, "Plastic Material")
    rs.MaterialColor(material_index, layer_color_doors)
    rs.MaterialShine(material_index, 0.8)

# make petal_2 and petal_3 curves
p3_h2 = 500
line_end_point = rs.CurveEndPoint(h_line)  
vertical_line_end = (
    line_end_point[0],         # keep X
    line_end_point[1],         # keep Y
    line_end_point[2] + p3_h2  # move Z
)

# add vertical lines
v_line = rs.AddLine(line_end_point, vertical_line_end)

# create a line for division
p3_hl1 = rs.AddLine(vertical_line_end, d1_ep1)
divided_points = rs.DivideCurve(p3_hl1, 2, create_points=False, return_points=True)

if divided_points:
    mid_div_point = divided_points[0]
    p3_h3 = 300
    p3_hy = 110
    p3_h4 = 200
    control_point = (
        mid_div_point[0] - p3_h3,  # move X
        mid_div_point[1] - p3_hy,  # move Y
        mid_div_point[2] + p3_h4   # move Z
    )
    control_curve = rs.AddCurve([vertical_line_end, control_point, d1_ep1], degree=2)

end_point_2 = ((middle_polygon_points[num_sides][0]), (middle_polygon_points[num_sides][1]), (middle_polygon_points[num_sides][2]) + 1000)
rs.AddLine(middle_polygon_points[num_sides], end_point_2)
p3_hl2 = rs.AddLine(end_point_2, largest_polygon_points[num_sides])
divided_points_2 = rs.DivideCurve(p3_hl2, 2, create_points=False, return_points=True) 

if divided_points_2:
    mid_div_point_2 = divided_points_2[0]
    p3_h5 = 400
    p3_h6 = 500
    control_point_2= (
        mid_div_point_2[0] + p3_h5,  # move X
        mid_div_point_2[1],          # keep Y
        mid_div_point_2[2] - p3_h6   # move Z
    )
    p2_line1 = rs.AddCurve([end_point_2, control_point_2, largest_polygon_points[num_sides]], degree=2)

p2_line2 = rs.AddLine(d1_ep1, end_point_2)
p2_curves = [p2_line1, p2_line2, d1_line2]
petal2_1 = rs.AddNetworkSrf(p2_curves, continuity=1, edge_tolerance=0, interior_tolerance=0, angle_tolerance=0)

# mirror and rotate petals2 to create flower
petal2_2 = rs.MirrorObject(petal2_1, smallest_polygon_points[num_sides], middle_polygon_points[num_sides], copy=True)
all_petals2 = [petal2_1, petal2_2]

for i in range(num_sides):
    if i > 0:
        rotated_petals2 = rs.RotateObjects((petal2_1, petal2_2), base_p, 360 / num_sides * i, axis=None, copy=True)
        all_petals2.extend(rotated_petals2)

# create layer for petals2 with material
layer_name_2 = "Petal 2"
layer_color_2 = (191,145,255)
rs.AddLayer(layer_name_2, layer_color_2)

for petal2 in all_petals2:
    rs.ObjectLayer(petal2, layer_name_2)

if not rs.LayerMaterialIndex(layer_name_2):  
    material_index = rs.AddMaterialToLayer(layer_name_2)  
    rs.MaterialName(material_index, "Paint Material")
    rs.MaterialColor(material_index, layer_color_2)  
    rs.MaterialShine(material_index, 0.5)

p3_line1 = rs.AddLine(largest_polygon_points[num_sides],vertical_line_end) 
# divide p3_line1 to find its midpoint
divided_points_p3_line1 = rs.DivideCurve(p3_line1, 2, create_points=False, return_points=True)

if divided_points_p3_line1:
    mid_p3_point = divided_points_p3_line1[0]  
    p3_h7 = 150  
    p3_h8 = 200 
    p3_h9 = 300  
    control_point_p3 = (
        mid_p3_point[0] + p3_h7,  # move X
        mid_p3_point[1] + p3_h8,  # move Y
        mid_p3_point[2] + p3_h9   # move Z
    )
    p3_curve = rs.AddCurve([largest_polygon_points[num_sides], control_point_p3, vertical_line_end], degree=2)
    
p3_curves = [p3_curve, d1_line2, control_curve]
petal3_1 = rs.AddNetworkSrf(p3_curves, continuity=1, edge_tolerance=0, interior_tolerance=0, angle_tolerance=0)

# mirror and rotate petals3 to create flower
petal3_2 = rs.MirrorObject(petal3_1, smallest_polygon_points[num_sides], middle_polygon_points[num_sides], copy=True)
all_petals3 = [petal3_1, petal3_2]

for i in range(num_sides):
    if i > 0:
        rotated_petals3 = rs.RotateObjects((petal3_1, petal3_2), base_p, 360 / num_sides * i, axis=None, copy=True)
        all_petals3.extend(rotated_petals3)

# create layer for petals3 with material
layer_name_3 = "Petal 3"
layer_color_3 = (191,191,255)
rs.AddLayer(layer_name_3, layer_color_3)

for petal3 in all_petals3:
    rs.ObjectLayer(petal3, layer_name_3)

if not rs.LayerMaterialIndex(layer_name_3):  
    material_index = rs.AddMaterialToLayer(layer_name_3)  
    rs.MaterialName(material_index, "Paint Material")
    rs.MaterialColor(material_index, layer_color_3)  
    rs.MaterialShine(material_index, 0.5)

# create star shape
def create_star(center, num_sides, radius, inner_radius):
    if num_sides < 5 or num_sides % 2 == 0:
        return None  
    angle_step = math.pi / num_sides  
    vertices = []
    for i in range(num_sides * 2):  
        angle = i * angle_step
        r = radius if i % 2 == 0 else inner_radius
        x = center[0] + r * math.cos(angle)
        y = center[1] + r * math.sin(angle)
        z = center[2]
        vertices.append((x, y, z))
    vertices.append(vertices[0])  
    polygon_id = rs.AddPolyline(vertices)
    return polygon_id

# parameters for star 
star_radius = 3000         
star_inner_radius = 2500   

# create star 
star_1 = create_star(center, num_sides, star_radius, star_inner_radius)
off_1 = 100
off_2 = 300
star_2 = rs.OffsetCurve(star_1,[2500,915,0], off_1, normal=None, style=1)
star_3 = rs.OffsetCurve(star_1,[2100,915,0], off_2, normal=None, style=1)

# create pool curves
star_3_points = rs.CurvePoints(star_3)
if len(star_3_points) >= 2:
    diameter_start = star_3_points[1]
    diameter_end = star_3_points[3]
    g1_h1 = 100
    # create the midpoint of the two points
    original_midpoint = (
        (diameter_start[0] + diameter_end[0]) / 2,
        (diameter_start[1] + diameter_end[1]) / 2,
        (diameter_start[2] + diameter_end[2]) / 2,
    )
    # create vectors from the midpoint to the start
    start_vector = (
        original_midpoint[0] - diameter_start[0],
        original_midpoint[1] - diameter_start[1],
        original_midpoint[2] - diameter_start[2],
    )
    end_vector = (
        original_midpoint[0] - diameter_end[0],
        original_midpoint[1] - diameter_end[1],
        original_midpoint[2] - diameter_end[2],
    )
    # normalize the vectors
    start_vector_length = math.sqrt(
        start_vector[0] ** 2 + start_vector[1] ** 2 + start_vector[2] ** 2
    )
    end_vector_length = math.sqrt(
        end_vector[0] ** 2 + end_vector[1] ** 2 + end_vector[2] ** 2
    )
    normalized_start_vector = (
        (start_vector[0] / start_vector_length) * g1_h1, # move X
        (start_vector[1] / start_vector_length) * g1_h1, # move Y
        (start_vector[2] / start_vector_length) * g1_h1, # move Z
    )
    normalized_end_vector = (
        (end_vector[0] / end_vector_length) * g1_h1, # move X
        (end_vector[1] / end_vector_length) * g1_h1, # move Y
        (end_vector[2] / end_vector_length) * g1_h1, # move Z
    )
    # move start and end points
    adjusted_diameter_start = (
        diameter_start[0] + normalized_start_vector[0],
        diameter_start[1] + normalized_start_vector[1],
        diameter_start[2] + normalized_start_vector[2],
    )
    adjusted_diameter_end = (
        diameter_end[0] + normalized_end_vector[0],
        diameter_end[1] + normalized_end_vector[1],
        diameter_end[2] + normalized_end_vector[2],
    )
    # create midpoint for radius
    midpoint = (
        (adjusted_diameter_start[0] + adjusted_diameter_end[0]) / 2,
        (adjusted_diameter_start[1] + adjusted_diameter_end[1]) / 2,
        (adjusted_diameter_start[2] + adjusted_diameter_end[2]) / 2,
    )

pool_1 = rs.AddCurve([adjusted_diameter_start, largest_polygon_points[1], adjusted_diameter_end], degree=3)
pool_2 = rs.AddLine(adjusted_diameter_start, star_3_points[2])
pool_3 = rs.AddLine(adjusted_diameter_end, star_3_points[2])
pool_curves_h = [pool_1, pool_2, pool_3]
rs.JoinCurves(pool_curves_h)

translation_2 = [0, 0, -100]
translation_3 = [0, -100, 0]
pool_curves_1 = [rs.CopyObject(curve, translation_2) for curve in pool_curves_h]
pool_curves_2 = [rs.MoveObject(curve, translation_3) for curve in pool_curves_h]

start_point_1 = rs.CurveStartPoint(pool_curves_1[0])
start_point_2 = rs.CurveStartPoint(pool_curves_2[0])
end_point_1 = rs.CurveEndPoint(pool_curves_1[0])
end_point_2 = rs.CurveEndPoint(pool_curves_2[0])
con_line = rs.AddLine(end_point_1, end_point_2)
joined_curves_1 = rs.JoinCurves(pool_curves_1)
joined_curves_2 = rs.JoinCurves(pool_curves_2)
rail_1 = joined_curves_1
rail_2 = joined_curves_2
shape = con_line
sweep_objects = rs.AddSweep2([rail_1, rail_2], [shape])
pool_top = rs.AddNetworkSrf(pool_curves_2, continuity=1, edge_tolerance=0, interior_tolerance=0, angle_tolerance=0)
pool_bottom = rs.AddNetworkSrf(pool_curves_1, continuity=1, edge_tolerance=0, interior_tolerance=0, angle_tolerance=0)
pool = [pool_bottom, sweep_objects, pool_top]

#create garden
rotation_copies = []
all_joined_curves_2 = [joined_curves_2]

for i in range(1, num_sides):
    rotated_joined_curves_2 = rs.RotateObject(joined_curves_2, base_p, 360 / num_sides * i, axis=None, copy=True)
    if rotated_joined_curves_2:
        rotation_copies.append(rotated_joined_curves_2)
        all_joined_curves_2.append(rotated_joined_curves_2)

path_1 = rs.AddLine([0,0,0], [0,0,-100])
garden_sides = rs.ExtrudeCurve(star_2, path_1) 
garden_top = rs.AddPlanarSrf(star_2 + all_joined_curves_2)
garden_bh = rs.AddPlanarMesh(star_2, delete_input=False)
translation_1 = [0,0,-100]
garden_bottom = rs.CopyObject(garden_bh, translation_1)
all_garden = [garden_sides, garden_top, garden_bottom]

# create layer for garden with material
layer_name_4 = "Garden"
layer_color_4 = (221,242,209)
rs.AddLayer(layer_name_4, layer_color_4)
rs.ObjectLayer(all_garden, layer_name_4)

if not rs.LayerMaterialIndex(layer_name_4):  
    material_index = rs.AddMaterialToLayer(layer_name_4)  
    rs.MaterialName(material_index, "Paint Material")
    rs.MaterialColor(material_index, layer_color_4)
    rs.MaterialShine(material_index, 0.5)

# create layer for pool with material
layer_name_5 = "Pool"
layer_color_5 = (167, 199, 231)
rs.AddLayer(layer_name_5, layer_color_5)

for pool_surface in pool:
    rs.ObjectLayer(pool_surface, layer_name_5)
if not rs.LayerMaterialIndex(layer_name_5):
    material_index = rs.AddMaterialToLayer(layer_name_5)
    rs.MaterialName(material_index, "Plastic Material")
    rs.MaterialColor(material_index, layer_color_5)
    rs.MaterialShine(material_index, 0.8)

# rotate the pool
rotated_pools = []
for i in range(num_sides):
    if i > 0:
        rotated_pools = rs.RotateObjects(pool, base_p, 360 / num_sides * i, axis=None, copy=True)

# clean up (delete extra lines etc.)
rs.DeleteObjects([base_p, h_line, vertical_line_id, tilted_line_id, v_line, p3_hl1, p3_hl2, p3_curve, p2_line1, control_curve, curve, polygon_id, d1_line1, d1_line2, d1_line1, star_1, star_2, star_3,joined_curves_1, joined_curves_2, garden_bh, pool_1, pool_2, pool_3])
rs.EnableRedraw(True)