// dependency: https://github.com/revarbat/BOSL
use <BOSL/transforms.scad>
use <BOSL/metric_screws.scad>
use <BOSL/masks.scad>

include <tape.scad>

module frame() {
    tr=top_rim;
    tc=tr*1.5;
    fbd=front_body_depth;
    bbr=back_bumpers_radius;
    
    module back_bumpers() {
        module bumper() { back_half() circle(r=bbr); }
        back(depth) {
            right(bbr) bumper();
            right(width-bbr) bumper();
        }
    }
    
    module bolt() { metric_bolt(size=back_bumpers_bolt_size, headtype=bolt_headtype, l=height, pitch=0); }
        module nut() { metric_nut(size=back_bumpers_bolt_size, pitch=0); }
        
    module back_bolts() {
        back(depth) {
            right(bbr) {
                up(height) bolt();
                nut();
            }
            right(width-bbr) {
                up(height) bolt();
                nut();
            }
        }
    }
    
    module front_bolts() { 
        bolt_offset=front_body_bolt_offset;
        back(front_body_depth/2) {
            right(bolt_offset) {
                up(height) bolt();
                nut();
            }
            right(width-bolt_offset) {
                up(height) bolt();
                nut();
            }
        }
    }

    module top_cover() {
      up(height-plate) linear_extrude(height=plate) {
        back_bumpers();
        polygon(points=[
                // frame
                [0, 0], [0, depth],
                [width, depth], [width, 0],
                // window
                [tr, tr+fbd], [tr, depth-tr-tc], [tr+tc, depth-tr],
                [width-tr-tc, depth-tr], [width-tr, depth-tr-tc], [width-tr, tr+fbd]
            ],
            paths=[
                [0,1,2,3], [4,5,6,7,8,9]
            ]);
        }
    }
    
    module walls() {
        walls_height=height-plate*2;
        up(plate) linear_extrude(height=walls_height) {
            //back_bumpers();
            shell2d(thickness=-wall) {
                square([width, depth]);
            }
        }
    }
    
    module bottom_cover() {
        linear_extrude(height=plate) {
            back_bumpers();
            square([width, depth]);
        }
    }
    
    color("SaddleBrown") top_cover();
    color("grey") walls();
    color("SaddleBrown") bottom_cover();
    color("silver") back_bolts();
    color("silver") front_bolts();
}

module mechanism() {
    module spool(r_in, r_out, in_rim, out_rim) {
        module spindle(d, h) {
            color("Sienna") cylinder(h=h, d=d);
        }
            
        module spool_plate() {
            difference() {
                cylinder(h=spool_plate_height, r=r_out);
                if (!$preview && r_out - r_in > out_rim) {
                    angle=spool_plate_hole_angle;
                    difference() {
                        for (i = [1:spool_plate_holes]) {
                            zrot(360/spool_plate_holes * i) {
                                angle_pie_mask(r=r_out - out_rim, l=spool_plate_height, ang=angle, center=false);
                            }
                        }
                        cylinder(h=spool_plate_height, r=r_in + in_rim);
                    }
                }
            }
        }
        
        spindle_h=height-plate;
        difference() {
            color("Azure") {
                spool_plate();
                up(spool_plate_height) cylinder(h=spool_inner_height, r=r_in);
                up(spool_plate_height + spool_inner_height) spool_plate();
            }
            up(spool_plate_height + spool_inner_height/2) cube([r_in*2, spool_slit_depth, spool_inner_height], center=true);
            // TODO: spindle height
            spindle(d=spindle_diam+spindle_diam_tolerance, h=spindle_h);
        }
        spindle(d=spindle_diam, h=spindle_h);
    }
    
    module main_spool() {
        spool(r_in=spool_inner_radius,
            r_out=spool_outer_radius,
            in_rim=spool_plate_hole_inner_rim,
            out_rim=spool_plate_hole_outer_rim);
    }
    module aux_spool() {
        spool(r_in=middle_spool_in_r, r_out=middle_spool_out_r,
            in_rim=aux_spool_plate_hole_inner_rim,
            out_rim=aux_spool_plate_hole_outer_rim);
    }
    
    module spools() {
        up(plate) {
            right(main_spools_x) {
                back(spool1_depth) main_spool();
                back(spool2_depth) main_spool();
            }
            right(aux_spools_right_x) {
                back(spool3_depth) aux_spool();
                back(spool4_depth) aux_spool();
            }
            right(aux_spools_left_x) {
                back(spool4_depth) aux_spool();
            }
        }
    }
    
    module tapes() {
        spool1_tape_r = spool_outer_radius * 0.8;
        spool2_tape_r = spool_outer_radius * 0.5;
        up(plate + spool_plate_height) {
            // main spools
            right(main_spools_x) {
               back(spool1_depth) tape_spool(r_in=spool_inner_radius, r_out=spool1_tape_r);
               back(spool2_depth) tape_spool(r_in=spool_inner_radius, r_out=spool2_tape_r);
            }
            // TODO: convert to path
            // main 1 --> middle
            tape([main_spools_x + spool1_tape_r, spool1_depth, 0], [aux_spools_right_x + middle_spool_in_r, spool3_depth, 0]);
            // --> right corner
            right(aux_spools_right_x + middle_spool_in_r) tape([0, spool3_depth, 0], [0, spool4_depth, 0]);
            // --> left corner
            tape([aux_spools_left_x, spool4_depth - middle_spool_in_r, 0], [aux_spools_right_x, spool4_depth - middle_spool_in_r, 0]);
            // --> main 2
            tape([aux_spools_left_x - middle_spool_in_r, spool4_depth, 0], [main_spools_x - spool2_tape_r, spool2_depth, 0]);
        }
    }
    
    spools();
    tapes();
}

module holodisk() {
    #frame();
    mechanism();
}

holodisk();