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        = 8                     # columns in x direction
ycol        = 4                     # columns in y direction
levels      = 6                     # 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



# Facade variables
xbsize = thick                                 # Width of facade blocks
zbsize = (hgt + thick) / 10                    # Height of facade blocks
ybsize = B                                     # Depth of facade blocks
ynum = int(p_length / ybsize)                  # Number of blocks along the length (Y-axis)
xnum = int(p_width / ybsize)                   # Number of blocks along the width (X-axis)
znum = int((levels * (hgt + thick)) / zbsize)  # Number of blocks along the height (Z-axis)

# Facade function
def create_facade(f_height, ybsize, xbsize, zbsize, ynum, xnum, znum):
    for side in range(4):  # Loop through each side
        for i in range(xnum if side in (0, 1) else ynum):  # Set facade width or length
            for j in range(znum):  # Set facade height along the Z-axis
                my_ran = ran.randint(0, 9)
                if my_ran >= 3:  # Randomize block placement
                    # Create block
                    if side in (0, 1):  # Rotate the box by 90 degrees for front and back sides
                        box = rs.AddBox([(0, 0, 0), (ybsize, 0, 0), (ybsize, xbsize, 0), (0, xbsize, 0),
                                         (0, 0, zbsize), (ybsize, 0, zbsize), (ybsize, xbsize, zbsize), (0, xbsize, zbsize)])
                    else:  # Keep the box in original orientation for left and right sides
                        box = rs.AddBox([(0, 0, 0), (xbsize, 0, 0), (xbsize, ybsize, 0), (0, ybsize, 0),
                                         (0, 0, zbsize), (xbsize, 0, zbsize), (xbsize, ybsize, zbsize), (0, ybsize, zbsize)])

                    # Move block based on position on each respective side
                    if side == 0:  # Front side
                        rs.MoveObject(box, (i * ybsize - B, -xbsize, f_height + j * zbsize))
                    elif side == 1:  # Back side
                        rs.MoveObject(box, (i * ybsize - B, p_length - B/2, f_height + j * zbsize))
                    elif side == 2:  # Left side
                        rs.MoveObject(box, (-xbsize - B, i * ybsize, f_height + j * zbsize))
                    elif side == 3:  # Right side
                        rs.MoveObject(box, (p_width - B, i * ybsize, f_height + j * zbsize))

                    # Assign a random color
                    color = (ran.randint(0, 255), ran.randint(0, 255), ran.randint(0, 255))
                    rs.ObjectColor(box, color)

# Generate facade
create_facade(f_height, ybsize, xbsize, zbsize, ynum, xnum, znum)

#
(f_list, c_list, p_list, stair_list) = make_domino()

for i in range(10):
        xran=ran.randint(0,200)
        yran=ran.randint(0,200)
        angel=ran.uniform(0,180)
        (f_list, c_list, p_list, stair_list)=make_domino()
        rs.RotateObjects(f_list+ c_list+ p_list+ stair_list, (0,0,0), angel)
        rs.MoveObjects(f_list+ c_list+ p_list+ stair_list,(xran,yran,0))


# Initialize lists
f_list = []
c_list = []
p_list = []
fa_list = []

for i in range(levels):
    center_pt[2] = f_height + i * (thick + hgt)
    level = f_height + thick + (i - 1) * (hgt + thick)
    
    # Create foundations at the first level
    if i == 0:
        f_list = make_foundation(A, f_size, f_height, xcol, ycol)
    else:
        # Create columns and add them to the list
        c_list.extend(make_column(A, level, thick, hgt, xcol, ycol))
    
    # Create plates (floors)
    p_list.append(make_box(center_pt, p_width, p_length, thick))


cornerl_pt = [p_width-B-0.1, A*(ycol-1)/2, 0]
corner2_pt = [A*(xcol-1)/2, p_length-0.3, 0]


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