import rhinoscriptsyntax as rs
import Rhino.Geometry as rg
import random as r


def draw_castle(o, l, w, h, t, f_fort, f_towers):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    draw_fort_floors(o, l, w, h, t, f_fort)
    
    draw_tower_a_floors(o + vz*h*f_fort, l, w, h, t, f_towers[0])
    draw_tower_b_floors(o + vz*h*f_fort, l, w, h, t, f_towers[1])
    draw_tower_c_floors(o + vz*h*f_fort, l, w, h, t, f_towers[2])
    draw_tower_d_floors(o + vz*h*f_fort, l, w, h, t, f_towers[3])


def draw_fort_floors(o, l, w, h, t, f):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    for n in range(f):
        draw_fort(o + vz*h*n, l, w, h, t)
        draw_fort_vert(o + vz*h*n, l, w, h, t)
        if n == f-1: draw_fort(o + vz*h*(n+1), l, w, h, t)


def draw_tower_a_floors(o, l, w, h, t, f):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    for n in range(f):
        if n == 0: draw_tower_a(o + vz*h*n, l, w, h, t, [0,0,1,1])
        else: draw_tower_a(o + vz*h*n, l, w, h, t)
        draw_tower_a_vert(o + vz*h*n, l, w, h, t)
        if n == f-1:
            draw_tower_a(o + vz*h*(n+1), l, w, h, t)
            draw_tower_a_cap(o + vz*h*(n+1), l, w, h, t)


def draw_tower_b_floors(o, l, w, h, t, f):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    for n in range(f):
        if n == 0: draw_tower_b(o + vz*h*n, l, w, h, t, [0,1,0,1])
        else: draw_tower_b(o + vz*h*n, l, w, h, t)
        draw_tower_b_vert(o + vz*h*n, l, w, h, t)
        if n == f-1:
            draw_tower_b(o + vz*h*(n+1), l, w, h, t)
            draw_tower_b_cap(o + vz*h*(n+1), l, w, h, t)


def draw_tower_c_floors(o, l, w, h, t, f):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    for n in range(f):
        if n == 0: draw_tower_c(o + vz*h*n, l, w, h, t, [1,0,1,0])
        else: draw_tower_c(o + vz*h*n, l, w, h, t)
        draw_tower_c_vert(o + vz*h*n, l, w, h, t)
        if n == f-1:
            draw_tower_c(o + vz*h*(n+1), l, w, h, t)
            draw_tower_c_cap(o + vz*h*(n+1), l, w, h, t)


def draw_tower_d_floors(o, l, w, h, t, f):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    for n in range(f):
        if n == 0: draw_tower_d(o + vz*h*n, l, w, h, t, [1,1,0,0])
        else: draw_tower_d(o + vz*h*n, l, w, h, t)
        draw_tower_d_vert(o + vz*h*n, l, w, h, t)
        if n == f-1:
            draw_tower_d(o + vz*h*(n+1), l, w, h, t)
            draw_tower_d_cap(o + vz*h*(n+1), l, w, h, t)


def draw_fort(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o, o + vx*l)
    rs.AddLine(o, o + vy*w)
    rs.AddLine(o + vx*l, o + vx*l + vy*w)
    rs.AddLine(o + vy*w, o + vx*l + vy*w)
    
    rs.AddLine(o + vx*t + vy*t, o + vx*(l-t) + vy*t)
    rs.AddLine(o + vx*t + vy*t, o + vx*t + vy*(w-t))
    rs.AddLine(o + vx*(l-t) + vy*t, o + vx*(l-t)+ vy*(w-t))
    rs.AddLine(o + vx*t + vy*(w-t), o + vx*(l-t)+ vy*(w-t))


