/*
A torch with a wide COD LED strip which can lay flat on flat surface
The light can be directed up/down by simply twisting the body.

Powered by a 18650 battery, through a boost circuit to raise to 12V needed
for the LED cob. Includes a USB battery charge port at the other end to the
on/off switch.

The feet can be taken on/off if required.

The feet include impressions for magnets to glued into.

The battery is held in place using a friction fit using tape to pad
it out slightly. MI used masking tape because it has high friction.
Ensure that you cover the terminals well. It could slide about!
I also taped the end of the charger module to be extra safe, and the
boost module is 100% protected by the "boostHolder" pieces.

Build parts
-----------

Build in several parts. Use the custom "piece" field :
    foot (x2)
    tube
    chargerEnd
    switchEnd
    boost (x2) (to secure the boost circuit within the tube) Required M3 bolts

Bought parts
------------

A 18650 battery. I use 2nd hand ones from old laptops. Usually only one or
two cells have died when the battery as a whole is dead. I don't tend to
use torches for long periods, so a high capacity battery is a waste!

Search ebay (or other shop) for :
    usb battery charge module
    dc boost module mounting holes (3.x V to 12V no usb socket

FYI, The boost modules with mouting holes are becoming rarer.
If you can't find any, the "boost" piece won't be of use.

Requirements
------------

    At least 17cm build height!

Possible Improvements
---------------------

    Add posts to the "buttonEnd", so that it can never rotate (twisting the wires)
    
    Cut away the tube to allow space for the wires from the LED cob strip.

*/

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

class CobTwist : Model {
  

    // Size of the LED module
    @Custom
    var length = 173
    val width = 15.5
    var thickness = 2.7

    val buttonD = 13 // Old one was 16.5

    val endT=8
    val endBase=2
    val endChamfer=1
    val endExtra = 3
    val endSkin=0.8

    // Thickness of the tube walls. On a small extrusion this seems a little 
    // flimsy, but the final result feels very rigid to me.
    val tubeT = 0.6
    val radius=13 // external radius of the tube

    // The boost module is 22 mm, so we need an internal radius of at least 11 mm
    fun internalRadius() = radius - tubeT

    val footT = 5 // Diff between internal and external radius of the foot.
    val magnetD = 11 // Diameter of the magnets on the feet (include some slack?)
    val magnetT = 1.0 // Thickness of the magnets (include some slack?)

    // For an interference fit between the tube and the ends.
    // I recommend gluing the ends on. You don't want anybody
    // shorting out the battery (lithium batteries are dangerous!)
    val slack = 0.3

    // I didn't include any slack at first. (I ussumed that the split nature
    // of the foot would suffice. However, the feet tend to turn the ends,
    // so a higher value may be better (0.4 maybe??? Testing for the first time...)
    val footSlack = 0.4

    //@Custom
    var text = ""
  
    @Piece
    fun others() : Shape3d {
        return (
            buttonEnd() +
            chargerEnd().translateX(30) +
            boostHolder().translateY(-3).rotateZ(180).also().translateX(60) +
            foot().tileX(2,5).translateY(-35)
            ).center()
    }
    

    // ==== FUNCTIONS BEGIN ====
    override fun build() : Shape3d {
    
        return buttonEnd() +
            chargerEnd().rotateX(180).translateZ(length+30) +
            tube().translateZ( endBase ) +
            led().translate( 0,10,endBase ) +
            battery().translateZ(30).translateY(-2) +
            foot() +
            foot().mirrorZ().translateZ(length)
      
    }

    // For debugging only.
    fun battery() = Cylinder( 65, 9 ).color("GhostWhite")

    // Used by the "chargerEnd" and "buttonEnd" pieces.
    // Goes on both ends of the tube. Each end is modified in different ways.
    fun end() : Shape3d {
        val outside = Circle( radius + slack + endSkin )
        val inside = Circle( radius + slack )
       
        return ExtrusionBuilder().apply {
            crossSection(Circle( radius + slack - endChamfer))
            forward(endChamfer)
            crossSection(outside)
            forward(endT-endChamfer)
            crossSection(outside)
            crossSection(inside)
            forward(-endT + endBase )
            crossSection(inside)
        }.build().color( "LightGreen" )
    }

