include <units.inc>;
include <lib.scad>;
include <constants.scad>;
include <stock_parts.scad>;

frame_size = 20;
wall_thickness = 2;
corner_size=30;
// The length along each edge that the corner bracket takes.  I.e., if
// you construct a frame of four corner brackets and 4 tubes of length
// $L-$corner_size, the distance between opposite tubes' centerlines
// will be $L.
corner_offset = frame_size / 2 + wall_thickness;
rail_diam = 8;
// distance between centerline of rail and centerline of frame Y tube.
yrail_offset = (frame_size + corner_size / 2) / 2;

ysled_extralen = frame_size; // on each end

// calculated

ysled_rail_spacing = (sled_ysize);




// Generates bar of length $l, centered on origin extending in +Z
module tslot(l) {
  bom_item(printable=false, label = str("tslot(", l, "mm)"));
  colorize(stock_color) {
    translate([-frame_size/2, -frame_size/2, 0])
      cube([frame_size, frame_size, l]);
  }
}

// A corner, with tubes extending in +x and +y.
module corner_base() {
  odim = frame_size/2 + wall_thickness;
  ldim = frame_size/2 + corner_size;
  cap_points = [[-odim, -odim],
		[-odim,  ldim],
		[ odim,  ldim],
		[ ldim,  odim],
		[ ldim, -odim]];
  difference() {
    translate([0, 0, -odim])
      linear_extrude(odim * 2)
      polygon(points = cap_points);
    
    // two bars...
    translate([-frame_size/2, corner_offset, -frame_size/2])
      cube([frame_size, ldim, frame_size]);
    translate([corner_offset, -frame_size/2, -frame_size/2])
      cube([ldim, frame_size, frame_size]);
    translate([corner_offset, corner_offset, -frame_size/2])
      cube([ldim, ldim, frame_size]);
    //translate([-odim - 1, -odim - 1, 0])
    //cube(ldim*2);
  }
}

module rail_holder(in_x) {
  odim = frame_size/2 + wall_thickness;
  ldim = frame_size/2 + corner_size;
  tube_offset = (corner_size) / 2 + wall_thickness;
  tube_rotation = in_x ? 90 : 0;

  translated_rail_offset = yrail_offset - frame_size / 2;

  translate([frame_size/2, frame_size/2, -frame_size/2]) {
    difference() {
      linear_extrude(frame_size)
	      polygon(points = [[wall_thickness, wall_thickness],
			    [wall_thickness, corner_size],
		      [corner_size, wall_thickness]]);

      translate([translated_rail_offset, translated_rail_offset, frame_size/2])
        rotate([tube_rotation -90, tube_rotation, 0])
        translate([0, 0, -corner_size])
        cylinder(d = rail_diam, corner_size * 4);
		
    }
  }
}

// centered on 
module ysled_slider(spread, associated_parts = $preview) {
  bom_item(label = str("ysled_slider(", spread, ")"));
  sled_len = spread + frame_size;
  sled_height = frame_size;
  
  colorize("green")
  render()
  translate([0, -sled_len/2, 0])
  rotate([-90, 0, 0]) {
    difference() {
      union() {
	translate([-frame_size/2, -frame_size/2, 0])
	  cube([frame_size + 5, frame_size, sled_len]);
      }
      
      cylinder(d = bushing_id * 1.1, h = sled_len);
      
      translate([0,0,-1])
	cylinder(d = bushing_od, h = bushing_len+1);
      translate([0,0,sled_len - bushing_len])
	cylinder(d = bushing_od, h = bushing_len+1);

      for (zpos = [frame_size / 2, sled_len - frame_size / 2]) {
	translate([sled_height/2, 0, zpos]) 
	rotate([0,90,0]) {
	  cylinder(h = sled_height + 1, d = rail_diam);
	}
      }
    }
  }
  // TODO: add posts for the idlers
  
  translate([0, -sled_len/2, 0])
  rotate([-90, 0, 0])
  if (associated_parts) {
    bushing();
    translate([0,0,sled_len - bushing_len]) bushing();
  }
}