def draw_fort_vert(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o, o + vz*h)
    rs.AddLine(o + vy*w, o + vy*w + vz*h)
    rs.AddLine(o + vx*l, o + vx*l + vz*h)
    rs.AddLine(o + vx*l + vy*w, o + vx*l + vy*w + vz*h)
    
    rs.AddLine(o + vx*t + vy*t, o + vx*t + vy*t + vz*h)
    rs.AddLine(o + vx*t + vy*(w-t), o + vx*t + vy*(w-t) + vz*h)
    rs.AddLine(o + vx*(l-t) + vy*t, o + vx*(l-t) + vy*t + vz*h)
    rs.AddLine(o + vx*(l-t)+ vy*(w-t), o + vx*(l-t)+ vy*(w-t) + vz*h)


def draw_tower_a(o, l, w, h, t, elements = [1,1,1,1]):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    if elements[0]: rs.AddLine(o, o + vx*t)
    if elements[1]: rs.AddLine(o, o + vy*t)
    if elements[2]: rs.AddLine(o + vx*t, o + vx*t + vy*t)
    if elements[3]: rs.AddLine(o + vy*t, o + vx*t + vy*t)


def draw_tower_b(o, l, w, h, t, elements = [1,1,1,1]):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    if elements[0]: rs.AddLine(o + vx*(l-t), o + vx*l)
    if elements[1]: rs.AddLine(o + vx*(l-t), o + vy*t + vx*(l-t))
    if elements[2]: rs.AddLine(o + vx*l, o + vx*l + vy*t)
    if elements[3]: rs.AddLine(o + vy*t + vx*(l-t), o + vx*l + vy*t)


def draw_tower_c(o, l, w, h, t, elements = [1,1,1,1]):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    if elements[0]: rs.AddLine(o + vy*(w-t), o + vx*t + vy*(w-t))
    if elements[1]: rs.AddLine(o + vy*(w-t), o + vy*w)
    if elements[2]: rs.AddLine(o + vx*t + vy*(w-t), o + vx*t + vy*w)
    if elements[3]: rs.AddLine(o + vy*w, o + vx*t + vy*w)


def draw_tower_d(o, l, w, h, t, elements = [1,1,1,1]):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    if elements[0]: rs.AddLine(o + vy*(w-t) + vx*(l-t), o + vx*l + vy*(w-t))
    if elements[1]: rs.AddLine(o + vy*(w-t) + vx*(l-t), o + vy*w + vx*(l-t))
    if elements[2]: rs.AddLine(o + vx*l + vy*(w-t), o + vx*l + vy*w)
    if elements[3]: rs.AddLine(o + vy*w + vx*(l-t), o + vx*l + vy*w)


def draw_tower_a_vert(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o, o + vz*h)
    rs.AddLine(o + vy*t, o + vy*t + vz*h)
    rs.AddLine(o + vx*t, o + vx*t + vz*h)
    rs.AddLine(o + vx*t + vy*t, o + vx*t + vy*t + vz*h)


def draw_tower_b_vert(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o + vx*(l-t), o + vx*(l-t) + vz*h)
    rs.AddLine(o + vy*t + vx*(l-t), o + vy*t + vx*(l-t) + vz*h)
    rs.AddLine(o + vx*l, o + vx*l + vz*h)
    rs.AddLine(o + vx*l + vy*t, o + vx*l + vy*t + vz*h)


def draw_tower_c_vert(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o + vy*(w-t), o + vy*(w-t) + vz*h)
    rs.AddLine(o + vy*w, o + vy*w + vz*h)
    rs.AddLine(o + vx*t + vy*(w-t), o + vx*t + vy*(w-t) + vz*h)
    rs.AddLine(o + vx*t + vy*w, o + vx*t + vy*w + vz*h)


def draw_tower_d_vert(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o + vy*(w-t) + vx*(l-t), o + vy*(w-t) + vx*(l-t) + vz*h)
    rs.AddLine(o + vy*w + vx*(l-t), o + vy*w + vx*(l-t) + vz*h)
    rs.AddLine(o + vx*l + vy*(w-t), o + vx*l + vy*(w-t) + vz*h)
    rs.AddLine(o + vx*l + vy*w, o + vx*l + vy*w + vz*h)