    // The "chargerEnd" piece. Includes a hole and mounting post
    // for a usb charger module. Ensure you get one with no component on
    // one side, as you will be gluing it to a plastic post.
    @Piece
    fun chargerEnd() : Shape3d {
        val hole = Cube( 8.5, 3.5, endT*3 ).center()
        val floor = Cube( 18, 6, 10 ).centerXY().translateZ(0.9)
        val entry = Cube( 11, 5, 0.5).centerXY().translateZ(-0.1)

        // If you glue the charger module to the post with epoxy,
        // then these holes will give extra support.
        // If using super-glue, then don't include these holes, as they
        // will only reduce the surface area, and give no mechanical advantage.
        val holes = Cube(2,10,2)
            .tileX(2,5)
            .tileZ(2,5)
            .centerXY()
            .translateZ(3)

        val post = Cube( 20, 0.6, 13 ).centerX().translateY(-3.5) +
            Cube( 0.6, 5, 13 ).translateY(-8) -
            holes


        val indentText = Text( text, BOLD, 7 )
            .center()
            .mirrorX()
            .translateY(6.5)
            .extrude(0.6).translateZ( -0.01 )
            .color("Orange")

        return end() - hole - floor - entry - indentText + post 
    }

    // The "buttonEnd" piece. Includes a hole for a button.
    // Note, my button's retaining ring fouled again the cob LED strip,
    // so I glued it in place.
    // Consider using a smaller diameter button!
    // NOTE. I should have added post(s) to prevent the end from rotating.
    // (to prevent wires getting twisted). I'll have to glue mine in place.
    fun buttonEnd() : Shape3d {
        val post = Cube(0.6, 8, 8).centerXY().translateX(10)
        return end() -
            Cylinder( 30, buttonD / 2).center() +
            post.mirrorX().also()
    }
        

    // Used for debugging only. Shows the size of the boost module, as well
    // as the mounting holes.
    fun boostModule() : Shape3d {
        val board = Cube( 43.5, 21.5, 1.5 ).color("Green")
        val components = Cube(43.5, 21.5, 10).translateZ(1.5).color("WhiteSmoke")

        val holes = Cylinder.hole( 20, 1.5 ).translate(15,-7.5,-1)
            .translate(-30,15,-1).also()
        return (board + components).centerXY() - holes
    }

    @Piece
    fun boosts() = boostHolder().translateY(-3).rotateZ(180).also()

    // The "boost" piece. Print two of them to secure and protect the boost
    // module. Requires two short M3 bolts (no nuts).
    @Piece
    fun boostHolder() : Shape3d {

        val thick = 0.6
        val height = 9
        val r = internalRadius() - slack 

        val oversize = Cube( r * 3, r * 3, height ).centerXY()
        val snug = Circle( r ) - Square( radius * 2 ).centerX().translateY(2)
        val inside = Circle( r-1 )

        val block = Cube( 6,4,10 ).translate(-10,-2,0)
        val hole = Cylinder.hole(30,1.5).center().rotateZ(-90).rotateX(90).translate(-7.5,0,7.5)

        // val debug = boostModule().rotateZ(90).rotateX(90).translate(0,4,21.75+thick)

        // We make a "fake" chamfer at the bottom to prevent squishage of the
        // first layer making it too big to fit in the tube.
        val solid = (oversize - inside.extrude(height).translateZ(thick)) /
            (snug.extrude(height).translateZ(0.4) + snug.offset(-0.4).extrude(height))

        return block - hole + solid 
    }

    // The "tube" piece.
    // I had no trouble printing it, despite being tall and narrow, it didn't
    // get knocked over during the print (and I did not use a brim).
    // Consider printing a small version (using @Custum length), and
    // check that your LED strip fit within.
    @Piece
    fun tube() : Shape3d {
        val up = 7.5
        val boardT = 2
        val apeture = 11
        
        val profile = (
            Square( radius*2+1 ).center() -    // Overly large square
            Circle( radius - tubeT ) +         // Internal circle
            Square( radius*2, 20 ).centerX().translateY( up-tubeT ) - // Fill in the top
            Square( width, boardT ).centerX().translateY( up ) - // Slot for LED
            Square( apeture, 10 ).centerX().translateY( up ) // Apeture for light
        ) / Circle( radius ).convexity(3)

        val removeForSolder = Cube( width, 10, 5 ).centerX()
            .hull( Cube( 2, 10, 6 ).centerX().translateZ(8) )
            .translateY(up)
            
        val removeForSolders = removeForSolder + removeForSolder.mirrorZ().translateZ(length)

        val removeForButton = Cylinder(21,10).translateZ(length-20)
        return profile.extrude( length ) - removeForSolders - removeForButton
    }

