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.*
import static uk.co.nickthecoder.foocad.layout.v1.Layout2d.*
import static uk.co.nickthecoder.foocad.layout.v1.Layout3d.*
import static uk.co.nickthecoder.foocad.arrange.v1.Arrange.*
import uk.co.nickthecoder.foocad.screws.v3.*
import static uk.co.nickthecoder.foocad.along.v3.Along.*
import uk.co.nickthecoder.foocad.compound.v1.*
import uk.co.nickthecoder.foocad.woodworking.v1.*
import static uk.co.nickthecoder.foocad.woodworking.v1.Woodworking.*
import uk.co.nickthecoder.foocad.smartextrusion.v1.*
import static uk.co.nickthecoder.foocad.smartextrusion.v1.SmartExtrusion.*

include BoxConstruction.foocad

class Box2 : Model {

    var size = Vector3( 438, 460, 380 )

    var lumberSize = Vector2( 21, 19 )

    meth construction() : BoxConstruction = BoxConstruction().apply {
        cornerExtra = 17
        angleExtra = 10
        thickness = 3.0
        insideRadius = 2
        crossSection = lumberSize
        screwHole = Countersink().headDiameter(7).holeDiameter(3.5).recess(0.75)
        //screwHole = Cube(0)
    }

    @Piece( about="A small piece to test if lumberSize is correct" )
    meth test() = construction().angleB(22.5)

    @Piece( about="8 required (half are mirror images)" )
    meth corner() = construction().cornerB()

    @Piece( about="8 required" )
    meth sideBracing() = construction().angleA45()

    @Piece( about="8 required (45° bracing for the bottom panel)" )
    meth baseBracing() = construction().angleB45()

    @Piece( about="4 required" )
    meth endEndBracing() = construction().angleC45()

    @Piece( about="4 required (half are mirror images)" )
    meth endBottomBracing() = construction().angleA45()

    @Piece( about="4 required" )
    meth centerConnector() = construction().apply{
        angleExtra = cornerExtra
    }.angleB(0).rotateX(90)


    @Piece
    meth spacer() = construction().spacer()

    @Piece
    meth cornerReinforcement() : Shape3d {
        val plain = construction().cornerReinforcement( 80, 1.8 )
        val diagonals = Square( 2 ).center().tileX( 15, 4.15 ).center().rotate(-45)
            .extrude(10).translate( 38, 38, 0 )
        val straight = Square( 2 ).center().tileX( 10, 4.2 )
            .translate( 7, 7 )
            .rotate(90).mirrorX().also(2)
            .extrude(10)

        return plain - (diagonals + straight)
    }

    @Piece( about="" )
    meth completeSet() = arrangeX(
        arrangeY(
            corner().translateX(1).mirrorX().also().toOrigin().tileY(4,2),
            centerConnector().toOrigin().tileX(2,2).tileY(2,2)
        ),
        sideBracing().toOrigin().tileY(8,2),
        baseBracing().rotateZ(90).toOrigin().tileY(8,2),
        arrangeY(
            endEndBracing().toOrigin().frontTo(1).mirrorY().also().tileY(2,2),
            endBottomBracing().toOrigin().tileY(4,2)
        )
    )


    @Piece( printable=false )
    override fun build() : Shape3d {
        val joints = construction()
        val wood = Wood( "main", lumberSize.x, lumberSize.y )

        val sideBracingDelta = 180
        val baseBracingDelta = 115
        val centerDelta = 100
        val endBracingDelta = 170

        val corners = joints.cornerB()
            .leftTo( -size.x / 2 - joints.thickness ).mirrorX().also()
            .frontTo( -size.y / 2 - joints.thickness ).mirrorY().also()
            .mirrorZ().topTo( size.z + joints.thickness*2 ).also(2)
            .translateZ(-joints.thickness)
            .color("Orange")

        val sideBottomBracing = joints.angleA45()
            .rotateY(-90).rotateZ(90)
            .frontTo( corners.front  + sideBracingDelta )
            .leftTo( corners.left )
            .bottomTo( corners.bottom )
            .mirrorX().also()
            .mirrorY().also()
            .color("Orange")

        val sideEndBracing = joints.angleA45()
            .rotateZ(90).mirrorZ()
            .leftTo( corners.left )
            .frontTo( corners.front )
            .bottomTo( sideBracingDelta )
            .mirrorX().also()
            .mirrorY().also()
            .color("Orange")

        val baseEndBracing = joints.angleB45()
            .rotateY(90)
            .frontTo( corners.front )
            .leftTo( corners.right - baseBracingDelta )
            .bottomTo(0)
            .mirrorX().also()
            .mirrorY().also()
            .color("Orange")
        val baseSideBracing = joints.angleB45()
            .rotateY(-90).rotateZ(90)
            .rightTo( corners.right )
            .bottomTo(0)
            .backTo( corners.front + baseBracingDelta )
            .mirrorX().also()
            .mirrorY().also()
            .color("Orange") 

        val centerConnectors = joints.angleB(0)
            .rotateY(90).rotateZ(90).centerX().bottomTo(0)
            .rightTo( corners.right )
            .centerYTo( centerDelta )
            .bottomTo(-joints.thickness)
            .mirrorX().also()
            .mirrorY().also()
            .color("Orange")
        
        val endEndBracing = joints.angleC45().mirrorZ()
            .frontTo( corners.front )
            .leftTo( corners.left )
            .translateZ( endBracingDelta )
            .mirrorX().also()
            .mirrorY().also()
            .color("Orange").darker()
        val endBottomBracing = joints.angleA45()
            .rotateY(-90)
            .frontTo( corners.front )
            .bottomTo( corners.bottom )
            .translateX( corners.left + endBracingDelta )
            .mirrorX().also()
            .mirrorY().also()
            .color("Orange").darker()

        val across = wood.cut( size.x - lumberSize.y * 2 )
            .edgeDownAlongX().centerX().frontTo( -size.y / 2 )
            .mirrorY().also()
            .topTo(size.z).also()
            .color( "LightGreen" )

        val along = wood.cut( size.y )
            .edgeDownAlongY().centerY().rightTo( size.x / 2 )
            .mirrorX().also()
            .topTo(size.z).also()
            .color("Green")

        val center = wood.cut( size.x - lumberSize.y *2 )
            .edgeDownAlongX().centerX()
            .centerYTo( centerDelta ).mirrorY().also()
            .color("LightGreen")

        val upright = wood.cut( size.z - lumberSize.x*2 )
            .rotateZ(90)
            .bottomTo( lumberSize.x )
            .leftTo( -size.x /2 )
            .frontTo( - size.y / 2 )
            .mirrorX().also()
            .mirrorY().also()
            .color( "LightBlue" )

        return Compound().apply {
            + corners

            + across
            + along
            + center
            + upright

            + sideBottomBracing
            + sideEndBracing

            + centerConnectors

            //+ baseEndBracing
            //+ baseSideBracing

            + endEndBracing
            + endBottomBracing

        }.build()
    }
}