# Copyright (c) 2026 JSOL CORPORATION
#
# This script is released under the MIT License.
# See the full license text at:
# https://www.jmag-international.com/scriptlibrary/jmag_script_library_mit/

app = designer.GetApplication()
geomApp = app.CreateGeometryEditor()
geomDoc = geomApp.GetDocument()

# Dimensional parameters
HelixPitch = 50
HelixStartX = 0
HelixStartY = 0
HelixStartZ = 0
HelixTurn = 5
HelicalRadius = 100
TubeRadius = 20

# Equation names
EqPitch = u"pitch"
EqStartX = u"start_x"
EqStartY = u"start_y"
EqStartZ = u"start_z"
EqTurn = u"turn"
EqHelicalRadius = u"helical_radius"
EqTubeRadius = u"tube_radius"


def createNewPart():
    """Create a new Part and open it in edit mode."""
    assm = geomDoc.GetAssembly()
    part = assm.CreatePart()
    part.OpenPart()

    return part


def setupEquation(equation, expression):
    """Configure the basic settings for equations in DesignTable."""

    # The argument of SetType
    # 0: Value
    # 1: Expression
    equation.SetType(0)
    equation.SetExpression(str(expression))


def createHelixEquations():
    """Register the helix start coordinates, pitch, number of turns, and radii as equations."""
    designTable = geomDoc.GetDesignTable()
    equationDataList = [
        (EqPitch, HelixPitch),
        (EqStartX, HelixStartX),
        (EqStartY, HelixStartY),
        (EqStartZ, HelixStartZ),
        (EqTurn, HelixTurn),
        (EqHelicalRadius, HelicalRadius),
        (EqTubeRadius, TubeRadius),
    ]

    designTable.EditStart()

    for equationName, expression in equationDataList:
        designTable.AddEquation(equationName)
        equation = designTable.GetEquation(equationName)
        setupEquation(equation, expression)

    designTable.EditEnd()


def createOffsetYZPlane(part):
    """Create a YZ plane offset by start_x."""
    refYZPlane = part.GetPlaneYZ()

    offsetPlane = part.CreateReferencePlane()
    offsetPlane.SetTypeByString(u"Distance")
    offsetPlane.SetPropertyByReference(u"Plane", refYZPlane)
    offsetPlane.SetProperty(u"Distance", EqStartX)

    return offsetPlane


def createSketchOnHelixPlane(part):
    """Create a sketch on the YZ plane offset by start_x."""
    offsetPlane = createOffsetYZPlane(part)
    offsetPlaneRef = geomDoc.CreateReferenceFromItem(offsetPlane)

    sketch = part.CreateSketch(offsetPlaneRef)

    return sketch


def createRegionFromItems(sketch, itemList):
    """Create a region on the sketch from all items in the argument's itemList."""
    selection = geomDoc.GetSelection()
    selection.Clear()
    for item in itemList:
        selection.Add(item)
    sketch.CreateRegions()
    selection.Clear()


def setConstraintExpression(constraint, propertyName, equationName):
    """Set an equation name to the specified constraint property."""
    constraint.SetProperty(propertyName, equationName)


def getDistanceExpressionFromSignedValue(equationName, value):
    """Return a distance expression for a signed coordinate value."""
    if value < 0:
        return u"-" + equationName

    return equationName


