import rhinoscriptsyntax as rs
import random as ran

# Delete all objects and start from scratch
rs.DeleteObjects(rs.AllObjects())

# Disable redraw for faster execution
rs.EnableRedraw(False)

#Domino variables

A           = 5                     # A = Module size (distance between columns)
B           = A/3                   # B = Distance of columns to end of plate
thick       = 0.18                  # thicknes of all slabs
hgt         = 2.7                   # height of room
xcol        = 5                     # columns in x direction
ycol        = 6                     # columns in y direction
levels      = 7                     # number of floor plates
f_height    = 0.5                   # f_height = foundation height
f_size       = 0.8                   # f_size = foundation edge size

#derived values:

center_pt = [A*(xcol-1)/2,A*(ycol-1)/2,f_height]    # insertion point of floor plate
p_width   = A*(xcol-1)+2*B                          # width of floor plate (x)
p_length  = A*(ycol-1) + f_size                     # lenght of floor plate (y)

def make_box(insertion=[0,0,0],xsize=10,ysize=10,zsize=10):

    corners = [[0,0,0], [xsize,0,0], [xsize,ysize,0], [0,ysize,0], [0,0,zsize],
              [xsize,0,zsize], [xsize,ysize,zsize], [0,ysize,zsize]]
    box=rs.AddBox(corners)
    rs.MoveObject(box, (-xsize/2,-ysize/2,0))
    rs.MoveObject(box, insertion)
    return(box)

def make_podest(insertion=[0,0,0],xsize=10,ysize=10,zsize=10):

    corners = [[0,0,0], [xsize,0,0], [xsize,ysize,0], [0,ysize,0], [0,0,zsize],
              [xsize,0,zsize], [xsize,ysize,zsize], [0,ysize,zsize]]
    box=rs.AddBox(corners)
    rs.MoveObject(box, insertion)
    return(box)

#make_box([10,-3,0],6,9,10)

#function to create a field of foundations
def make_foundations(A=5.0, f_size=0.8, f_height=0.5, xcol=2, ycol=3):
    fns =[]
    for i in range(xcol):
        for j in range(ycol):
            fns.append (make_box([i*A,j*A,0], f_size,f_size,f_height))
    return(fns)

#function to create a field of columns

def make_columns(A=5.0, level=0.5, thick=0.2, hgt=3.0, xcol=2, ycol=3):
    cls = []
    for i in range(xcol):
        for j in range(ycol):
            cls.append (make_box([i*A,j*A,level], thick,thick,hgt))
    return(cls)

def make_arc(insertion, rad, thick, hgt, orientation):
    segs=[]
    segs.append(rs.AddArc([0,0,0], rad, 180))
    segs.append(rs.AddArc([0,0,0], rad-thick, 180))
    segs.append(rs.AddLine([rad,0,0],[rad-thick,0,0]))
    segs.append(rs.AddLine([-(rad-thick),0,0],[-rad,0,0]))
    crv=rs.JoinCurves(segs, delete_input=True)
    path=rs.AddLine([0,0,0],[0,0,hgt])
    arc=rs.ExtrudeCurve(crv, path)
    rs.CapPlanarHoles(arc)
    rs.DeleteObject(crv)
    rs.DeleteObject(path)
    rs.RotateObject(arc, [0,0,0], orientation)
    rs.MoveObject(arc, insertion)
    return(arc)

def make_terrace(A=5.0, level=0.5, thick=0.2, hgt=3.0, xcol=2, ycol=3):
    cls = []
    for i in range(xcol-1):
        for j in range(ycol-1):
            ori = ran.randint(0,6)
            if ori<4:
                orientation = ori*90
                cls.append(make_arc([i*A+A/2,j*A+A/2,level], A/2,thick,hgt, orientation))
    return(cls)

def make_stair(start, th, tt, steps, thick, s_width):
    pointlist=[start]
    for i in range (steps):
        pointlist.append([pointlist[-1][0],pointlist[-1][1],pointlist[-1][2]+ th])
        pointlist.append([pointlist[-1][0]+tt,pointlist[-1][1],pointlist[-1][2]])
    pointlist.append([pointlist[-1][0],pointlist[-1][1],pointlist[-1][2]-thick])
    pointlist.append([pointlist[0][0],pointlist[0][1],pointlist[0][2]-thick])
    pointlist.append([pointlist[0][0],pointlist[0][1],pointlist[0][2]])
    s_outline=rs.AddPolyline(pointlist)
    path=rs.AddLine(start,[start[0],start[1]+s_width,start[2]])
    hull = rs.ExtrudeCurve(s_outline, path)
    rs.CapPlanarHoles(hull)
    return[hull]


#building domino

