import uk.co.nickthecoder.foocad.threaded.v2.*
import static uk.co.nickthecoder.foocad.layout.v1.Layout2d.*
import static uk.co.nickthecoder.foocad.layout.v1.Layout3d.*
import uk.co.nickthecoder.foocad.smartextrusion.v1.*
import static uk.co.nickthecoder.foocad.smartextrusion.v1.SmartExtrusion.*

class Bug : Model {

    var bump = 0.9

    var clearance = 0.3
    
    var scale = 2.0

    var threadSize = 10

    meth thread() = Thread( threadSize )

    @Piece
    meth foot() : Shape3d {
        val bigToe = Sphere(4).translate(8,2.0,0)
        val littleToe = Sphere(3.8).translate(6.9,-0.8,0)
        val heal = Sphere(7)

        val hull = bigToe.hull(littleToe).hull(heal)
        val onlyTop = hull.boundingCube().bottomTo(0)

        val solid = hull.translateZ(1).intersection(onlyTop)
            .scale( scale )

        val hole = lockingHole( solid.top - 1 )
            .rotateX(90).rotateZ(-90)
            .centerZ()
            .topTo( solid.top + 1 )
        
        return solid - hole
    }

    @Piece
    meth footLeft() = foot().mirrorY()

    meth zOffset() = 7
    meth segmentShape() = Circle(10).translateX(zOffset()).intersection( Square( 30 ).centerY() )

    meth centerHeight() = zOffset() * scale

    @Piece
    meth segment1() : Shape3d {
        val shape = segmentShape()

        val unscaledSolid = shape.smartExtrude(10)
                .edges( Fillet(2) )
            .rotateY(-90)
            .centerX()

        val solid = unscaledSolid
            .scale( scale )

        val indentHalf = Sphere(9)
            .leftTo(unscaledSolid.right-2)
        val indent = indentHalf.hull( indentHalf.translateZ(-10) )
            .scale( scale )
            .translateZ(centerHeight()).mirrorX().also()

        val legHolePath = PolygonBuilder().apply {
            moveTo( 0, solid.front - 2 )
            lineBy( 0.75, 2 )
            bezierBy(
                Vector2( 5, solid.size.y/4 ),
                Vector2( -5, solid.size.y/4 ),
                Vector2( 0, solid.size.y )
            )
            lineBy( -0.75, 2 )
        }.buildPath()
        val legHoles = holeShape().extrude( legHolePath )
            .rotateY(-90)
            .bottomTo( centerHeight() - 1 )

        val spineHole = holeShape().smartExtrude( solid.size.x )
            .rotateY(90)
            .centerX()
            .translateZ( centerHeight() )

        return solid - indent - legHoles - spineHole
    }

    meth lump() : Shape3d {
        val a = Sphere(9-clearance)
            .scale( scale )
            .translateZ(centerHeight())
            .intersection( Cube( 30*scale ).centerXY() )
        val b = Circle( a.size.x / 2 )
            .smartExtrude(centerHeight())
            .bottom( roundedChamfer(3.5*scale) )
        return a + b
    }

    @Piece
    meth segment2() : Shape3d {
        val shape = segmentShape()

        val solid = shape.smartExtrude(10)
                .edges( Fillet(2) )
            .rotateY(-90)
            .centerX()
            .scale( scale )

        val lump = lump()

        val openingSize = 4 * scale
        val spineOpening = holeShape().smartExtrude( openingSize + 0.1 )
                .top( Chamfer(-openingSize, openingSize) )
            .rotateY(90)
            .translateZ( centerHeight() )
            .rightTo( lump.right )
    
        val spineOpenings = spineOpening.mirrorX().also()
        
        val spineHole = holeShape().extrude( lump.size.x )
            .rotateY(90).centerX()
            .translateZ( centerHeight() )            

        val lockHole = thread().threadedHole( centerHeight() + spineHole.size.z/2 + 0.1 )
            .topTo( spineHole.top )

        return solid + lump - spineOpenings - spineHole - lockHole
    }


