import rhinoscriptsyntax as rs
import random as ran
import flipped_classroom_lib as fc
reload(fc)

rs.DeleteObjects(rs.AllObjects())

###############################################################
# Your Panel functions...
###############################################################
 
def my_panel(points, scale, offset):
    #rs.AddSrfPt(points)
    (P0,P1,P2,P3) = points
    pline = rs.AddPolyline([P0,P1,P2,P3,P0])                    #geschlossene Polylinie
    
    #rs.AddLine(P0,P2)                                           #erste Diagonale
    d_cen1 = rs.VectorDivide(rs.VectorAdd(P0,P2),2)             #Zentrum der ersten Diagonale
    #rs.AddPoint(d_cen1)                                         #Puntk im Zentrum der ersten Diagonale
    
    #rs.AddLine(P1,P3)                                           #zweite Diagonale
    d_cen2 = rs.VectorDivide(rs.VectorAdd(P1,P3),2)             #Zentrum der zweiten Diagonale
    #rs.AddPoint(d_cen2)                                         #Punkt im Zentrum der zweiten Diagonale
    
    center_pt = rs.VectorDivide(rs.VectorAdd(d_cen1, d_cen2),2)
    #rs.AddPoint(center_pt)                                      #Mittelpunkt dder beiden Zentrumspunkte
    #if not (rs.PointCompare(d_cen1, d_cen2)):                   #sind die Punkte ident?
    #    rs.AddLine(d_cen1, d_cen2)                              #Verbindung der beiden Zetrumspunkte
    
    vec1 = rs.VectorSubtract(P0, center_pt)
    vec2 = rs.VectorSubtract(center_pt, P3)
    normal =  rs.VectorCrossProduct(vec1, vec2)
    u_normal = rs.VectorUnitize(normal)
    su_normal = rs.VectorScale(u_normal, scale)                 #Laenge des Vektors
    normal_pt = rs.VectorAdd(center_pt, su_normal)
    #rs.AddPoint(normal_pt)
    #rs.AddLine(center_pt, normal_pt)
    
    
    off_1 = rs.ScaleObject(pline, center_pt, [scale, scale, scale], copy = True)
    s_points = rs.CurvePoints(off_1)
    off_1_s = rs.CopyObject(off_1, su_normal/2)
    ss_points = rs.CurvePoints(off_1_s)
    #herausstehender Rahmen
    rs.AddSrfPt([ss_points[0], s_points[0], s_points[1], ss_points[1]])
    rs.AddSrfPt([ss_points[1], s_points[1], s_points[2], ss_points[2]])
    rs.AddSrfPt([ss_points[2], s_points[2], s_points[3], ss_points[3]])
    rs.AddSrfPt([ss_points[3], s_points[3], s_points[0], ss_points[0]])
    #Rahmen auf der 0Ebene
    rs.AddSrfPt([P0, s_points[0], s_points[1], P1])
    rs.AddSrfPt([P1, s_points[1], s_points[2], P2])
    rs.AddSrfPt([P2, s_points[2], s_points[3], P3])
    rs.AddSrfPt([P3, s_points[3], s_points[0], P0])
    
    off_2 = rs.ScaleObject(off_1, center_pt, [scale*0.8, scale*0.8, scale*0.8], copy = True)
    s2_points = rs.CurvePoints(off_2)
    off_2_s = rs.MoveObject(off_2, su_normal/2)
    ss2_points = rs.CurvePoints(off_2_s)
    
    rs.AddSrfPt([ss2_points[0], ss_points[0], ss_points[1], ss2_points[1]])
    rs.AddSrfPt([ss2_points[1], ss_points[1], ss_points[2], ss2_points[2]])
    rs.AddSrfPt([ss2_points[2], ss_points[2], ss_points[3], ss2_points[3]])
    rs.AddSrfPt([ss2_points[3], ss_points[3], ss_points[0], ss2_points[0]])
    
    #Pyramide kreieren
    scale = ran.randint(0,2)
    su_normal = rs.VectorScale(u_normal, scale)                 #Laenge des Vektors
    normal_pt = rs.VectorAdd(center_pt, su_normal)
    
    pyr = []
    pyr.append(rs.AddSrfPt([ss2_points[0], normal_pt, ss2_points[1]]))
    pyr.append(rs.AddSrfPt([ss2_points[1], normal_pt, ss2_points[2]]))
    pyr.append(rs.AddSrfPt([ss2_points[2], normal_pt, ss2_points[3]]))
    pyr.append(rs.AddSrfPt([ss2_points[3], normal_pt, ss2_points[0]]))
    #rs.MoveObject(pyr, [0, -offset, 0])
    
    rs.HideObjects([pline, off_1, off_1_s, off_2_s])