    // The "foot" piece. Print two identical copies.
    // These have a split design, so that they can be taken on/off easily
    // after the body of the torch is built.
    // I say "easily" - it takes a bit of brute force and coordination,
    // but there's no unsoldering involved (unlike the first design!)
    @Piece
    fun foot() : Shape3d {
        val internalR  = radius + slack + endSkin + footSlack
        val externalR = internalR + footT

        val extra = 8
        val foo = 47 // The width at floor level
        val thickness = 9 // Thickness at the top
        val thickness2 = 17 // Thickness at the bottom (Badly named!)

        val base = Square( foo, 10 ).roundAllCorners(3).centerX().translateY(-internalR-extra)
        val shape = (Circle( externalR ).hull(base)) // - Circle( internalR )

        val profile = PolygonBuilder().apply {
            moveTo(-externalR,0)
            lineTo(externalR+extra,0)
            lineTo(externalR+extra,thickness2)
            bezierTo(
                Vector2(externalR+extra-20,thickness2),
                Vector2(10,thickness),
                Vector2(0,thickness)
            )
            lineTo(-externalR,thickness)
        }.build()

        val center = ExtrusionBuilder().apply {
            forward(-0.1)
            crossSection( Circle( internalR - 1 ) )
            forward(1)
            crossSection( Circle( internalR ) )
            forward( thickness-2 )
            crossSection( Circle( internalR ) )
            forward(1)
            crossSection( Circle( internalR - 1 ) )
            forward(30)
            crossSection( Circle( internalR - 1 ) )
        }.build().color("Red")

        val inter = profile.extrude( foo ).centerZ().rotateX(90).rotateZ(-90)

        val split = (
                Square(1,extra+2).centerX() +
                Square(8).center().rotate(45).translateY(extra+3.5)
            )
            .extrude( thickness2+2 )
            .centerX()
            .translate(0,-internalR-extra-1,-1)

        val magnetHoles = Cylinder.hole( magnetT+0.1, magnetD/2 )
            .rotateX(90)
            .translateZ(thickness2/2)
            .translateY(-internalR-extra+magnetT)
            .translateX(10).mirrorX().also()

        return shape.extrude( thickness2 ).color( "Violet" ) / inter -
            center - 
            magnetHoles -
            split 
    }

    fun led() = Cube( width,thickness,length )
        .centerX().mirrorY()
        .color("WhiteSmoke")

    fun line( fromX:  double, fromY : double, toX : double, toY : double ) =
        line( Vector2(fromX, fromY), Vector2(toX, toY) )

    fun line( from : Vector2, to : Vector2 ) : Shape2d {
        val across = (to-from).normal().unit()*2
        return PolygonBuilder().apply {
            moveTo(from)
            lineTo(from+across)
            lineTo(to+across)
            lineTo(to)
        }.build()
    }

    fun box( name : String ) : Shape2d{
        return Square( 60, 40 ).center().color("DarkGreen") +
            Text( name ).center().color("MintCream")
    }

    // A simple circuit diagram
    fun circuit() : Shape2d {
        val switch = box("Switch").translateX(-270)
        val led = box("LED").translateX(-180)
        val boost = box("Boost").translateX(-90)
        val battery = box("Battery")
        val charger = box("Charger").translateX(90)


        val plusToSwitch = line( -30,0, -60, -30 ) +
            line( -60,-30, -210,-30 ) +
            line( -210, -30, -240, -5 )

        val switchToCharger = line( -240,5, -210, 30 ) +
            line( -210,30, 30,30 ) +
            line( 30,30, 60,5 )

        val chargerToBoost = line( 60, 20, 25,50 ) +
            line( 25, 50, -25, 50 ) +
            line( -25, 50, -60, 5 )

        val boostToLED = line( -120, 10, -150, 10 )

        val batteryToCharger = line( 30,0, 60, -10 )

        val posLines = plusToSwitch + switchToCharger + 
            chargerToBoost +
            boostToLED

        val negLines = batteryToCharger +
            chargerToBoost.mirrorY() +
            boostToLED.mirrorY()

        val text1 = Text( """On Charger :
    'B+' goes to the switch
    'B-' goes to battery's negative
    'out+' goes to boost's 'in+'
    'out-' goes to boost's 'in-'
   
""" ).translate(120,40)
    
        val text2 = Text( """On Boost :
    'out' connects to the LED
    'in' connects to the charger's "out"
""").translate(-180,-70)

        return led + switch + boost + battery + charger +
            posLines.color("Red") +
            negLines.color("Black") +
            text1 + text2
    }

}