# -*- coding: utf-8 -*-
import rhinoscriptsyntax as rs
import random as ran
import sys

# Make sure the path to your library is known (adjust to your local path):
sys.path.append(r"C:\Path\To\Your\Library")
import flipped_classroom_lib as fc
reload(fc)

# 1) Clear the scene
rs.DeleteObjects(rs.AllObjects())
rs.EnableRedraw(False)

############################################
# Custom panel function: "abstract spiky" version
############################################
def my_abstract_spike_panel(points, 
                            spike_h_range=(1.0, 8.0), 
                            tilt_range=0.3, 
                            base_offset_range=(0.0, 1.5)):
    """
    Takes a face (4 corner points), computes its center and normal,
    and creates a more 'abstract' spiky geometry:
      - random spike height in spike_h_range
      - random tilt of the spike's normal vector
      - optional offset at the base for a 'thicker' root.
    """
    if len(points) != 4:
        return
    
    P0, P1, P2, P3 = points
    # Compute face center (average of corners)
    center = [
        (P0[0] + P1[0] + P2[0] + P3[0]) / 4.0,
        (P0[1] + P1[1] + P2[1] + P3[1]) / 4.0,
        (P0[2] + P1[2] + P2[2] + P3[2]) / 4.0
    ]
    
    # Compute normal from cross product
    v1 = rs.VectorSubtract(P1, P0)
    v2 = rs.VectorSubtract(P3, P0)
    normal = rs.VectorUnitize(rs.VectorCrossProduct(v1, v2))
    
    # Random tilt: we rotate the normal by up to tilt_range in X and Y directions
    # This makes spikes deviate from the original face normal.
    # A small tilt_range like 0.3 => up to 30% of the original normal in XY directions
    tilt_x = ran.uniform(-tilt_range, tilt_range)
    tilt_y = ran.uniform(-tilt_range, tilt_range)
    # We treat these as small offsets in local basis (u, v).
    # u = unitize(v1), v = cross(normal, u)
    u = rs.VectorUnitize(v1)
    v = rs.VectorUnitize(rs.VectorCrossProduct(normal, u))
    # Apply tilt in local coords:
    normal = rs.VectorAdd(normal, rs.VectorScale(u, tilt_x))
    normal = rs.VectorAdd(normal, rs.VectorScale(v, tilt_y))
    normal = rs.VectorUnitize(normal)
    
    # Random spike height
    spike_h = ran.uniform(spike_h_range[0], spike_h_range[1])
    
    # Spike tip is center + normal * spike_h
    spike_top = rs.VectorAdd(center, rs.VectorScale(normal, spike_h))
    
    # Optional base offset => the corners are moved slightly along normal * negative
    # so the base has thickness or an inward slope. 
    base_offset = ran.uniform(base_offset_range[0], base_offset_range[1])
    
    # Shift corners "down" along normal => negative direction
    P0b = rs.VectorSubtract(P0, rs.VectorScale(normal, base_offset))
    P1b = rs.VectorSubtract(P1, rs.VectorScale(normal, base_offset))
    P2b = rs.VectorSubtract(P2, rs.VectorScale(normal, base_offset))
    P3b = rs.VectorSubtract(P3, rs.VectorScale(normal, base_offset))
    
    # Build 4 triangular surfaces from each corner to spike_top
    srfA = rs.AddSrfPt([P0b, P1b, spike_top])
    srfB = rs.AddSrfPt([P1b, P2b, spike_top])
    srfC = rs.AddSrfPt([P2b, P3b, spike_top])
    srfD = rs.AddSrfPt([P3b, P0b, spike_top])
    
    return [srfA, srfB, srfC, srfD]

############################################
# 2) Get dome geometry from flipped_classroom_lib
############################################
# Example: calling fc.PEF_pantheon() returns:
#   [p_list, e_list, ve_list, f_list, zcol, xcol]
result_list = fc.PEF_pantheon()

p_list = result_list[0]  # All points
e_list = result_list[1]  # Horizontal edges
ve_list = result_list[2] # Vertical edges
f_list = result_list[3]  # Face list: each face is [P0, P1, P2, P3]
zcol   = result_list[4]  # number of face-rows
xcol   = result_list[5]  # number of faces per row

print "Dome geometry loaded!"
print "Points:", len(p_list)
print "Faces:", len(f_list)
print "Levels (zcol):", zcol
print "Faces per level (xcol):", xcol

############################################
# 3) Replace simple AddSrfPt with our more abstract spiky function
############################################
for i in range(zcol):
    for j in range(xcol):
        face_points = f_list[i*xcol + j]
        # Create an abstract spiky geometry
        panels = my_abstract_spike_panel(
            face_points,
            spike_h_range=(2.0, 12.0),   # zackig: von 2 bis 12 Einheiten
            tilt_range=0.6,             # stärke der Neigung
            base_offset_range=(0.5, 2.5)# wie tief die Basis reingezogen wird
        )
        # Optional: Färbe die Panels zufällig
        col = (ran.randint(50,255), ran.randint(50,255), ran.randint(50,255))
        if panels:
            for p in panels:
                rs.ObjectColor(p, col)

############################################
# 4) Done!
############################################
rs.EnableRedraw(True)
rs.ZoomExtents()