def my_panel_frame(points, scale, offset):
    #rs.AddSrfPt(points)
    (P0,P1,P2,P3) = points
    pline = rs.AddPolyline([P0,P1,P2,P3,P0])                    #geschlossene Polylinie
    
    #rs.AddLine(P0,P2)                                           #erste Diagonale
    d_cen1 = rs.VectorDivide(rs.VectorAdd(P0,P2),2)                            #Zentrum der ersten Diagonale
    #rs.AddPoint(d_cen1)                                         #Puntk im Zentrum der ersten Diagonale
    
    #rs.AddLine(P1,P3)                                           #zweite Diagonale
    d_cen2 = rs.VectorDivide(rs.VectorAdd(P1,P3),2)                            #Zentrum der zweiten Diagonale
    #rs.AddPoint(d_cen2)                                         #Punkt im Zentrum der zweiten Diagonale
    
    center_pt = rs.VectorDivide(rs.VectorAdd(d_cen1, d_cen2),2)
    #rs.AddPoint(center_pt)                                      #Mittelpunkt dder beiden Zentrumspunkte
    #if not (rs.PointCompare(d_cen1, d_cen2)):                   #sind die Punkte ident?
    #rs.AddLine(d_cen1, d_cen2)                                  #Verbindung der beiden Zetrumspunkte
    
    vec1 = rs.VectorSubtract(P0, center_pt)
    vec2 = rs.VectorSubtract(center_pt, P3)
    normal =  rs.VectorCrossProduct(vec1, vec2)
    u_normal = rs.VectorUnitize(normal)
    su_normal = rs.VectorScale(u_normal, scale)                 #Laenge des Vektors
    normal_pt = rs.VectorAdd(center_pt, su_normal)
    #rs.AddPoint(normal_pt)
    #rs.AddLine(center_pt, normal_pt)
    
    #off_1 = rs.OffsetCurve(pline, center_pt, offset, u_normal)
    off_1 = rs.ScaleObject(pline, center_pt, [scale, scale, scale], copy = True)
    s_points = rs.CurvePoints(off_1)
    
    #create front of frame

    off_1_s = rs.CopyObject(off_1, su_normal)
    ss_points = rs.CurvePoints(off_1_s)
    rs.AddSrfPt([ss_points[0], s_points[0], s_points[1], ss_points[1]])
    rs.AddSrfPt([ss_points[1], s_points[1], s_points[2], ss_points[2]])
    rs.AddSrfPt([ss_points[2], s_points[2], s_points[3], ss_points[3]])
    rs.AddSrfPt([ss_points[3], s_points[3], s_points[0], ss_points[0]])

    off_2 = rs.ScaleObject(off_1, center_pt, [scale, scale, scale], copy = True)
    s2_points = rs.CurvePoints(off_2)

    off_2_s = rs.CopyObject(off_2, su_normal*2)
    ss2_points = rs.CurvePoints(off_2_s)
    rs.AddSrfPt([ss2_points[0], s2_points[0], s2_points[1], ss2_points[1]])
    rs.AddSrfPt([ss2_points[1], s2_points[1], s2_points[2], ss2_points[2]])
    rs.AddSrfPt([ss2_points[2], s2_points[2], s2_points[3], ss2_points[3]])
    rs.AddSrfPt([ss2_points[3], s2_points[3], s2_points[0], ss2_points[0]])

    off_3 = rs.ScaleObject(off_2, center_pt, [scale, scale, scale], copy = True)
    s3_points = rs.CurvePoints(off_3)

    off_3_s = rs.CopyObject(off_3, su_normal*3)
    ss3_points = rs.CurvePoints(off_3_s)
    rs.AddSrfPt([ss3_points[0], s3_points[0], s3_points[1], ss3_points[1]])
    rs.AddSrfPt([ss3_points[1], s3_points[1], s3_points[2], ss3_points[2]])
    rs.AddSrfPt([ss3_points[2], s3_points[2], s3_points[3], ss3_points[3]])
    rs.AddSrfPt([ss3_points[3], s3_points[3], s3_points[0], ss3_points[0]])

    #Rahmenflaeche
    rs.AddSrfPt([P0, s3_points[0], s3_points[1], P1])
    rs.AddSrfPt([P1, s3_points[1], s3_points[2], P2])
    rs.AddSrfPt([P2, s3_points[2], s3_points[3], P3])
    rs.AddSrfPt([P3, s3_points[3], s3_points[0], P0])

    srf = rs.AddSrfPt([s3_points[0], s3_points[1], s3_points[2], s3_points[3]])
    rs.MoveObject(srf, su_normal*3)
    
    rs.HideObjects([pline, off_1, off_2, off_3, off_1_s, off_2_s, off_3_s])
    #Pyramide kreieren
    """
    rs.AddSrfPt([P0, normal_pt, P1])
    rs.AddSrfPt([P1, normal_pt, P2])
    rs.AddSrfPt([P2, normal_pt, P3])
    rs.AddSrfPt([P3, normal_pt, P0])
    """

