import rhinoscriptsyntax as rs
import ghpythonlib.treehelpers as th
import sys
import clr
clr.AddReferenceToFileAndPath("C:\\Users\\Xiujin\\AppData\\Roaming\\McNeel\\Rhinoceros\\packages\\7.0\\Karamba3D\\2.2.0.14\\Karamba.gha")
clr.AddReferenceToFileAndPath("C:\\Users\\Xiujin\\AppData\\Roaming\\McNeel\\Rhinoceros\\packages\\7.0\\Karamba3D\\2.2.0.14\\KarambaCommon.dll")
import feb
import Karamba.Models.Model as Model
import Karamba.GHopper.Models.GH_Model as GH_Model
import Karamba
import Karamba.Elements.ModelTruss as Truss
from Karamba.Geometry import Point3, Line3, Vector3
from Karamba.CrossSections import CroSec
from Karamba.Supports import Support
from Karamba.Loads import Load
from Karamba.Utilities import MessageLogger
"""UnitsConversionFactories"""
import KarambaCommon
import System
from System import GC
from System.Collections.Generic import List

class BasicStructure:
    def __init__(self, celing_length_x, celing_length_y, num_load_x, num_load_y, celing_height, support_list):
        self.celing_length_x = celing_length_x
        self.celing_length_y = celing_length_y
        self.num_load_x = num_load_x
        self.num_load_y = num_load_y
        self.celing_height = celing_height
        self.support_list = support_list
    def generate_grid(self):
        gap_load_x = self.celing_length_x/self.num_load_x
        gap_load_y = self.celing_length_y/self.num_load_y
        vertical_line_list = []
        horizontal_line_list = []
        self.point_list = []
        for i in range(self.num_load_x):
            horizontal_line_list.append([])
            vertical_line_list.append([])
            self.point_list.append([])
            for j in range(self.num_load_y):
                self.point_list[i].append(rs.AddPoint(i*gap_load_x, j*gap_load_y,self.celing_height))
                if i < self.num_load_x - 1 and j < self.num_load_y - 1:
                    horizontal_line_list[i].append(0)
                    horizontal_line_list[i][j] = rs.AddLine((i*gap_load_x, j*gap_load_y,self.celing_height), ((i+1)*gap_load_x, j*gap_load_y,self.celing_height))
                    vertical_line_list[i].append(0)
                    vertical_line_list[i][j] = rs.AddLine((i*gap_load_x, j*gap_load_y,self.celing_height), (i*gap_load_x, (j+1)*gap_load_y,self.celing_height))
                elif j == self.num_load_y-1 and i < self.num_load_x - 1:
                    horizontal_line_list[i].append(0)
                    horizontal_line_list[i][j] = rs.AddLine((i*gap_load_x, j*gap_load_y,self.celing_height), ((i+1)*gap_load_x, j*gap_load_y,self.celing_height))
                elif i == self.num_load_x-1 and j < self.num_load_y - 1:
                    vertical_line_list[i].append(0)
                    vertical_line_list[i][j] = rs.AddLine((i*gap_load_x, j*gap_load_y,self.celing_height), (i*gap_load_x, (j+1)*gap_load_y,self.celing_height))
        return vertical_line_list, horizontal_line_list
    def generate_leg(self):
        x_coordinate_list = []
        y_coordinate_list = []
        support_point_list = []
        leg_list = []
        for i in range(len(self.support_list)):
            if i%2 == 0:
                x_coordinate_list.append(self.support_list[i])
            if i%2 != 0:
                y_coordinate_list.append(self.support_list[i])
        for i in range(len(x_coordinate_list)):
            support_point_list.append(rs.AddPoint(x_coordinate_list[i], y_coordinate_list[i], 0))
        for i in range(len(support_point_list)):
            distance_min = sys.maxsize
            point_min = self.point_list[2][2]
            for j in range(len(self.point_list)):
                for k in range(len(self.point_list[i])):
                    distance_2pt = rs.Distance(support_point_list[i], self.point_list[j][k])
                    if distance_2pt < distance_min:
                        distance_min = distance_2pt
                        point_min = self.point_list[j][k]
            leg_list.append(rs.AddLine(support_point_list[i], point_min)) 
        return self.point_list, leg_list