def draw_tower_a_cap(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o, o + vz*h)
    rs.AddLine(o + vy*t, o + vz*h)
    rs.AddLine(o + vx*t, o + vz*h)
    rs.AddLine(o + vx*t + vy*t, o + vz*h)


def draw_tower_b_cap(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o + vx*(l-t), o + vx*l + vz*h)
    rs.AddLine(o + vy*t + vx*(l-t), o + vx*l + vz*h)
    rs.AddLine(o + vx*l, o + vx*l + vz*h)
    rs.AddLine(o + vx*l + vy*t, o + vx*l + vz*h)


def draw_tower_c_cap(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o + vy*(w-t), o + vy*w + vz*h)
    rs.AddLine(o + vy*w, o + vy*w + vz*h)
    rs.AddLine(o + vx*t + vy*(w-t), o + vy*w + vz*h)
    rs.AddLine(o + vx*t + vy*w, o + vy*w + vz*h)


def draw_tower_d_cap(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o + vy*(w-t) + vx*(l-t), o + vx*l + vy*w + vz*h)
    rs.AddLine(o + vy*w + vx*(l-t), o + vx*l + vy*w + vz*h)
    rs.AddLine(o + vx*l + vy*(w-t), o + vx*l + vy*w + vz*h)
    rs.AddLine(o + vx*l + vy*w, o + vx*l + vy*w + vz*h)


def draw_cctv(o, l, w, h, t, f_cctv):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    draw_L_left_floors(o, l, w, h, t, f_cctv[0])
    draw_pillars_floors(o + vz*h*f_cctv[0], l, w, h, t, f_cctv[1])
    draw_L_right_floors(o + vz*h*(f_cctv[0]+f_cctv[1]), l, w, h, t, f_cctv[2])


def draw_L_left_floors(o, l, w, h, t, f):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    for n in range(f):
        draw_L_left(o + vz*h*n, l, w, h, t)
        draw_L_left_vert(o + vz*h*n, l, w, h, t)
        if n == f-1: draw_L_left(o + vz*h*(n+1), l, w, h, t)


def draw_L_right_floors(o, l, w, h, t, f):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    for n in range(f):
        draw_L_right(o + vz*h*n, l, w, h, t)
        draw_L_right_vert(o + vz*h*n, l, w, h, t)
        if n == f-1: draw_L_right(o + vz*h*(n+1), l, w, h, t)


def draw_pillars_floors(o, l, w, h, t, f):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    for n in range(f):
        if n == 0:
            draw_pillar_left(o + vz*h*n, l, w, h, t, [0,0,0,1])
            draw_pillar_right(o + vz*h*n, l, w, h, t, [0,1,0,0])
        else:
            draw_pillar_left(o + vz*h*n, l, w, h, t, [1,1,1,1])
            draw_pillar_right(o + vz*h*n, l, w, h, t, [1,1,1,1])
        
        draw_pillar_left_vert(o + vz*h*n, l, w, h, t, [1,1,1,1])
        draw_pillar_right_vert(o + vz*h*n, l, w, h, t, [1,1,1,1])
        
        if n == f-1:
            draw_pillar_left(o + vz*h*(n+1), l, w, h, t, [0,0,1,0])
            draw_pillar_right(o + vz*h*(n+1), l, w, h, t, [1,0,0,0])


def draw_L_left(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o, o + vx*t)
    rs.AddLine(o, o + vy*w)
    rs.AddLine(o + vx*t, o + vx*t + vy*(w-t))
    rs.AddLine(o + vy*w, o + vx*l + vy*w)
    rs.AddLine(o + vx*t + vy*(w-t), o + vx*l + vy*(w-t))
    rs.AddLine(o + vx*l + vy*w, o + vx*l + vy*(w-t))