def my_panel_grid(points, split):
    (P0,P1,P2,P3) = points
    L_L = rs.AddLine(P0, P3)
    R_L = rs.AddLine(P1, P2)
    v_lines = [L_L, R_L]                    #Liste der vertikalen Linien
    
    edge_pts = []
    for e in v_lines:
        rs.RebuildCurve(e, 1, split)
        edge_pts.extend(rs.CurvePoints(e))
    grid_pts = []
    for i in range (split):
        hline = rs.AddLine(edge_pts[i], edge_pts[i+split])
        rs.RebuildCurve(hline, 1, split)
        grid_pts.extend(rs.CurvePoints(hline))
    for i,p in enumerate(grid_pts):
        rs.AddPoint(p)
        cmd = "-Dot {} {} _Enter ".format (str(i), str(p))
        rs.Command(cmd, False)



###############################################################

rs.EnableRedraw(False)

#quad = [[0,0,0], [10,0,0], [10,0,12], [0,0,12]]
#quad = [[0,0,0], [10,4,0], [10,4,12], [0,0,12]]
#quad = [[0,0,0], [10,0,0], [10,2,12], [0,2,12]]
#quad = [[0,0,0], [10,0,0], [8,2,12], [2,2,12]]
#quad = [[0,0,0], [10,2,0], [10,-2,12], [0,2,10]]
     
#result_list = fc.PEF_single_face(quad)
#result_list = fc.PEF_face(7, 10, 8.0, 5.0, 30)
#result_list = fc.PEF_face_w(7, 10, 8.0, 5.0, 30, 2.0)
result_list = fc.PEF_pantheon()

p_list = result_list[0]  # Pointlist, contains single points
e_list = result_list[1]  # Horizontal Edgelist, contains lists with two points
ve_list = result_list[2] # Vertical Edgelist, contains lists with two points
f_list = result_list[3]  # Facelist, contans lists with four points (quads)
zcol = result_list[4]    # number of levels of faces
xcol = result_list[5]    # number of faces in one level
print "there are " + str(len(p_list)) + " points and " + str(len(f_list)) + " faces on " + str(zcol) + " levels, "+str(xcol)+" per level!"



