package mz_macros;
import harmonic.mz.data.*;
import harmonic.mz.data.fields.*;
import harmonic.mz.function.*;
import harmonic.cad.shapes.*;
import harmonic.cad.manager.*;
import harmonic.mz.manager.*;
import harmonic.mz.gui.*;
import harmonic.meshGeom.math.*;
import java.util.*;
import java.awt.*;


public class MakeSpring extends Module
{
  // These units are MILLIMETERS (1A= 5mm at 50,000,000X)
  // so, 1.0 = 5mm; 0.2 = 1mm; 0.1 = 0.5mm; 0.04 = 0.2mm **layer thickness**
  ScalarField housing_radius = new ScalarField("housing_radius", 5.0f);
  ScalarField axle_radius = new ScalarField("axle_radius", 1.f);

  // thickness of radial walls
  ScalarField radial_thickness = new ScalarField("radial_thickness", 0.5f);
  ScalarField radial_tolerance = new ScalarField("radial_tolerance", 0.15f);

  // thickness of axial walls (axial means along Z-axis, probably).
  ScalarField axial_thickness = new ScalarField("axial_thickness", 0.5f);
  ScalarField axial_tolerance = new ScalarField("axial_tolerance", 0.2f);

  // entire height of housing
  ScalarField height = new ScalarField("height", 5.75f);

  // define spring
  ScalarField spring_radius = new ScalarField("spring_radius", 3.f);
  ScalarField tube_radius = new ScalarField("tube_radius", 0.5f);
  

  // turns of spring in housing
  ScalarField turns = new ScalarField("turns", 2.f);
  IntField samplesPerTurn = new IntField("samplesPerTurn", 32);

  // scale factor
  ScalarField scale = new ScalarField("scale", 1.f);
  
  float housing_radius_s;
  float axle_radius_s;
  float radial_thickness_s;
  float radial_tolerance_s;
  float axial_thickness_s;
  float axial_tolerance_s;
  float tube_radius_s;
  float spring_radius_s;
  float height_s;
  float turns_s;
  float samplesPerTurn_s;
  
  public MakeSpring()
  {
    setName("Make Spring");
    MZ.modules().loadModule("harmonic.cad.manager.CAD");
  }
  
  public Component macroGUI(){
    Vector nodes = new Vector();
    nodes.add(height);
    nodes.add(housing_radius);
    nodes.add(axle_radius);
    nodes.add(radial_thickness);
    nodes.add(radial_tolerance);
    nodes.add(axial_thickness);
    nodes.add(axial_tolerance);
    nodes.add(spring_radius);
    nodes.add(tube_radius);
    nodes.add(turns);
    nodes.add(samplesPerTurn);
    nodes.add(scale);
    return new NodeValuesDialog(nodes, "Make Spring");
  }


  public ShapeNode make_spring()
  {
    // call MakeHelix macro
    MakeHelix mh = new MakeHelix();
    // tranxfer params
    mh.radius.setScalar(spring_radius.getScalar());
    mh.height.setScalar(height.getScalar()/turns.getScalar());
    mh.turns.set(turns);
    mh.samplesPerTurn.set(samplesPerTurn);
    // make the shape
    PolylineShape helix = mh.make_helix();

    // make the section
    CircleFromCenterRadiusShape section = new CircleFromCenterRadiusShape();
    section.radius.setScalar(tube_radius.getScalar());
    // move the section to the end of the path
    TMat rot = new TMat();
    rot.fromXRotation(90.f*Geo.radPerDeg); // rotate
    TMat trans = new TMat();
    trans.translate(1.f, 0.f, 0.f);    // translate
    TMat sweepPerSection = new TMat();
    sweepPerSection.mul(trans, rot);
    section.getCoordSystem().setParentPerLocal(sweepPerSection); // do tfm
    // make the spring
    GeneralPathSweepShape spring = new GeneralPathSweepShape();
    spring.setName("Spring");
    spring.section.addNode(section);
    spring.path.addNode(helix);
    return spring;
  }
  
    
    
  public void execute()
  {
    float scale_factor = scale.getScalar();

    housing_radius_s = this.housing_radius.getScalar() * scale_factor;
    axle_radius_s = this.axle_radius.getScalar() * scale_factor;
    radial_thickness_s = this.radial_thickness.getScalar() * scale_factor;
    axial_thickness_s = this.axial_thickness.getScalar() * scale_factor;
    tube_radius_s = this.tube_radius.getScalar() * scale_factor;
    height_s = this.height.getScalar() * scale_factor;
    spring_radius_s = this.spring_radius.getScalar() * scale_factor;
    turns_s = this.turns.getScalar() * scale_factor;
    samplesPerTurn_s = this.samplesPerTurn.getInt() * scale_factor;
    
    
    // make spring with params from gui
    ShapeNode spring = make_spring();
    CAD.addShape(spring);
    Clr3f pink = new Clr3f(1.0f, 0.5f, 0.5f);
    ((SolidShape)spring).fillColor.setAllColors(pink);

    
    // Make housing
    CylinderFromCenterRadiusHeightShape outer =
      new CylinderFromCenterRadiusHeightShape();
    outer.radius.setScalar(housing_radius_s);
    outer.height.setScalar(height_s);
    Pnt3f outer_center = new Pnt3f();
    outer.center.setPoint(outer_center);
    
    CylinderFromCenterRadiusHeightShape inner =
      new CylinderFromCenterRadiusHeightShape();
    float inner_radius = housing_radius_s - radial_thickness_s;
    inner.radius.setScalar(inner_radius);
    Pnt3f inner_center = new Pnt3f(outer_center);
    inner_center.z += axial_thickness_s;
    inner.center.setPoint(inner_center);
    float inner_height = height_s - 2.f * axial_thickness_s;
    inner.height.setScalar(inner_height);


    CylinderFromCenterRadiusHeightShape ax_bore =
      new CylinderFromCenterRadiusHeightShape();
    float ax_bore_rad = axle_radius_s + radial_tolerance.getScalar();
    ax_bore.radius.setScalar(ax_bore_rad);
    Pnt3f bore_center = new Pnt3f(outer_center);
    bore_center.z += -1.f;
    ax_bore.center.setPoint(bore_center);
    float ax_bore_height = height_s + 2.f;
    ax_bore.height.setScalar(ax_bore_height);

    // add axle seat.

    // add spokes to distal end

    // now make it 
    
    SubtractionShape housing = new SubtractionShape();
    housing.positive.addNode(outer);
    housing.negative.addNode(inner);
    housing.negative.addNode(ax_bore);
    //    housing.negative.addNode(ax_seat);
    //    housing.negative.addNode(spokes);
    CAD.addShape(housing);
    housing.setName("housing");
    outer.visibility.setBoolean(false);
    inner.visibility.setBoolean(false);
    ax_bore.visibility.setBoolean(false);
    //    ax_seat.visibility.setBoolean(false);
    //    spokes.visibility.setBoolean(false);
    
    
  }
  

}