def draw_L_left_vert(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o, o + vz*h)
    rs.AddLine(o + vx*t, o + vx*t + vz*h)
    rs.AddLine(o + vy*w, o + vy*w + vz*h)
    rs.AddLine(o + vx*t + vy*(w-t), o + vx*t + vy*(w-t) + vz*h)
    rs.AddLine(o + vx*l + vy*w, o + vx*l + vy*w + vz*h)
    rs.AddLine(o + vx*l + vy*(w-t), o + vx*l + vy*(w-t) + vz*h)


def draw_L_right(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o, o + vx*l)
    rs.AddLine(o, o + vy*t)
    rs.AddLine(o + vy*t, o + vy*t + vx*(l-t))
    rs.AddLine(o + vx*l, o + vx*l + vy*w)
    rs.AddLine(o + vy*t + vx*(l-t), o + vx*(l-t) + vy*w)
    rs.AddLine(o + vx*l + vy*w, o + vx*(l-t) + vy*w)


def draw_L_right_vert(o, l, w, h, t):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    rs.AddLine(o, o + vz*h)
    rs.AddLine(o + vx*l, o + vx*l + vz*h)
    rs.AddLine(o + vy*t, o + vy*t + vz*h)
    rs.AddLine(o + vy*t + vx*(l-t), o + vy*t + vx*(l-t) + vz*h)
    rs.AddLine(o + vx*l + vy*w, o + vx*l + vy*w + vz*h)
    rs.AddLine(o + vx*(l-t) + vy*w, o + vx*(l-t) + vy*w + vz*h)


def draw_pillar_left(o, l, w, h, t, elements = [1,1,1,1]):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    if elements[0]: rs.AddLine(o, o + vx*t)
    if elements[1]: rs.AddLine(o, o + vy*t)
    if elements[2]: rs.AddLine(o + vx*t, o + vx*t + vy*t)
    if elements[3]: rs.AddLine(o + vy*t, o + vx*t + vy*t)


def draw_pillar_right(o, l, w, h, t, elements = [1,1,1,1]):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    if elements[0]: rs.AddLine(o + vx*(l-t) + vy*(w-t), o + vx*l + vy*(w-t))
    if elements[1]: rs.AddLine(o + vx*(l-t) + vy*(w-t), o + vy*w + vx*(l-t))
    if elements[2]: rs.AddLine(o + vx*l + vy*(w-t), o + vx*l + vy*w)
    if elements[3]: rs.AddLine(o + vx*(l-t) + vy*w, o + vx*l + vy*w)


def draw_pillar_left_vert(o, l, w, h, t, elements = [1,1,1,1]):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    if elements[0]: rs.AddLine(o, o + vz*h)
    if elements[1]: rs.AddLine(o + vx*t, o + vx*t + vz*h)
    if elements[2]: rs.AddLine(o + vy*t, o + vy*t + vz*h)
    if elements[3]: rs.AddLine(o + vx*t + vy*t, o + vx*t + vy*t + vz*h)


def draw_pillar_right_vert(o, l, w, h, t, elements = [1,1,1,1]):
    vx, vy, vz = rg.Vector3d.XAxis, rg.Vector3d.YAxis, rg.Vector3d.ZAxis
    
    if elements[0]: rs.AddLine(o + vx*(l-t) + vy*(w-t), o + vx*(l-t) + vy*(w-t) + vz*h)
    if elements[1]: rs.AddLine(o + vx*l + vy*(w-t), o + vx*l + vy*(w-t) + vz*h)
    if elements[2]: rs.AddLine(o + vx*(l-t) + vy*w, o + vx*(l-t) + vy*w + vz*h)
    if elements[3]: rs.AddLine(o + vx*l + vy*w, o + vx*l + vy*w + vz*h)