if 1:
    for i in range(zcol):
        for j in range(xcol):
            points = f_list[i*xcol+j]
            scale = ran.uniform(0.5, 8.5)
            my_panel(f_list[i*xcol+j], 0.9, 1.5)
            #rs.AddSrfPt(f_list[i*xcol+j])

if 0:
    for i in range(zcol):
        for j in range(xcol):
            points = f_list[i*xcol+j]
            scale = ran.uniform(0.5, 8.5)
            my_panel_frame(f_list[i*xcol+j], 0.9, 1.5)
            #rs.AddSrfPt(f_list[i*xcol+j])

if 0:
    for i in range(zcol):
        for j in range(xcol):
            points = f_list[i*xcol+j]
            #scale = ran.uniform(0.5, 8.5)
            my_panel_grid(f_list[i*xcol+j], 8)
            #rs.AddSrfPt(f_list[i*xcol+j])

#############################################################################
# DOTS to explain the lists
#############################################################################
if 0:  # put a dot on each point and create a Point
    for i,pt in enumerate(p_list):
        rs.AddPoint(pt)
        cmd = "-Dot {} {} _Enter ".format(str(i),str(pt))
        rs.Command(cmd, False)

if 0:  # put a dot on each horizontal edge and create a line
    for i,e in enumerate(e_list):
        rs.AddLine(e[0],e[1])
        cmd = "-Dot {} {} _Enter ".format(i,int(e[0]))
        rs.Command(cmd, False)

if 0:  # put a dot on each vertical edge and create a line
    for i,ve in enumerate(ve_list):
        rs.AddLine(ve[0],ve[1])
        cmd = "-Dot {} {} _Enter ".format(i,ve[0])
        rs.Command(cmd, False)

if 0:  # put a dot on each face and create a surface
    for i, quad in enumerate(f_list):
        rs.AddSrfPt(quad)
        cmd = "-Dot {} {} _Enter ".format(i,quad[0])
        rs.Command(cmd, False)

#############################################################################
# Some experiments with the lists
#############################################################################
if 0:
    for i, quad in enumerate(f_list):
        if i%2:
            rs.AddSrfPt(quad)

if 0:
    for i in range(zcol):
        for j in range(xcol):
            if (i+j)%2:
                rs.AddSrfPt(f_list[i*xcol+j])

if 1: # last row in pantheon ceiling is flat
    for i in range(zcol):
        for j in range(xcol):
            if i != zcol-1:
                points = f_list[i*xcol+j]
                scale = ran.uniform(0.5,8.5)
                my_panel(f_list[i*xcol+j], 0.9, 1.5)
            else:
                rs.AddSrfPt(f_list[i*xcol+j])

if 0:
    for i in range(zcol):
        for j in range(xcol):
            points = f_list[i*xcol+j]
            (P0,P1,P2,P3) = points
            cpoints=[P0,P1,P2,P3,P0]
            plinea = rs.AddCurve(cpoints,2)
            plineb = rs.AddCurve(cpoints,3)
            #loftsurf = rs.AddLoftSrf([plinea, plineb])
            rs.Command("-_Loft selid {} selid {} _Enter _Enter _Enter".format(plinea, plineb), False)
            loftsurf = rs.FirstObject()
            rs.OffsetSurface(loftsurf, .2, both_sides=True, create_solid=True) 


if 0:
    for line in e_list:
        mline = rs.AddLine(line[0], line[1])
        rs.AddPipe(mline, 0, 0.3, cap=2)
    for line in ve_list:
        mline = rs.AddLine(line[0], line[1])
        rs.AddPipe(mline, 0, 0.2, cap=2)
   
rs.EnableRedraw(True)