module nema17_housing() {
  hwidth = corner_size + frame_size + wall_thickness;
  hheight = nema17_face + wall_thickness * 2;
  hdepth = frame_size + wall_thickness * 2;

  screw_dxy = 31 / 2;
  translate([0,
	     -nema17_face/2 - frame_size/2 - wall_thickness,
	     0])
    render()
  difference() {
    cube([hwidth, hheight, hdepth],
	 center=true);

    translate([0,0,-2])
      cube([nema17_face+1, nema17_face+1, hdepth],
	   center=true);
    cylinder(d=23, frame_size);

    for (x = [-screw_dxy, screw_dxy],
	   y = [-screw_dxy, screw_dxy])
      translate([x, y, frame_size/2 + wall_thickness])
      rotate([180, 0, 0]){
	cylinder(d=5,h=3);
      }
	
  }
}

module flcorner() {
  bom_item();
  rotate([0, 0, 0]) {
    corner_base();
    rail_holder(false);
  }
  translate([(corner_size-wall_thickness)/2, 0, 0])
    nema17_housing();
  
  if($preview)
  translate([(corner_size - wall_thickness) / 2,
	     -nema17_face/2 - frame_size/2 - wall_thickness,
	     frame_size/2]) {
    nema17();
    translate([0, 0, 2]) {
      pulley(16,6,1,7);
    }
  }
    
}

module frcorner() {
  bom_item();
  rotate([0, 0, 90]) {
    corner_base();
    rail_holder(true);
  }
  translate([-(corner_size-wall_thickness)/2, 0, 0])
    nema17_housing();
  
  if($preview)
  translate([-(corner_size - wall_thickness) / 2,
	     -nema17_face/2 - frame_size/2 - wall_thickness,
	     frame_size/2]) {
    nema17();
    translate([0,0,2]) {
      pulley(16, 1, 6, 7);
    }
  }
}

module blcorner() {
  bom_item();
  rotate([0, 0, 270]) {
    corner_base();
    rail_holder(true);
  }
}

module brcorner() {
  bom_item();
  rotate([0, 0, 180]) {
    corner_base();
    rail_holder(false);
  }
}

module xsled_slider() {
  slider_len = bushing_len + 10;
  screw_tab_len = 20;
  screw_tab_thickness = 10;
  
  render()
    //translate([screw_tab_len, 0, 0])
  difference() {
    union() {
      rotate([0, 90, 0]) {
	cylinder(d = frame_size, h = slider_len);
      }

      translate([0, -frame_size/2, 0])
      cube([slider_len, frame_size, frame_size / 2]);

      *translate([-screw_tab_len, -frame_size/2, frame_size/2])
	cube([screw_tab_len * 2 + slider_len, frame_size, screw_tab_thickness]);
    }
    rotate([0, 90, 0]) {
      cylinder(d = bushing_od, h = bushing_len);
      cylinder(d = rail_diam * 1.1, slider_len * 2);
    }
    
  }
  if($preview)
  rotate([0, 90, 0])
    bushing();
}

module sled_cornera() {
  bom_item();
  corner_base();
  translate([-frame_size/2 - wall_thickness, 0, -frame_size])
    xsled_slider();
}

module sled_cornerb() {
  bom_item();
  corner_base();
  rotate([0,0,90])
  translate([-frame_size/2 - wall_thickness, 0, -frame_size])
    xsled_slider();
}

module xsled_frame() {
  translate([-sled_xsize / 2 + corner_offset, -ysled_rail_spacing/2, 0])
    rotate([0, 90, 0])
    tslot(sled_xsize - corner_offset * 2);
  translate([-sled_xsize / 2 + corner_offset, ysled_rail_spacing/2, 0])
    rotate([0, 90, 0])
    tslot(sled_xsize - corner_offset * 2);
  translate([-sled_xsize / 2, -ysled_rail_spacing/2 + corner_offset, 0])
    rotate([-90, 0, 0])
    tslot(sled_ysize - corner_offset * 2);
  translate([sled_xsize / 2, -ysled_rail_spacing/2 + corner_offset, 0])
    rotate([-90, 0, 0])
    tslot(sled_ysize - corner_offset * 2);

