export default function(part) {
  let {
    store,
    sa,
    Point,
    points,
    Path,
    paths,
    options,
    complete,
    paperless,
    macro,
    utils,
    measurements
  } = part.shorthand();
  // Clean up paths from paperless dimensions
  for (let id in paths) delete paths[id];

  points[1] = new Point(
    points[0].x,
    measurements.seatDepth - options.waistbandWidth + 10
  );
  points[2] = new Point(
    points[0].x,
    points[1].y + measurements.inseam + store.get("lengthBonus")
  );
  points[3] = new Point(
    points[0].x,
    points[1].y + measurements.inseam / 2 + 50
  );
  points[4] = new Point(points[0].x, points[1].y - measurements.seatDepth / 4);
  points[5] = new Point(
    points[0].x - measurements.seatCircumference / 8 + 10,
    points[1].y
  );
  points[501] = points[5].shift(135, 30);
  points[502] = points[501].shift(45, 30);
  points[503] = points[501].shift(-135, 30);
  points[6] = new Point(points[5].x, points[4].y);
  points[7] = new Point(points[5].x, points[0].y);
  points[8] = new Point(
    points[6].x + measurements.seatCircumference / 4 + 20,
    points[6].y
  );
  points[801] = new Point(
    points[8].x,
    points[8].y - measurements.seatDepth / 4
  );
  points[802] = new Point(
    points[8].x,
    points[8].y + measurements.seatDepth / 4
  );
  points[9] = new Point(
    points[5].x -
      measurements.seatCircumference / 16 -
      5 +
      store.get("backReduction"),
    points[5].y
  );
  points[10] = new Point(points[7].x + 10, points[7].y);
  points[1001] = points[10].shiftTowards(points[6], 10);
  points[1002] = new Point(points[0].x, points[1001].y);
  points[11] = new Point(
    points[10].x + measurements.hipsCircumference / 4 + 25,
    points[10].y
  );
  points[12] = new Point(points[2].x + store.get("legWidth") / 2, points[2].y);
  points[1201] = new Point(points[12].x, points[12].y - 50);
  points[13] = points[12].flipX();
  points[1301] = points[1201].flipX();
  points[14] = new Point(
    points[3].x + store.get("legWidth") / 2 + 15,
    points[3].y
  );
  points[1401] = points[12].shiftOutwards(
    points[14],
    points[1].dy(points[3]) / 2
  );
  points[1402] = points[1401].flipX();

  points[15] = points[14].flipX();
  points[40] = new Path()
    .move(points[1001])
    .curve_(points[1002], points[11])
    .shiftAlong(50);
  points[41] = new Point(
    points[40].x + points[1001].dx(points[6]),
    points[40].y + points[1001].dy(points[6])
  );
  let tmp = new Path().move(points[6])._curve(points[502], points[501]);
  points[42] = tmp.shiftAlong(tmp.length() / 2);
  points[43] = points[42].shift(-35, 10);
  points["43beam"] = points[42].shift(-35, 40); // We use this to find curve intersection later
  points[44] = points[43].shift(0, 20);
  points[45] = points[40].shiftOutwards(points[41], 20);

  points[-1001] = new Path()
    .move(points[1001])
    .curve_(points[1002], points[11])
    .shiftAlong(10);
  points[-100101] = points[-1001].shift(points[1001].angle(points[6]), 10);
  points[-1002] = points[1002].shift(90, -10);
  points[-11] = new Path()
    .move(points[11])
    ._curve(points[801], points[8])
    .shiftAlong(10);
  points[-1101] = new Path()
    .move(points[11])
    ._curve(points[1002], points[1001])
    .shiftAlong(10);
  points[-1102] = new Point(
    points[-1101].x + points[11].dx(points[-11]),
    points[-1101].y + points[11].dy(points[-11])
  );
  points[-801] = points[801].shift(0, -10);
  points[-8] = points[8].shift(0, -10);
  points[-802] = points[802].shift(0, -10);
  points[-1401] = points[1401].shift(points[1401].angle(points[14]) + 90, -10);
  points[-14] = points[14].shift(points[1401].angle(points[14]) + 90, -10);
  points[-1201] = points[1201].shift(0, -10);
  points[-12] = points[12].shift(0, -10);
  points[-13] = points[13].shift(0, 10);
  points[-1301] = points[1301].shift(0, 10);
  points[-15] = points[-14].flipX();
  points[-1402] = points[-1401].flipX();
  points[-901] = new Path()
    .move(points[9])
    ._curve(points[503], points[501])
    .shiftAlong(10);
  points[-902] = new Path()
    .move(points[9])
    ._curve(points[1402], points[15])
    .shiftAlong(10);
  points[-9] = new Point(
    points[-902].x + points[9].dx(points[-901]),
    points[-902].y + points[9].dy(points[-901])
  );
  points[-501] = points[501].shift(points[503].angle(points[502]) - 90, 10);
  points[-502] = points[502].shift(points[503].angle(points[502]) - 90, 10);
  points[-503] = points[503].shift(points[503].angle(points[502]) - 90, 10);
  points[-6] = points[6].shift(points[6].angle(points[1001]) - 90, 10);
  points[-40] = points[40].shiftTowards(points[41], 10);

  // Smooth fly curve a bit at -6
  points["-6cp"] = points[-100101].shiftOutwards(
    points[-6],
    points[-6].dist(points[-502]) / 2
  );

  // Make sure fly ends on curve
  points.flyPretipX = utils.lineIntersectsCurve(
    points[42],
    points["43beam"],
    points[-501],
    points[-502],
    points["-6cp"],
    points[-6]
  );
  points[43] = points.flyPretipX.clone();

  // Slant pocket
  points[60] = new Path()
    .move(points[-1102])
    ._curve(points[-1002], points[-100101])
    .shiftAlong(50);
  let curve = new Path().move(points[-1102])._curve(points[-801], points[-8]);
  let len = curve.length();
  if (len >= 190) points[61] = curve.shiftAlong(190);
  else
    points[61] = new Path()
      .move(points[-8])
      .curve(points[-802], points[-1401], points[-14])
      .shiftAlong(190 - len);

  // Paths
  // This is the original Aldrich path, which includes seam allowance
  paths.aldrich = new Path()
    .move(points[9])
    ._curve(points[503], points[501])
    .curve_(points[502], points[6])
    .line(points[1001])
    .curve_(points[1002], points[11])
    ._curve(points[801], points[8])
    .curve(points[802], points[1401], points[14])
    ._curve(points[1201], points[12])
    .line(points[13])
    .curve_(points[1301], points[15])
    .curve_(points[1402], points[9])
    .close();

  // This is the path we use, no seam allowance
  paths.hemBase = new Path().move(points[-12]).line(points[-13]);
  paths.saBase = new Path()
    .move(points[-13])
    .curve_(points[-1301], points[-15])
    .curve_(points[-1402], points[-9])
    ._curve(points[-503], points[-501])
    .curve(points[-502], points["-6cp"], points[-6])
    .line(points[-100101])
    .curve_(points[-1002], points[-1102])
    ._curve(points[-801], points[-8])
    .curve(points[-802], points[-1401], points[-14])
    ._curve(points[-1201], points[-12]);

  paths.seam = paths.hemBase
    .clone()
    .join(paths.saBase)
    .close()
    .attr("class", "fabric");

  paths.aldrich.render = false;
  paths.hemBase.render = false;
  paths.saBase.render = false;

  // Complete pattern?
  if (complete) {
    if (sa) {
      paths.sa = paths.hemBase
        .offset(-3 * sa)
        .join(paths.saBase.offset(-1 * sa))
        .close()
        .attr("class", "fabric sa");
    }
    paths.fly = new Path()
      .move(points[43])
      .curve(points[44], points[45], points[41])
      .line(points[-40])
      .attr("class", "fabric dashed");
    paths.pocket = new Path()
      .move(points[60])
      .line(points[61])
      .attr("class", "fabric dashed");
    paths.lining = new Path()
      .move(points[-14])
      .line(points[-15])
      .attr("class", "lining dashed");
    macro("title", { at: points.title, title: "front", nr: 2 });
    macro("sprinkle", {
      snippet: "notch",
      on: [60, 61, 43]
    });
  }

  // Paperless?
  if (paperless) {
    macro("hd", {
      from: points[-9],
      to: points[-100101],
      y: points[-1102].y - sa - 15
    });
    macro("hd", {
      from: points[-100101],
      to: points[-1102],
      y: points[-1102].y - sa - 15
    });
    macro("hd", {
      from: points[-9],
      to: points[-1102],
      y: points[-1102].y - sa - 15
    });
    macro("hd", {
      from: points[-9],
      to: points[-8],
      y: points[-1102].y - sa - 30
    });
    macro("vd", {
      from: points[-9],
      to: points[-100101],
      x: points[-9].x - sa - 15
    });
    macro("vd", {
      from: points[-9],
      to: points[-1102],
      x: points[-9].x - sa - 30
    });
    macro("vd", {
      from: points[-13],
      to: points[-9],
      x: points[-9].x - sa - 30
    });
    macro("vd", {
      from: points[-12],
      to: points[-1102],
      x: points[-8].x + sa + 15
    });
    macro("hd", {
      from: points[-13],
      to: points[-12],
      y: points[-12].y + 3 * sa + 15
    });
  }

  return part;
}