#Author-Saeed Hamza
#Description-Normalizing a surface by selection

import adsk.core, adsk.fusion, adsk.cam, traceback

def CreateTop1EdgeDefinitionByCurve(brepBodyDef, iso_crv, startPoint, endPoint):
    edgeDef = adsk.fusion.BRepEdgeDefinition.cast(None)
    # Create vertex definition
    startVertexDef = brepBodyDef.createVertexDefinition(startPoint)
    endVertexDef = brepBodyDef.createVertexDefinition(endPoint) 
    # Create edge definition by curve
    edgeDef = brepBodyDef.createEdgeDefinitionByCurve(startVertexDef, endVertexDef, iso_crv)

    return edgeDef 


def CreateFaceForBodyDefination(brepBodyDef, surface, edgeDefs):   
    faceDef = adsk.fusion.BRepFaceDefinition.cast(None)
    
    # Create lump definition
    lumpDefs = brepBodyDef.lumpDefinitions
    lumpDef = lumpDefs.add()
    # Create shell definition
    shellDefs = lumpDef.shellDefinitions
    shellDef = shellDefs.add()
    # Create face definition
    faceDefs = shellDef.faceDefinitions
    faceDef = faceDefs.add(surface, True)

    # Create loop definition
    loopDefs = faceDef.loopDefinitions
    loopdef = loopDefs.add()
    
    # Create coEdge definitions
    brepCoEdgeDefs = loopdef.bRepCoEdgeDefinitions   
    for edgeDef in edgeDefs:
        brepCoEdgeDefs.add(edgeDef, True)

    return faceDef 


def CalcualteKnotVector( degree, nPoints, IsUniform, upperKnotLimit):
    if degree + 1 > nPoints or nPoints == 0 :
        return
    
    outText = []

    n = nPoints
    m = n + degree + 1
    divisor = m - 1 - 2 * degree
    knot_step = upperKnotLimit / divisor
    knot_step_add = knot_step

    if IsUniform == True :
        outText.append(0)
        for i in range(0,m,1) :
            if i >= m-1 :
                outText.append(upperKnotLimit)
            else :
                dividend = m-1
                outText.append(i / dividend)

    else :
        for i in range(0,m,1) :
            if i <= degree :
                outText.append(0)

            elif i >= m-degree-1 :
                outText.append(upperKnotLimit)
                
            else :
                outText.append(knot_step)
                knot_step += knot_step_add
                
    # print("dividend = " + str(dividend))
    # print("divisor = " + str(divisor))
    # print("m = " + str(m))
    # print("n = " + str(n))
    # print("m = " + str(m))
    # print("divisor = " + str(divisor))
    return outText


def run(context):
    ui = None
    try:
        app = adsk.core.Application.get()
        ui  = app.userInterface
        
        design = adsk.fusion.Design.cast(app.activeProduct)

        rootComp = design.rootComponent
        features = rootComp.features
        sketches = rootComp.sketches

        sele_list = []

        selections = ui.activeSelections
        for selection in selections:
            sele_list.append(selection.entity)

        print(len(sele_list))

        for sele in sele_list :
            face_eval = sele.evaluator    

            u_subdiv = 15
            v_subdiv = 15
            
            sketch = sketches.add(rootComp.xYConstructionPlane)    
            points = sketch.sketchPoints
            splines = sketch.sketchCurves.sketchFittedSplines

            isUDirection = True
            isVDirection = False

            u_splines_list = []
            v_splines_list = []

            edge_from_face = sele.edges[1]
            print(edge_from_face.classType())
            edge_eval = edge_from_face.evaluator
            (_, startParameter, endParameter) = edge_eval.getParameterExtents()
            (_, length) = edge_eval.getLengthAtParameter(startParameter, endParameter)

            gap = length / u_subdiv
            length_step = 0

            for para in range(0, u_subdiv+1, 1) :
                (_, parameter) = edge_eval.getParameterAtLength(startParameter, length_step)
                u_iso = face_eval.getIsoCurve(parameter, isUDirection)
                print(length_step)

                for iso in u_iso :
                    u_splines_list.append(splines.addByNurbsCurve(iso))

                length_step += gap


            edge_from_face = sele.edges[0]
            print(edge_from_face.classType())
            edge_eval = edge_from_face.evaluator
            (_, startParameter, endParameter) = edge_eval.getParameterExtents()
            (_, length) = edge_eval.getLengthAtParameter(startParameter, endParameter)
            print(length)
            gap = length / v_subdiv
            length_step = 0

            for para in range(0, v_subdiv+1, 1) :
                (_, parameter) = edge_eval.getParameterAtLength(startParameter, length_step)
                (_, point) = edge_eval.getPointAtParameter(parameter)
                print(parameter)
                v_iso = face_eval.getIsoCurve(parameter, isVDirection)
                print(length_step)

                for iso in v_iso :
                    v_splines_list.append(splines.addByNurbsCurve(iso))

                points.add(point)

                length_step += gap

            
            path_sections = []

            for spline in u_splines_list :
                path = adsk.fusion.Path.create(spline, 0)
                path_sections.append(path)


            loftFeatures = rootComp.features.loftFeatures
            input = loftFeatures.createInput(adsk.fusion.FeatureOperations.NewBodyFeatureOperation)
            loftSections = input.loftSections

            for section in path_sections :
                loftSections.add(section)

            loftCenterLineOrRails = input.centerLineOrRails

            for rail in v_splines_list :
                loftCenterLineOrRails.addRail(rail)

            input.isSolid = False
            loftFeature = loftFeatures.add(input)

  
    except:
        if ui:
            ui.messageBox('Failed:\n{}'.format(traceback.format_exc()))