import static uk.co.nickthecoder.foocad.layout.v1.Layout2d.*
import static uk.co.nickthecoder.foocad.layout.v1.Layout3d.*
import static uk.co.nickthecoder.foocad.extend.v1.Extend.*
import uk.co.nickthecoder.foocad.extras.v1.*
import static uk.co.nickthecoder.foocad.extras.v1.Extras.*
import uk.co.nickthecoder.foocad.smartextrusion.v1.*
import static uk.co.nickthecoder.foocad.smartextrusion.v1.SmartExtrusion.*
import uk.co.nickthecoder.foocad.threaded.v2.*
import static uk.co.nickthecoder.foocad.along.v3.Along.*
import uk.co.nickthecoder.foocad.woodworking.v1.*
import static uk.co.nickthecoder.foocad.woodworking.v1.Woodworking.*

class ColdFrameFlatPack : Model {

    //val wood = Wood("main", 63/2-3, 38/2-3  ) // Quarter of a common CLS timber
    val wood = Wood("main", 38, 62/2-3 ) // 38x29 Half of a common CLS timber

    // My sheets are 1150 x 610
    // The size of the box is
    @Custom
    var size = Vector3( 1150 + 20, (1150 /2) + 20 + wood.thickness*2, 610 + 20 )

    @Custom
    var cornerLength = 130


    @Custom
    var thread = Thread( 7 )

    @Custom
    var insertDiameter = 9.8

    @Custom
    var insertLength = 20

    @Custom
    var cornerSize = Vector3( 80, 20, 20 )


    meth panel( name : String, x : double, z : double ) : Shape3d {
        val bottom = wood.cut( x )
            .label( "$name-topBottom" )
            .edgeDownAlongX()
            .centerX()

        val topBottom = bottom
            .topTo( z ).also()

        val left =  wood.cut( z - wood.width*2 )
            .label( "$name-side" )
            .leftTo( topBottom.left )
            .bottomTo( wood.width )
            .darker()

        val sides = left
            .mirrorX().also()

        val corners = wood.cut( cornerLength )
            .mitre( OPPOSITE_SIDE ).bothEnds()
            .rotateY(-45)
            .translateX( -left.right - 2)
            .translateZ( z - wood.width - cornerLength / Math.sqrt(2) - 2)
            .mirrorX().also()
            .mirrorZ().translateZ( z ).also(2)

        return topBottom + sides + corners
    }

    @Piece
    meth corners() = corner().leftTo(1).frontTo(1).mirrorX().also().mirrorY().also()

    @Piece
    meth corner() : Shape3d {

        val shape = (
            Square( cornerSize.x, cornerSize.y ) +
            Square( cornerSize.y, cornerSize.x )
        )
        val solid = shape.smartExtrude( cornerSize.z )
            .edges( Chamfer(1) ) 

        val corner = (
            Triangle( cornerSize.y*3.2, cornerSize.y*3.2 ) -
            Circle( 5 )
                .translate(cornerSize.y*1.3, cornerSize.y*1.3 )
        ).smartExtrude( cornerSize.z /2 )
                .edges(Chamfer(1))

        val slots = Hull2d(
                Circle( thread.diameter/2 + 1 )
                    .sides(8).rotate(22.5)
                    .translateX(10).also()
                )
            .smartExtrude( cornerSize.y )
                .edges(Chamfer(1).reverse())
            .rotateX(-90)
            .centerZTo( cornerSize.z/2 )
            .rightTo( cornerSize.x - cornerSize.z/2 )
            .rotateZ(90).mirrorX().also(2)

        return solid + corner - slots 
    }

    var lidAdjustmentSize = Vector3( 200, 10, 8 )

    @Piece
    meth lidAdjustment() : Shape3d {
        val size = lidAdjustmentSize

        val notch = Hull2d(
            Circle( thread.diameter/2 + 1 )
                .translate( thread.diameter*1.5, thread.diameter*1.8 ).also()
        )
        val notches = notch.tileXWithin( size.x, 5 )

        val along = Hull2d(
            Circle( thread.diameter/2 + 1 )
                .translateX( notches.size.x - thread.diameter * 3 ).also()
        ).translate(thread.diameter*1.5, thread.diameter*1.8 )

        val end = Circle( thread.diameter/2 + 1 )
            .rightTo(-thread.diameter*3)

        val inside = (notches + along + end)
            .leftTo( size.y/2 )
        val outside = inside.offset( size.y )
        val shape = outside - inside    

        return shape.smartExtrude(size.z)
            .edges(Chamfer(1))
            
    }

    @Piece
    meth threadedInsert() = threadedInsert( insertLength, 0 )
    meth threadedInsert( length : double, barbHeight : double ) : Shape3d {
        val barbSize = 1.2

        val solid = Circle( insertDiameter/2 )
            .smartExtrude( length )
            .top( Chamfer(0.5) )

        val hole = thread.threadedHole( solid.size.z )

        val ribs = Triangle( barbSize*2, insertLength/2 )
            .extrude(barbSize)
            .rotateX(90)
            .centerY()
            .leftTo( insertDiameter/2 -barbSize )
            .bottomTo( barbHeight )
            .repeatAroundZ(4)

        return (solid+ribs) remove hole
    }

    @Piece
    meth threadedInsertWithOffset() : Shape3d {
        val extraZ = 4.2
        val plain = threadedInsert(insertLength + extraZ, extraZ )
        val offset = Square( plain.size.y + 2 ).scaleY(2)
            .roundAllCorners(2)
            .center()
            .smartExtrude( extraZ )
            .bottom( Chamfer(1) )

        return plain and offset
    }

    @Piece
    meth cornerBolt() : Shape3d {
        return thread
            .bolt( insertLength-1 + cornerSize.y )
            .bareLength( cornerSize.y )
    }

    @Piece
    meth lidAdjustmentBolt() : Shape3d {
        return thread
            .headSize( 20, 5 )
            .bolt( insertLength-1 + lidAdjustmentSize.z )
            .bareLength( lidAdjustmentSize.z )
    }

    override fun build() : Shape3d {
        val corners = corner()
            .leftTo( -size.x/2 + wood.thickness )
            .frontTo( -size.y/2 + wood.thickness )
            .centerZTo( wood.width/2 )
            .centerZTo( size.z - wood.width/2 ).also()

        val frontBack = panel( "front", size.x, size.z )
            .frontTo( -size.y/2 )
            .mirrorY().also()
            .color("lightGreen")

        val sides = panel( "side", size.y - wood.thickness*2, size.z )
            .rotateZ(90)
            .leftTo( frontBack.left )
            .mirrorX().also()
            .color("lightGreen").darker()

        val lid = panel( "lid", size.y, size.x )
            .rotateZ(90)
            .rotateY(90)
            .centerX()
            .bottomTo( size.z )

        val lidAdjustment = lidAdjustment()
            .rotateY(90)
            .leftTo( lid.right + 4 )
            .topTo( lid.top - 0 )
            .backTo( lid.back - 20 )

        val backSheet = Cube( 1150, 4, 610 )
            .frontTo( frontBack.back )
            .centerX()
            .centerZTo( frontBack.middle.z )
            .previewOnly()

        val sideSheet = Cube( 4, 1150/2, 610 )
            .leftTo( sides.right )
            .centerY()
            .centerZTo( frontBack.middle.z )
            .previewOnly()

        val topSheet = Cube( 1150, 610, 4 )
            .centerXY()
            .bottomTo( lid.top )
            .previewOnly()

        return frontBack + sides + corners + lid + lidAdjustment + backSheet + sideSheet + topSheet
    }

}