// utils

const r = (n, d = 2) => {
  const f = Math.pow(10, d);
  return Math.round(n * f) / f;
};

// unit selection

const units = {
  in: document.getElementById('units'),
  out: document.querySelectorAll('output[for=units]'),
};

const setUnits = () => {
  units.out.forEach((el) => {
    el.value = units.in.value;
  });
}

// pendulum calculations

const beats = {
  in: document.getElementById('beats-in'),
  bpm: document.getElementById('bpm'),
  bph: document.getElementById('bph'),
};

const pendulum = {
  theory: document.getElementById('pendulum-theory-out'),
  try: document.getElementById('pendulum-safe-out'),
};

const getBpm = () => parseFloat(beats.in.value, 10) * 60;
const getBph = () => getBpm() * 60;

const setBeats = () => {
  beats.bpm.value = r(getBpm());
  beats.bph.value = r(getBph());
};

const setLength = () => {
  const bpm = Math.pow(getBpm(), 2);
  let L = 141220 / bpm;

  if (units.in.value === 'mm') {
    L = (3578.4 / bpm) * 1000;    
  }
  
  pendulum.theory.value = r(L);
  pendulum.try.value = r(L * 0.2);
}

// going train calculations

const going = {
  escape: {
    wheel: document.getElementById('escape-wheel'),
    factor: document.getElementById('escape-factor'),
  },
  third: {
    pinion: document.getElementById('third-pinion'),
    wheel: document.getElementById('third-wheel'),
  },
  center: {
    pinion: document.getElementById('center-pinion'),
    wheel: document.getElementById('center-wheel'),
  },
  spurs: document.getElementById('total-spurs'),
};

const setCenter = () => {
  const escape = {
    wheel: parseInt(going.escape.wheel.value, 10),
    factor: parseInt(going.escape.factor.value, 10),
    pinion: parseInt(going.third.pinion.value, 10),
  };

  const third = {
    wheel: parseInt(going.third.wheel.value, 10),
    pinion: parseInt(going.center.pinion.value, 10),
  };

  const e = escape.wheel * escape.factor;
  const t = third.wheel / escape.pinion;
  const p = third.pinion;
  const c = getBph() / (e * t) * p;
  
  going.center.wheel.value = r(c, 4);
};

const setSpurs = () => {
  const g = {
    ew: parseInt(going.escape.wheel.value, 10),
    tp: parseInt(going.third.pinion.value, 10),
    tw: parseInt(going.third.wheel.value, 10),
    cp: parseInt(going.center.pinion.value, 10),
    cw: parseInt(going.center.wheel.value, 10),
  };

  going.spurs.value = Object.values(g).reduce((sub, item) => sub + item, 0);
};


// wheel sizing

const sizes = {
  third: {
    od: document.getElementById('third-od-in'),
    odRead: document.getElementById('third-od'),
    pd: document.getElementById('third-pd'),
    w: document.getElementById('third-w'),
    ppd: document.getElementById('third-pinion-pd'),
    set: document.getElementById('third-set-spacing'),
    
    useW: document.getElementById('eq-spurs'),
    hide: document.querySelectorAll('[data-hide=eq-spurs]'),
    show: document.querySelectorAll('[data-show=eq-spurs]'),
  },
  center: {
    od: document.getElementById('center-od'),
    pd: document.getElementById('center-pd'),
    w: document.getElementById('center-w'),
    ppd: document.getElementById('center-pinion-pd'),
    set: document.getElementById('center-set-spacing'),
  },
};

const spursDiv = (s) => (s / (s + 2));

const getSizeFromOD = (wheel) => {
  const ws = parseInt(going[wheel].wheel.value, 10);
  const ps = parseInt(going[wheel].pinion.value, 10);
  
  const wpd = parseFloat(sizes[wheel].od.value) * spursDiv(ws);
  const w = wpd * Math.PI / ws;
  const ppd = (ps * w) / Math.PI;
  const set = (ppd + wpd) / 2;

  return { wpd, w, ppd, set, };
}

const getSizeFromW = (wheel, w) => {
  const ws = parseInt(going[wheel].wheel.value, 10);
  const ps = parseInt(going[wheel].pinion.value, 10);
  
  const wpd = (ws * w) / Math.PI;
  const ppd = (ps * w) / Math.PI;
  const set = (ppd + wpd) / 2;
  const od = wpd / spursDiv(ws);

  return { wpd, w, ppd, set, od, };
}

const setGearSizing = (wheel, w) => {
  const els = sizes[wheel];
  const s = w
    ? getSizeFromW(wheel, parseFloat(w, 10))
    : getSizeFromOD(wheel);
  
  els.pd.value = r(s.wpd);
  els.w.value = r(s.w);
  els.ppd.value = r(s.ppd);
  els.set.value = r(s.set);
  
  if (s.od) {
    els.odRead.value = r(s.od);
  }
}


// initialize

const calcSizing = () => {
  setGearSizing('center');
  
  const hide = (el, hidden) => {
    hidden
      ? el.setAttribute('hidden', '')
      : el.removeAttribute('hidden');
  }
  
  if (sizes.third.useW.checked) {
    sizes.third.hide.forEach((el) => hide(el, true));
    sizes.third.show.forEach((el) => hide(el, false));
    setGearSizing('third', sizes.center.w.value);
  } else {
    sizes.third.hide.forEach((el) => hide(el, false));
    sizes.third.show.forEach((el) => hide(el, true));
    setGearSizing('third');
  }
}

const calcTrain = () => {
  setCenter();
  setSpurs();
  calcSizing();
};

const calc = () => {  
  setUnits();
  setBeats();
  setLength();
  calcTrain();
};

units.in.addEventListener('input', (e) => calc());
beats.in.addEventListener('input', (e) => calc());

going.escape.wheel.addEventListener('input', (e) => calcTrain());
going.escape.factor.addEventListener('input', (e) => calcTrain());
going.third.pinion.addEventListener('input', (e) => calcTrain());
going.third.wheel.addEventListener('input', (e) => calcTrain());
going.center.pinion.addEventListener('input', (e) => calcTrain());

sizes.center.od.addEventListener('input', (e) => calcSizing());
sizes.third.od.addEventListener('input', (e) => calcSizing());
sizes.third.useW.addEventListener('input', (e) => calcSizing());

calc();