/Tools/CornerBracket.foocad

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

class CornerBracket : Model {
    

    @Custom( about = "length, width, thickness" )
    var size = Vector3( 30, 10, 2 )

    @Custom
    var holeD = 4.0

    @Custom
    var holeCountA = 2

    @Custom( about="This is usually 1 less than holeCountA" )
    var holeCountB = 1
    
    @Custom
    var coverThickness = 0.6

    @Custom
    var slack = 0.1

    fun foo( holeD : double ) : Shape3d {

        val tri = Triangle( size.y + size.z, size.y + size.z )
        val extrude = tri.extrude( size.x )
            .rotateY(-90)
            .rotateZ(180)
            .backTo( size.z )
            .centerX()

        val hole = Cylinder( 100, holeD /2 ).sides(6).center()
        val spaceX = size.x - size.z
        val result = extrude -
            Cube( size.x - size.z * 2, size.y, size.y )
                .centerX().backTo(0).bottomTo( size.z ) -
            hole.repeatX( holeCountA, spaceX / holeCountA )
                .centerX().translateY( -size.y / 2 + size.z / 2 ) -
            hole.repeatX( holeCountB, spaceX / holeCountB ) 
                .rotateX(90)
                .centerX().translateZ( size.y / 2 + size.z / 2 )
                
                
        return result
    }

    @Piece
    fun bracket() = foo( holeD )

    @Piece
    fun jig() = foo( 1.5 )

    @Piece
    fun cover() : Shape3d {
        val width = size.y + size.z
        val baseWidth = Math.sqrt( 2*width*width )
        val base = Cube( size.x, baseWidth, coverThickness ).centerXY()
        val triWidth = size.y - size.z
        val tri = Triangle( triWidth, triWidth ).roundCorner(0,triWidth/2)
        val wings = tri.extrude( size.z )
            .rotateY(-90).rotateX(180+45)
            .translateZ( Math.sqrt( triWidth*triWidth*2 )/2 )
            .translateX( size.x/2 - size.z - slack )
            .mirrorX().also()

        return base + wings.color("Green")
    }

    override fun build() : Shape3d {
        val width = size.y + size.z
        val diag = Math.sqrt( width * width * 2 )

        /*
        return if ( piece == "bracket" ) {
            bracket().rotateX(45+90)
        } else if ( piece == "cover" ) {
            cover()
        } else if ( piece == "jig" ) {
            jig()
        } else if ( piece == "both" ) {
            bracket() +
            cover().translateY(-size.y*2)
        } else {
        */
        val bracket = bracket().frontTo(0).color( "Orange" )
            
        return bracket +
            cover().backTo(0).translateZ( -coverThickness )
                .rotateX( -180 + 45 )
                .color("Green")

                
    }
}