/Bike/FoldingBox.foocad

import uk.co.nickthecoder.foocad.smartextrusion.v1.*
import static uk.co.nickthecoder.foocad.smartextrusion.v1.SmartExtrusion.*
import uk.co.nickthecoder.foocad.extras.v1.*
import static uk.co.nickthecoder.foocad.extras.v1.Extras.*

class FoldingBox : Model {

    var size = Vector3( 300, 350, 250 )
    var tubeDiameter = 20
    var cornerSize = 50
    var cornerThickness = 2
    var clearance = 0.3

    meth corner() : Shape3d {
        val thickness = tubeDiameter + cornerThickness * 2
        val shape = Circle( thickness / 2 ) +
            Square( cornerSize - thickness, thickness ).centerY() +
            Square( thickness, cornerSize - thickness ).centerX()
        val solid = shape.smartExtrude( thickness )
            .bottom( Chamfer( 2 ) )
            .top( Fillet( thickness/2-2 ) )
        val holes = Circle( tubeDiameter/2 + clearance )
            .extrude( 100 )
            .rotateY(90)
            .translateZ( thickness/2 )
            .rotateZ(90).also()
            
        return (solid - holes).color("Orange")
    }

    meth side() : Shape3d {
        val sideLength = size.y - 50

        val leftRight = Circle( tubeDiameter/2 ).extrude( size.z )
            .translateY( -sideLength/2 ).mirrorY().also()

        val top = Circle( tubeDiameter/2 ).extrude( sideLength )
            .rotateX(90)
            .centerY()
            .translateZ( size.z )

        val corners = corner().opacity(0.75)
            .rotateY(90).centerX()
            .translateY( -sideLength/2 )
            .translateZ( size.z )
            .mirrorY().also()

        val pieces = leftRight + top + corners

        return pieces.translateX( size.x/2 )
    }

    meth end() : Shape3d {

        val leftRight = Circle( tubeDiameter/2 ).extrude( size.z )
            .translateX( -size.x/2 ).mirrorX().also()

        val topBottom = Circle( tubeDiameter/2 ).extrude( size.x )
            .rotateY(90)
            .centerX()
            .translateZ( size.z ).also()

        val corners = corner().opacity(0.75)
            .rotateZ(180)
            .rotateX(-90).centerY()
            .translateX( size.x/2 )
            .mirrorX().also()
            .mirrorZ().translateZ( size.z ).also(2)

        val pieces = leftRight + topBottom + corners

        return pieces.translateY( size.y/2 )
    }

    @Piece
    meth material() : Shape3d {
        val hem = 25
        val width = size.x + tubeDiameter
        val depth = size.y + tubeDiameter
        val height = size.z + tubeDiameter/2

        val end = Square( width, height ).extrude(1).color( "orange" ).centerX()
        val sides = Square( depth, height ).extrude(1).leftTo(end.right).mirrorX().also().color( "yellow" )
        val otherEnd = end.scaleX( 0.5 ).leftTo( sides.right ).mirrorX().also()
        val overlap = Square( hem, height ).extrude(1).color( "green" ).leftTo(otherEnd.right).mirrorX().also()

        val main = end + sides + otherEnd + overlap
        val forBase = Square( main.size.x, hem ).extrude(1).color("green").centerX().backTo(0)
        val wrap =  Square( main.size.x, hem + tubeDiameter*2 ).extrude(1).color("green").centerX().frontTo(main.back)

        val forTubes = Square( tubeDiameter*2 + hem *2, height - tubeDiameter ).extrude(1).color( "violet" )
            .centerXTo( width/2 )
            .translateX( depth ).also()
            .mirrorX().also()
            .translateZ(20)

        val cornerCutouts = Square( tubeDiameter* 2 + 20, 100 )
            .roundAllCorners(5)
            .centerX().frontTo( height - tubeDiameter)
            .extrude(3).centerZ()
            .translateX( width/2 )
            .translateX( depth ).also().mirrorX().also()
            .color("Red")

        return main + forBase + wrap - cornerCutouts + forTubes
    }

    override fun build() : Shape3d {
        val outline = Cube(size).centerXY().previewOnly()
        val sides = side().mirrorX().also()
        val ends = end().mirrorY().also()
        return ends + outline
    }

}