def make_domino(A=A, B=B, thick=thick, hgt=hgt, levels=levels, xcol=xcol, ycol=ycol, f_height=f_height, f_size=f_size):
    f_list=[]               # list of foundations
    c_list=[]               # list of columns
    p_list=[]               # list of plates
    for i in range(levels):
        center_pt[2] = f_height + i*(thick+hgt)
        level = f_height + thick + (i-1)*(hgt + thick)
        if i== 0:
            f_list = make_foundations(A, f_size, f_height, xcol, ycol)
        else:
            c_list.extend (make_columns(A, level, thick, hgt, xcol, ycol))
            c_list.extend(make_terrace(A, level, thick, hgt, xcol, ycol))
        p_list.append (make_box(center_pt, p_width, p_length, thick))
    level=f_height + thick + (levels-1)*(hgt + thick)
    c_list.extend(make_terrace(A, level, thick, hgt, xcol, ycol))
    #########################
    #calculate stair values
    #########################
    steps = int((hgt+thick)/0.17)
    if steps%2:
        steps = steps-1
    th = (hgt+thick)/steps
    if(th>0.19):
        steps=steps+2
        th = (hgt+thick)/steps
    #########################
    #stair parameters
    #########################
    tt=0.3                                              # step size
    s_width = 1.2                                       # s_width = stair width
    pod_w = B                                           # pod_w = depth of landing 
    start = [pod_w,-(s_width*2+f_size/2), f_height+thick]    # startpoint of stair 
    
    stair_l = []
    for i in range(levels):
        start[2] = f_height+thick + i*(thick+hgt)
        if i==levels-1:
            stair_l.append(make_podest([start[0]-pod_w, start[1]+s_width, start[2]-thick], pod_w, s_width, thick))
        else:
            stair_l.append(make_podest([start[0]-pod_w,start[1],start[2]-thick], pod_w, s_width*2,thick))
            stair_l.append(make_stair(start, th, tt, int(steps/2), thick, s_width))
            stair_l.append(make_podest([start[0]+(steps/2)*tt,start[1],start[2]+(steps/2)*th-thick], pod_w, s_width*2,thick))
            stair_l.append(make_stair([start[0]+(steps/2)*tt, start[1]+s_width, start[2]+(steps/2)*th], th, -tt, int(steps/2), thick, s_width))
            
    return(f_list, c_list, p_list,stair_l)




(f_list, c_list, p_list,stair_l)=make_domino()

f_list=[]               # list of foundations
c_list=[]               # list of columns
p_list=[]               # list of plates

for i in range(levels):
    center_pt[2] = f_height + i*(thick+hgt)
    level = f_height + thick + (i-1)*(hgt + thick)
    if i== 0:
        f_list = make_foundations(A, f_size, f_height, xcol, ycol)
    else:
        c_list.extend (make_columns(A, level, thick, hgt, xcol, ycol))
    p_list.append (make_box(center_pt, p_width, p_length, thick))

rs.AddLayer("foundation")
rs.LayerColor("foundation"), (220,60,60)
rs.ObjectLayer(f_list,"foundation")
rs.AddLayer("column")
rs.LayerColor("column"), (220,60,60)
rs.ObjectLayer(f_list,"column")
rs.AddLayer("plate")
rs.LayerColor("plate"), (220,60,60)
rs.ObjectLayer(f_list,"plate")

print f_list
print c_list
print p_list

# Size and number of boxes
xbsize = thick            
zbsize = (2 * hgt + 3 * thick) / 14
ybsize = (2 * A + f_size) / 14
ynum = 12   # Number of rows in the y-direction (1 row)
xnum = 1  # Number of boxes in the x-direction (wide)
znum = 14  # Number of boxes in the z-direction (depth)

# Create base box corners
corners = [(0, 0, 0), (xbsize, 0, 0), (xbsize, ybsize, 0), (0, ybsize, 0),
           (0, 0, zbsize), (xbsize, 0, zbsize), (xbsize, ybsize, zbsize), (0, ybsize, zbsize)]

# Create and move boxes randomly with color
for i in range(ynum):     # Loop for X-axis
    for j in range(znum): # Loop for Z-axis (filling the area in one layer)
        my_ran = ran.randint(0, 9)
        if my_ran >= 3:  # Only create box if random condition is met (like in the original)
            box = rs.AddBox(corners)  # Create the box
            
            # Move box based on X-Z grid structure, all boxes remain in the same Y-plane (flat)
            rs.MoveObject(box, (i * ybsize, 0, j * zbsize))
            rs.MoveObject(box, ((-B - xbsize), (-f_size / 2), (f_height)))
            
            # Assign random color to the box
            color = (ran.randint(0, 255), ran.randint(0, 255), ran.randint(0, 255))
            rs.ObjectColor(box, color)

# Enable redraw to update the view
rs.EnableRedraw(True)