support_list = th.tree_to_list(support_list)
grid = BasicStructure(celing_length_x, celing_length_y, num_load_x, num_load_y, celing_height, support_list)
vertical_line_list, horizontal_line_list = grid.generate_grid()
line_list = vertical_line_list + horizontal_line_list 
point_list, leg_list = grid.generate_leg()




logger = MessageLogger();
k3d = KarambaCommon.Toolkit();
L= []
for i in range(len(line_list)):
    for j in range(len(line_list[i])):
        p0 = Point3(rs.CurveStartPoint(line_list[i][j])[0], rs.CurveStartPoint(line_list[i][j])[1], rs.CurveStartPoint(line_list[i][j])[2])
        p1 = Point3(rs.CurveEndPoint(line_list[i][j])[0], rs.CurveEndPoint(line_list[i][j])[1], rs.CurveEndPoint(line_list[i][j])[2])
        L.append(Line3(p0,p1))
for i in range(len(leg_list)):
    p0 = Point3(rs.CurveStartPoint(leg_list[i])[0], rs.CurveStartPoint(leg_list[i])[1], rs.CurveStartPoint(leg_list[i])[2])
    p1 = Point3(rs.CurveEndPoint(leg_list[i])[0], rs.CurveEndPoint(leg_list[i])[1], rs.CurveEndPoint(leg_list[i])[2])
    L.append(Line3(p0,p1))
nodes = clr.Reference[List[Point3]]()
elems = k3d.Part.LineToBeam(List[Line3](L), List[str](["B1"]), List[CroSec](), logger, nodes);

cond = List[System.Boolean]([True for i in range(6)])
P_support = []
for i in range(len(leg_list)):
    p = Point3(rs.CurveStartPoint(leg_list[i])[0], rs.CurveStartPoint(leg_list[i])[1], rs.CurveStartPoint(leg_list[i])[2])
    P_support.append(k3d.Support.Support(p, cond))
supports = List[Support](P_support);
    
P_load = []
for i in range(len(point_list)):
    for j in range(len(point_list[i])):
        rs.PointCoordinates
        p = Point3(rs.PointCoordinates(point_list[i][j])[0], rs.PointCoordinates(point_list[i][j])[1], rs.PointCoordinates(point_list[i][j])[2])
        P_load.append(k3d.Load.PointLoad(p, Vector3(0, 0, -2), Vector3()))
ploads = List[Load](P_load);
mass = clr.Reference[float]()
cog = clr.Reference[Point3]()
warning_flag = clr.Reference[bool]()
info = clr.Reference[str]()
msg = clr.Reference[str]()
model = k3d.Model.AssembleModel(elems, supports, ploads, info, mass, cog, msg, warning_flag)
MaxUtil = clr.Reference[List[float]]()
MaxDisp = clr.Reference[List[float]]()
compliances = clr.Reference[str]()
Elemid = List[float]([])
groupid = List[float]([])
resourcePath = R'C:\Program Files\Rhino 7\Plug-ins\Karamba\CrossSections'
crosecPath = System.IO.Path.Combine(resourcePath, 'CrossSectionValues.bin')
croSecTable, info = k3d.CroSec.ReadCrossSectionTable(crosecPath)
inCroSecs_L = croSecTable.crosecs
inCroSecs_readOnlyL = inCroSecs_L.AsReadOnly()
msg = clr.Reference[List[float]]()
model = k3d.Algorithms.OptiCroSec(model, inCroSecs_L, MaxDisp, MaxUtil, clr.Reference[str]())
Model_out = Karamba.GHopper.Models.GH_Model(model)

model = k3d.Algorithms.OptiCroSec( model, inCroSecs_readOnlyL, MaxDisp, MaxUtil, clr.Reference[str]() )






vertical_line_list = th.list_to_tree(vertical_line_list)
horizontal_line_list = th.list_to_tree(horizontal_line_list)
point_list = th.list_to_tree(point_list)