# Copyright (c) 2026 JSOL CORPORATION
#
# 本スクリプトはMITライセンスのもとで公開しています。
# ライセンス全文は以下を参照してください。
# https://www.jmag-international.com/jp/scriptlibrary/jmag_script_library_mit/

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

# 寸法パラメータ
HelixPitch = 50
HelixStartX = 0
HelixStartY = 0
HelixStartZ = 0
HelixTurn = 5
HelicalRadius = 100
TubeRadius = 20

# 方程式名
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():
    """新しいPartを作成し、編集可能な状態で開く"""
    assm = geomDoc.GetAssembly()
    part = assm.CreatePart()
    part.OpenPart()

    return part


def setupEquation(equation, expression):
    """DesignTable上の方程式の基本設定を行う"""

    # The argument of SetType
    # 0: 値
    # 1: 式
    equation.SetType(0)
    equation.SetExpression(str(expression))


def createHelixEquations():
    """螺旋の開始座標、ピッチ、巻数、各半径を方程式として登録する"""
    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):
    """start_xでオフセットしたYZ平面を作成する"""
    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):
    """start_xでオフセットしたYZ平面上にスケッチを作成する"""
    offsetPlane = createOffsetYZPlane(part)
    offsetPlaneRef = geomDoc.CreateReferenceFromItem(offsetPlane)

    sketch = part.CreateSketch(offsetPlaneRef)

    return sketch


def createRegionFromItems(sketch, itemList):
    """引数のitemListすべてからスケッチ上に領域を作成する"""
    selection = geomDoc.GetSelection()
    selection.Clear()
    for item in itemList:
        selection.Add(item)
    sketch.CreateRegions()
    selection.Clear()


def setConstraintExpression(constraint, propertyName, equationName):
    """拘束寸法に方程式名を設定する"""
    constraint.SetProperty(propertyName, equationName)


def getDistanceExpressionFromSignedValue(equationName, value):
    """符号付き座標値から、距離拘束に使用する正の式を返す"""
    if value < 0:
        return u"-" + equationName

    return equationName


def drawBaseShapeForHelix(sketch, helicalRadius, tubeRadius):
    """螺旋の断面となる円と螺旋軸を作成し、領域を生成する"""
    sketch.OpenSketch()

    # YZ平面上のスケッチでは、スケッチX方向をY方向、
    # スケッチY方向をZ方向として扱う。
    sketchStartX = HelixStartY
    sketchStartY = HelixStartZ

    # 螺旋軸上の基準点
    axisPointVertex = sketch.CreateVertex(sketchStartX, sketchStartY)
    axisPointRef = geomDoc.CreateReferenceFromItem(axisPointVertex)
    # Y軸方向の螺旋軸
    axisLine = sketch.CreateLine(
        sketchStartX - helicalRadius,
        sketchStartY,
        sketchStartX + helicalRadius,
        sketchStartY
    )
    axisRef = geomDoc.CreateReferenceFromItem(axisLine)
    sketch.CreateMonoConstraint(u"horizontality", axisRef)
    sketch.CreateBiConstraint(u"coincident", axisRef, axisPointRef)
    # 螺旋軸上の開始点のY位置を方程式で拘束する
    startYConstraint = sketch.CreateMonoConstraint(
        u"distancefromyaxis",
        axisPointRef
    )
    startYDistanceExpression = getDistanceExpressionFromSignedValue(
        EqStartY,
        HelixStartY
    )
    setConstraintExpression(
        startYConstraint,
        u"Distance",
        startYDistanceExpression
    )
    # 螺旋軸のZ位置を方程式で拘束する
    startZConstraint = sketch.CreateMonoConstraint(
        u"distancefromxaxis",
        axisPointRef
    )
    startZDistanceExpression = getDistanceExpressionFromSignedValue(
        EqStartZ,
        HelixStartZ
    )
    setConstraintExpression(
        startZConstraint,
        u"Distance",
        startZDistanceExpression
    )

    # チューブ断面の中心
    tubeCenterVertex = sketch.CreateVertex(
        sketchStartX,
        sketchStartY + helicalRadius
    )
    tubeCenterRef = geomDoc.CreateReferenceFromItem(tubeCenterVertex)
    # 螺旋半径を表す補助線
    radiusLine = sketch.CreateLine(
        sketchStartX,
        sketchStartY,
        sketchStartX,
        sketchStartY + helicalRadius
    )
    radiusLineRef = geomDoc.CreateReferenceFromItem(radiusLine)
    # 補助線を回転軸に垂直にし、チューブ断面中心までの距離を方程式で拘束する
    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)
    # チューブ断面となる円
    tubeCircle = sketch.CreateCircle(
        sketchStartX,
        sketchStartY + helicalRadius,
        tubeRadius
    )
    tubeCircleRef = geomDoc.CreateReferenceFromItem(tubeCircle)
    # チューブ断面の半径を方程式で拘束する
    tubeRadiusConstraint = sketch.CreateMonoConstraint(
        u"radius",
        tubeCircleRef
    )
    setConstraintExpression(tubeRadiusConstraint, u"Radius", EqTubeRadius)

    # チューブ断面の円から閉じた領域を作成する
    createRegionFromItems(sketch, [tubeCircle])

    sketch.CloseSketch()

    return axisLine


def createHelixByRevolve(part, sketch, axisLine):
    """円領域を螺旋軸まわりに回転させ、螺旋形状を作成する"""
    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):
    """Part内に方程式付きの螺旋形状を作成する"""
    sketch = createSketchOnHelixPlane(part)
    axisLine = drawBaseShapeForHelix(sketch, HelicalRadius, TubeRadius)
    createHelixByRevolve(part, sketch, axisLine)


def main():
    """方程式付きの螺旋形状を持つPartを作成する"""
    createHelixEquations()

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


main()