const Pentagon = document.getElementById("pentagon");
const Triangle = document.getElementById("triangle");
const Lambert = document.getElementById("lambert");
/*
Pentagon.addGeodesic(calcPoint(1, 0), [0, 1, 0], [-10, 10], 0);

A = calcPoint(0, 1.0);
C = calcPoint(1.0, 0);
D = calcPoint(0, 0);

B = geodesic(A, [1.0, 0.0, 0.0], 1.0);
B_ = geodesic(C, [0.0, 1.0, 0.0], 1.0);

Pentagon.addPoint(A, 0);
Pentagon.addPoint(B, 1);
Pentagon.addPoint(C, 2);
Pentagon.addPoint(D, 3);
Pentagon.addPoint(B_, 4);

a = calcGeodesic(A, B);
Pentagon.addGeodesic(a.A, a.U, a.t, 2);
b = calcGeodesic(B, B_);
Pentagon.addGeodesic(b.A, b.U, b.t, 3);
c = calcGeodesic(C, D);
Pentagon.addGeodesic(c.A, c.U, c.t, 4);
g = calcGeodesic(A, D);
Pentagon.addGeodesic(g.A, g.U, g.t, 5);
*/

function calcPentagon(input) {
  console.log(input);
  var r = Math.exp(input / 100.0);
  console.log(r);
  var points = [];
  for (let i = 0; i < 5; i++) {
    let point = calcPoint(
      Math.cos((2.0 * Math.PI * i) / 5.0) * r,
      Math.sin((2.0 * Math.PI * i) / 5.0) * r
    );
    points.push(point);
  }
  for (let i = 0; i < 5; i++) {
    let A = points[i];
    let B = points[(i + 1) % 5];
    let g = calcGeodesic(A, B);
    Pentagon.setGeodesic(g.A, g.U, g.t, i);
    Pentagon.setPoint(A, i + 1);
  }
}
calcPentagon(100);

var alpha = 30;
var beta = 30;
var gamma = 30;

function changeTriangle(value, index) {
  switch (index) {
    case 0:
      alpha = parseInt(value, 10);
      break;
    case 1:
      beta = parseInt(value, 10);
      break;
    case 2:
      gamma = parseInt(value, 10);
      break;
    default:
      console.log("Invalid index");
  }
  calcTriangle();
}

function calcTriangle() {
  //var s = alpha + beta + gamma;
  //console.log(alpha, beta, gamma, s);
  al = alpha * (Math.PI / 180);
  be = beta * (Math.PI / 180);
  ga = gamma * (Math.PI / 180);

  var a = Math.acosh(
    (Math.cos(be) * Math.cos(ga) + Math.cos(al)) / (Math.sin(be) * Math.sin(ga))
  );
  var t = calcPoint(0, -1);
  var ta = calcTang([0, 0, 1], [0, -1, 0], t);
  U = calcU(t, ta, Math.PI / 2);
  var B = geodesic(t, U, a / 2);
  var C = geodesic(t, U, -a / 2);
  Triangle.setPoint(B, "B");
  Triangle.setPoint(C, "C");
  var g_a = calcGeodesic(B, C);
  Triangle.setGeodesic(g_a.A, g_a.U, g_a.t, 1);
  var U_c = calcU(B, calcGeodesic(B, C).U, be);
  Triangle.setGeodesic(g_a.A, U_c, [-10, 10], 3);
  console.log(dot(U_c, U_c));
  console.log(times(wedge(U_c, g_a.U), 1 / Math.sin(be)));
  console.log(B);

  var U_b = calcU(C, calcGeodesic(C, B).U, Math.PI - ga);
  console.log(U_b);
  console.log(dot(U_b, U_b));
  Triangle.setGeodesic(C, U_b, [-10, 10], 4);
}

AB = 0.5;
AD = 0.5;
function changeDistance(value, type) {
  switch (type) {
    case "AB":
      AB = value / 100;
      break;
    case "AD":
      AD = value / 100;
      break;
    default:
      console.log("Invalid type");
  }
  calcLambert();
  console.log(AB, AD);
}

function calcLambert() {
  var da = Math.sqrt(AB * AB + AD * AD);
  var U0 = [Math.SQRT2 / 2, -Math.SQRT2 / 2, 0];
  var A0 = calcPoint(0, 0);
  var A = geodesic(A0, U0, da);
  var UA = calcTang(A0, U0, A);
  console.log(UA);
  var U1 = calcU(A, UA, -Math.PI / 4);
  Lambert.setPoint(A, "A");
  Lambert.setGeodesic(A, U1, [0, AB], 0);
  var U2 = calcU(A, UA, Math.PI / 4);
  Lambert.setGeodesic(A, U2, [0, AD], 1);
  var B = geodesic(A, U1, AB);
  Lambert.setPoint(B, "B");
  var D = geodesic(A, U2, AD);
  Lambert.setPoint(D, "D");
  var UD = calcTang(A, U2, D);
  var UB = calcTang(A, U1, B);
  var U3 = calcU(D, UD, Math.PI / 2);
  var U4 = calcU(B, UB, -Math.PI / 2);
  Lambert.setGeodesic(D, U3, [0, 7.0], 2);
  Lambert.setGeodesic(B, U4, [0, 7.0], 3);
  var sAD = Math.sinh(AD);
  var sAB = Math.sinh(AB);
  //Lambert.setText("sinh(AD)sinh(AB) = " + sAD * sAB);
}

calcLambert();
calcTriangle();