/Printer/DragChain.foocad

import static uk.co.nickthecoder.foocad.layout.v1.Layout2d.*
import static uk.co.nickthecoder.foocad.layout.v1.Layout3d.*
import uk.co.nickthecoder.foocad.extras.v1.*
import static uk.co.nickthecoder.foocad.extras.v1.Extras.*

class DragChain : Model {

    var segments = 3

    var size = Vector3( 5,5,5 )
    var gap = 1.0

    var wallThickness = 0.8
    var baseThickness = 0.8
    var flexThickness = 0.4

    var joinSize = Vector2( 0.6, 0.6 )

    var delta = 1

    meth segment() : Shape3d {

        val trap = Trapezium( size.y, size.z )
            .deltaX( delta )
            .rotate(90)
            
        val base = Square( size.x + wallThickness * 2, size.y + delta * 2 )
            .center()
            .extrude( baseThickness )

        val sides = trap.extrude( wallThickness )
            .rotateY(-90)
            .leftTo( size.x/2 )
            .mirrorX().also()
            .centerXY()
            .bottomTo(base.top)

        val top = Square( size.x + wallThickness *2, size.y )
            .extrude( baseThickness )
            .centerXY()
            .bottomTo( sides.top )

        return base + sides + top
    }

    override meth build() : Shape3d {
        val one = segment()
        val many = one.tileY( segments, gap )
            .centerXY()

        val floor = Square( many.size.x, many.size.y )
            .center()
            .extrude( flexThickness )

        return many + floor
    }

}
    /*
    var segments = 3

    var size = Vector3( 5,5,5 )

    var thickness = 0.8
    var baseThickness = 2.0

    var joinSize = Vector2( 0.6, 0.6 )

    var angle = 30.0

    var round = 0.5

    meth internalShape() : Shape2d {
        val x = size.x/2
        val y = size.y/2
        val x2 = x * Math.sin( angle * Math.PI / 180 )

        return PolygonBuilder().apply {
            moveTo( x, 0 )
            lineTo( x2, y )
            lineTo( -x2, y )
            lineTo( -x, 0 )
            lineTo( -x2, -y )
            lineTo( x2, -y )
        }.build()
            //.roundCorners( listOf<int>( 5, 4, 2, 1 ), round )
    
    }

    meth segment() : Shape3d {
        val internal = internalShape()
        val external = internal.offset( thickness )
        val removeBase = external.offset( -thickness )

        val base = external.extrude(0.4)

        val solid = (external - removeBase)
            .extrude( baseThickness*2 + size.z )
        val hole = Square( solid.size.x * 2, size.y )
            .center()
            .smartExtrude( size.z )
                .top( Chamfer( size.z/2 - 0.1, size.z/3 ) )
            .bottomTo( baseThickness )

        val join = Cube( joinSize.x, joinSize.y, baseThickness )
            .topTo( solid.top ).also()
            .centerY()
            .centerXTo( solid.right )

        return solid + base - hole + join
    }

    meth chain( segments : int ) : Shape3d {
        return segment().tileX( segments )
            .centerX()
    }

    @Piece
    meth chain() = chain( segments )

    override fun build() : Shape3d {
        return chain( segments )
    }
    */