  translate([-sled_xsize / 2, -sled_ysize / 2, 0])
    sled_cornera();
  translate([sled_xsize / 2, sled_ysize / 2, 0])
    rotate([0,0,180])
    sled_cornera();
  
  translate([sled_xsize / 2, -sled_ysize / 2, 0])
    rotate([0,0,90])
    sled_cornerb();
  translate([-sled_xsize / 2, sled_ysize / 2, 0])
    rotate([0,0,270])
    sled_cornerb();


  // simulate a piece of film
  if (false) {
    color("#0008")
      cube([
	     5*inch,
	     4*inch,
	     1
	     ],
	   center=true);
  }
}

module xsled2() {
  bom_item();

  tab_len = bushing_len * 2;
  tab_thickness = bushing_od + wall_thickness * 2;
  glass_thickness = 3; // TODO: Update when an actual size is available

  inner_ysize = sled_ysize - tab_thickness;

  lip_depth = tab_thickness - wall_thickness - glass_thickness;
  lip_width = glass_thickness;

  glass_holder_points = [
    [0,0],
    [lip_depth + wall_thickness, 0],
    [lip_depth + wall_thickness, wall_thickness + 0.5],
    [lip_depth, wall_thickness + 0.5],
    [lip_depth, wall_thickness + glass_thickness],
    [lip_depth - glass_thickness, wall_thickness + glass_thickness],
    [lip_depth - glass_thickness, wall_thickness + glass_thickness*2],
    [0, tab_thickness]
  ];


  for (xsign = [1,-1],
	 ysign = [1,-1]) {
    translate([sled_xsize / 2 * xsign,
	       sled_ysize / 2 * ysign,
		0])
    rotate([0, -90 * xsign, 0]) {
      difference() {
        union() {
          cylinder(d = tab_thickness, h = tab_len);
          translate([-tab_thickness/2,
                      ysign > 0 ? -tab_thickness/2: 0,
                      0])
          cube([tab_thickness, tab_thickness/2, tab_len]);    
        }
        translate([0,0,-0.5]) {
        	cylinder(d = bushing_od, h = bushing_len+0.5);
          cylinder(d = rail_diam * 1.1 , h = tab_len + 1);
        }
      }
      if ($preview) {
        bushing();
      }
    }

    //cube([sled_xsize, inner_ysize, tab_thickness/2], center=true);
    difference() {
      union() {
        translate([-sled_xsize/2, -inner_ysize/2, -tab_thickness/2])
        rotate([0, 90, 0])
        rotate([0,0,90])
        linear_extrude(sled_xsize)
        polygon(glass_holder_points);

        translate([sled_xsize/2, inner_ysize/2, -tab_thickness/2])
        rotate([0, 90, 180])
        rotate([0,0,90])
        linear_extrude(sled_xsize)
        polygon(glass_holder_points);

        translate([sled_xsize/2, -inner_ysize/2, -tab_thickness/2])
        rotate([0, 90, 90])
        rotate([0,0,90])
        linear_extrude(inner_ysize)
        polygon(glass_holder_points);

        translate([-sled_xsize/2, inner_ysize/2, -tab_thickness/2])
        rotate([0, 90, -90])
        rotate([0,0,90])
        linear_extrude(inner_ysize)
        polygon(glass_holder_points);
      }

      translate([-10, inner_ysize/2 - 1 - lip_depth + glass_thickness, -tab_thickness/2 + wall_thickness + glass_thickness])
      cube([20, glass_thickness + 1, 30]);
    }
  }

  color("#fff3")
  if ($preview) {
    // draw glass sheets
    translate([0,0,-tab_thickness/2 + wall_thickness + glass_thickness/2])
    cube([sled_xsize - lip_depth*2, inner_ysize - lip_depth*2, glass_thickness],
      center=true);
    translate([0,0,-tab_thickness/2 + wall_thickness + 3*glass_thickness/2])
    cube(
      [
        sled_xsize - lip_depth*2 + glass_thickness*2,
        inner_ysize - lip_depth*2 + glass_thickness*2, 
        glass_thickness
      ],
      center=true);
    
  }
}
// render()
// xsled2();