    @Piece
    meth head() : Shape3d {
        val neck = Sphere(9-clearance)
            .scale( scale )
            .translateZ(centerHeight())
            .intersection( Cube( 30*scale ).centerXY() )

        val head = Sphere( 11 )
            .translateZ( 3 )
        val eye = Sphere( 3 ) - Sphere( 1.4 ).translate( 2.1, 0.5, 1 )
        val eyes = eye.translate(7.5,5,7).mirrorY().also()

        val spineHole = holeShape().extrude( neck.size.x )
            .rotateY(90).centerX()
            .translateZ( centerHeight() )            

        val openingSize = 4 * scale
        val spineOpening = holeShape().smartExtrude( openingSize + 0.1 )
                .top( Chamfer(-openingSize, openingSize) )
            .rotateY(-90)
            .translateZ( centerHeight() )
            .leftTo( neck.left )

        val slice = Cube( 200 ).centerXY()

        val addition = (head + eyes).translateX(4)
            .scale( scale )
            .translateZ( centerHeight() )
            .intersection(slice)

        val lockHole = thread().threadedHole( centerHeight() + spineHole.size.z/2 + 0.1 )
            .topTo( spineHole.top )

        val antenaHoles = lockingHole(addition.top - centerHeight() + 1).rotateX(90)
            .bottomTo(centerHeight())
            .rotateX(20)
            .rotateY(10)
            .translate( 3 * scale, 3*scale, 0 )
            .mirrorY().also()

        return neck + addition - spineOpening - lockHole - spineHole - antenaHoles
    }
    
    @Piece
    meth antena() : Shape3d {
        val ball = Sphere(4)
            .translateZ(3)
            .scale(scale)

        val slice = Cube( 100 ).centerXY()

        val hole = lockingHole( ball.top - 2 )
            .rotateX(90)
            .bottomTo(-0.1)

        return ball.intersection(slice) - hole - hole
    }

    @Piece
    meth tail() : Shape3d {
        val segment = segment2()
        val tailA = Circle( segment.size.y * 0.75 / 2 )
            .extrude( 1 )
            .rotateY(90)
            .translateX( -segment.size.x * 0.2 )
        val tailB = Sphere( segment.size.y * 0.2 )
            .translate( -segment.size.y * 0.7, 0, -2 )

        val tail = tailA.hull(tailB)
            .centerZTo( centerHeight() )
            .intersection( Cube( 200 ).centerXY() )

        return segment + tail
    }

    @Piece
    meth lock() : Shape3d {
        val rod = thread().threadedRod( centerHeight() - 1 )
            .chamferBottom(false)
        val slot = Cube(20, 1, 1.5).centerXY()

        return (rod - slot).rotateY(90).bottomTo(-threadSize*0.2).intersection(Cube(40).centerXY())
    }

    meth lockingHole( length : double ) =
            holeShape()
            .extrude( wigglePath( length, bump ) )
            .color("Red")

    meth holeShape() = Circle((1.75 + 0.7)/2).hole()
    // The path a hole makes. This is the "clever" part of the system which
    // ensures that the filament is held firmly in the holes despite the fact that
    // the diameter of the holes is LARGER than the filament.
    // The holes wiggle, which forces the filament to wiggle, and therefore
    // it presses outwards (due to the springy nature of the filament).
    meth wigglePath( length : double, bump : double ) : Path2d {
        val pre = 1
        val halfLength = length/2 - pre

        return PolygonBuilder().apply {
            moveTo( 0, -length/2 )
            lineBy( 0, pre )
            bezierBy(
                Vector2( 0, halfLength/2 ),
                Vector2( 0, halfLength/2 ),
                Vector2( bump, halfLength )
            )
            bezierBy(
                Vector2( 0, halfLength/2 ),
                Vector2( 0, halfLength/2 ),
                Vector2( -bump, halfLength )
            )
            lineBy( 0, pre )
        }.buildPath()
    }


    @Piece( printable=false )
    override fun build() : Shape3d {
        val feet = foot().translate(0,-17*scale,0).mirrorY().also()
        val segment1 = segment1().translateZ(10*scale)
        val segment2 = segment2().translate(12*scale, 0, 10*scale).color("Orange")
        val part = feet + segment1 + segment2

        val tail = tail().translate(-12*scale, 0, 10*scale).color("Orange" )

        val extraLegs = (feet + segment1).translateX(12*scale*8)
        val head = head().translate(12*scale*9, 0, 10*scale).color("Orange")

        val antena = antena()
            .leftTo( head.right )
            .bottomTo( head.top + 20 )
            .frontTo( -20 )
            .mirrorY().also()

        return part.repeatX(4, 24*scale) + tail + extraLegs + head + antena
    }

}