def draw_random_castle(o):
    # parameters for castle model
    l_min, l_max = 3, 20
    w_min, w_max = 3, 20
    h_min, h_max = 1, 3
    t_min, t_max = 1, 5
    f_fort_min, f_fort_max = 1, 3
    f_towers_min, f_towers_max = 1, 5
    max_total_height = 20
    
    #nr_of_variations = (l_max-l_min + 1)*(w_max-w_min + 1)*(h_max-h_min + 1)*(t_max-t_min + 1)*(f_fort_max-f_fort_min + 1)*(f_towers_max-f_towers_min + 1)
    #print "Total possible number or castle model variations: ", nr_of_variations
    
    # length, width, height (of one floor), thickness (of fort and towers)
    l = r.randint(l_min, l_max)
    w = r.randint(w_min, w_max)
    h = r.randint(h_min, h_max)
    t = r.randint(t_min, t_max)
    
    # thickess cannot be bigger than half the smallest side (length or width)
    # this would cause the inner courtyard to dissapear
    if t*2 >= l: t = int(l/2) - 1
    if t*2 >= w: t = int(w/2) - 1
    if t < 1: t = 1
    
    # random number of floors for the fort
    f_fort = r.randint(f_fort_min, f_fort_max)
    
    # random number of floors for the towers
    # there are 4 towers but only 2 pairs of heights - maybe a more realistic scenario
    f_towers_a = r.randint(f_towers_min, f_towers_max)
    f_towers_b = r.randint(f_towers_min, f_towers_max)
    f_towers = [f_towers_a, f_towers_a, f_towers_b, f_towers_b]
    r.shuffle(f_towers)
    
    # constrain maximal height of the castle
    max_floors = f_fort + max(f_towers) + 1 # we have to add the cap
    total_height = h*max_floors
    if total_height > max_total_height:
        #print "Model (" + str(i) + "," + str(j) + ") total height: " + str(total_height) + ", floors: " + str(max_floors) + ", floor height: " + str(h)
        h = int(max_total_height/max_floors)
        #total_height = h*max_floors
        #print "\tnew floor height: " + str(h) + ", new total height: " + str(total_height)
        
    draw_castle(o, l, w, h, t, f_fort, f_towers)


def draw_random_cctv(o):
    # parameters for cctv model
    l_min, l_max = 2, 20
    w_min, w_max = 2, 20
    h_min, h_max = 1, 5
    t_min, t_max = 1, 5
    f_cctv_min, f_cctv_max = 1, 3
    max_total_height = 20
    
    #nr_of_variations = (l_max-l_min + 1)*(w_max-w_min + 1)*(h_max-h_min + 1)*(t_max-t_min + 1)*(f_cctv_max-f_cctv_min + 1)
    #print "Total possible number or cctv model variations: ", nr_of_variations
    
    # length, width, height (of one floor), thickness (of L body and pillars)
    l = r.randint(l_min, l_max)
    w = r.randint(w_min, w_max)
    h = r.randint(h_min, h_max)
    t = r.randint(t_min, t_max)
    
    # every side must be at least double the thickness
    if l < t*2: l = t*2
    if w < t*2: w = t*2
    
    # random number of floors for each section of cctv
    f_cctv = [r.randint(f_cctv_min, f_cctv_max), r.randint(f_cctv_min, f_cctv_max), r.randint(f_cctv_min, f_cctv_max)]
    
    # constrain maximal height of the cctv
    max_floors = f_cctv[0] + f_cctv[1] + f_cctv[2]
    total_height = h*max_floors
    if total_height > max_total_height:
        #print "Model (" + str(i) + "," + str(j) + ") total height: " + str(total_height) + ", floors: " + str(max_floors) + ", floor height: " + str(h)
        h = int(max_total_height/max_floors)
        #total_height = h*max_floors
        #print "\tnew floor height: " + str(h) + ", new total height: " + str(total_height)
    
    draw_cctv(o, l, w, h, t, f_cctv)