import rhinoscriptsyntax as rs
import random as ran
import fantastic_stairs_lib as fs

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

# Function to create a vertical grid
def make_v_grid(x_cnt, z_cnt, xsize, zsize, l_len):
    pts = []
    lines = []
    for i in range(x_cnt):
        for j in range(z_cnt):
            lines.append(rs.AddLine([i * xsize, 0, j * zsize], [i * xsize, l_len, j * zsize]))
            pts.append(rs.AddPoint([i * xsize, 0, j * zsize]))
    return pts, lines

# Function to create a domino house with adjustable ramps/stairs
def make_domino_house(xsize, zsize, levels, dist_x, dist_y, angle, house_index):
    l_len = 1.0  
    result = fs.make_domino(
        xsize, 
        xsize / 3, 
        thick=fs.thick, 
        hgt=(zsize - fs.thick), 
        levels=levels, 
        xcol=x_cnt, 
        ycol=fs.ycol
    )
    
    # move and rotate the house components
    for o_list in result:
        rs.MoveObjects(o_list, [0, -(fs.ycol - 1) * xsize - fs.f_size / 2, -(fs.f_height + fs.thick)])
        co_list = rs.MirrorObjects(o_list, [0, 0, 0], [dist_x, 0, 0], copy=True)
        rs.MoveObjects(co_list, [dist_x - (x_cnt - 1) * xsize, dist_y * house_index, 0])  # Offseting houses
        rs.RotateObjects(co_list, [dist_x, dist_y * house_index, 0], (angle - 180), [0, 0, 1])
    
    # Adding ramps or stairs
    pts1, lines1 = make_v_grid(x_cnt, z_cnt, xsize, zsize, l_len)
    rs.RotateObjects(pts1, [0, 0, 0], angle, [0, 0, 1])
    rs.RotateObjects(lines1, [0, 0, 0], angle, [0, 0, 1])
    rs.MoveObjects(pts1, (dist_x, dist_y * house_index, 0))
    rs.MoveObjects(lines1, (dist_x, dist_y * house_index, 0))
    
    pts2, lines2 = make_v_grid(x_cnt, z_cnt, xsize, zsize, l_len)
    ptl1 = range(0, len(pts1))
    ptl2 = range(0, len(pts2))
    
    crv_list = []
    while len(ptl1) > 0:
        r_init = ran.randint(0, len(ptl1) - 1)
        r_end = ran.randint(0, len(ptl2) - 1)
        init = lines1[ptl1[r_init]]
        end = lines2[ptl2[r_end]]
        ptl1.pop(r_init)
        ptl2.pop(r_end)
        crv_list.append(fs.blend_curves(init, end, 2))
    
    for curve in crv_list:
        (st_crv, tothgt) = fs.curve_to_stairline(curve)
        len_c = rs.CurveLength(st_crv)
        if abs(tothgt) <= zsize:
            fs.make_curved_ramp(st_crv, tothgt)
        else:
            (steps, th) = fs.calculate_steps_height(tothgt)
            An = 0
            tt = (len_c - An) / steps
            if tt > 0.32:
                tt = fs.tt
                P = steps / 2
                P = 4
                pod_l = fs.calculate_podlen(len_c, tt, steps, P, An)
                print(
                    "Stair values (length, tread height, tread depth, steps):",
                    len_c, th, tt, steps
                )
                fs.make_curved_podeststair(
                    st_crv, steps=steps, th=th, tt=tt, pod_l=pod_l, P=P, An=An, DC=steps+1, s_width=1.2
                )

# Parameters for houses
house_count = 3
x_cnt, z_cnt = 3, 5  # Grid size
xsize, zsize = 4.0, 3.0
angle_range = (90, 180)
dist_x, dist_y = 20, 20

# Generate multiple domino houses
for house_index in range(house_count):
    levels = ran.randint(10, 20) 
    angle = ran.uniform(*angle_range)  
    make_domino_house(xsize, zsize, levels, dist_x, dist_y, angle, house_index)


rs.EnableRedraw(True)