def drawBaseShapeForHelix(sketch, helicalRadius, tubeRadius):
    """Create the circle that forms the helix cross-section and the helix axis, and generate the region."""
    sketch.OpenSketch()

    # In a sketch on the YZ plane, the sketch X-direction corresponds to the Y-direction, and the sketch Y-direction corresponds to the Z-direction.
    sketchStartX = HelixStartY
    sketchStartY = HelixStartZ

    # Reference point on the helix axis
    axisPointVertex = sketch.CreateVertex(sketchStartX, sketchStartY)
    axisPointRef = geomDoc.CreateReferenceFromItem(axisPointVertex)
    # Helix axis in the Y-direction
    axisLine = sketch.CreateLine(
        sketchStartX - helicalRadius,
        sketchStartY,
        sketchStartX + helicalRadius,
        sketchStartY
    )
    axisRef = geomDoc.CreateReferenceFromItem(axisLine)
    sketch.CreateMonoConstraint(u"horizontality", axisRef)
    sketch.CreateBiConstraint(u"coincident", axisRef, axisPointRef)
    # Constrain the Y-position of the reference point on the helix axis using an equation.
    startYConstraint = sketch.CreateMonoConstraint(
        u"distancefromyaxis",
        axisPointRef
    )
    startYDistanceExpression = getDistanceExpressionFromSignedValue(
        EqStartY,
        HelixStartY
    )
    setConstraintExpression(
        startYConstraint,
        u"Distance",
        startYDistanceExpression
    )
    # Constrain the Z-position of the helix axis using an equation.
    startZConstraint = sketch.CreateMonoConstraint(
        u"distancefromxaxis",
        axisPointRef
    )
    startZDistanceExpression = getDistanceExpressionFromSignedValue(
        EqStartZ,
        HelixStartZ
    )
    setConstraintExpression(
        startZConstraint,
        u"Distance",
        startZDistanceExpression
    )

    # Center of the tube cross-section
    tubeCenterVertex = sketch.CreateVertex(
        sketchStartX,
        sketchStartY + helicalRadius
    )
    tubeCenterRef = geomDoc.CreateReferenceFromItem(tubeCenterVertex)
    # Construction line representing the helix radius
    radiusLine = sketch.CreateLine(
        sketchStartX,
        sketchStartY,
        sketchStartX,
        sketchStartY + helicalRadius
    )
    radiusLineRef = geomDoc.CreateReferenceFromItem(radiusLine)
    # Constrain the construction line to be perpendicular to the helix axis, and set the distance to the tube cross-section center using an equation.
    sketch.CreateBiConstraint(u"perpendicularity", axisRef, radiusLineRef)
    sketch.CreateBiConstraint(u"coincident", radiusLineRef, axisPointRef)
    sketch.CreateBiConstraint(u"coincident", radiusLineRef, tubeCenterRef)
    helicalRadiusConstraint = sketch.CreateBiConstraint(
        u"distance",
        axisPointRef,
        tubeCenterRef
    )
    setConstraintExpression(helicalRadiusConstraint, u"Distance", EqHelicalRadius)
    # Circle that forms the tube cross-section
    tubeCircle = sketch.CreateCircle(
        sketchStartX,
        sketchStartY + helicalRadius,
        tubeRadius
    )
    tubeCircleRef = geomDoc.CreateReferenceFromItem(tubeCircle)
    # Constrain the radius of the tube cross-section using an equation.
    tubeRadiusConstraint = sketch.CreateMonoConstraint(
        u"radius",
        tubeCircleRef
    )
    setConstraintExpression(tubeRadiusConstraint, u"Radius", EqTubeRadius)

    # Create a closed region from the tube cross-section circle.
    createRegionFromItems(sketch, [tubeCircle])

    sketch.CloseSketch()

    return axisLine


def createHelixByRevolve(part, sketch, axisLine):
    """Rotate the circular region around the helix axis to create the helical shape."""
    revolve = part.CreateRevolveSolid(sketch)

    revolve.SetTypeByName(u"OneSide")
    revolve.SetProperty(u"AxisType", u"SelectEntity")

    axisRef = geomDoc.CreateReferenceFromItem(axisLine)
    revolve.SetAxis(axisRef)

    revolve.SetProperty(u"UseHelical", True)
    revolve.SetProperty(u"HelicalPitch", EqPitch)

    revolve.SetProperty(u"Reverse", True)
    revolve.SetProperty(u"Angle", u"360.0*" + EqTurn)
    return revolve


def createHelixPart(part):
    """Create a helical shape with equations in the specified Part."""
    sketch = createSketchOnHelixPlane(part)
    axisLine = drawBaseShapeForHelix(sketch, HelicalRadius, TubeRadius)
    createHelixByRevolve(part, sketch, axisLine)


def main():
    """Create a Part containing a helical shape with equations."""
    createHelixEquations()

    part = createNewPart()
    createHelixPart(part)
    part.ClosePart()


main()