import * as THREE from "three";


function guidGenerator() {
    var S4 = function() {
       return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
    };
    return (S4()+S4()+"-"+S4()+"-"+S4()+"-"+S4()+"-"+S4()+S4()+S4());
}

// Pure JS SHA-256 (works in browser or Node)
// Returns hex string
function sha256(message) {
  // UTF-8 encode string to bytes
  const msgBytes = new TextEncoder().encode(message);

  // Constants (first 32 bits of the fractional parts of the cube roots of the first 64 primes)
  const K = new Uint32Array([
    0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
    0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
    0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
    0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
    0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
    0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
    0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
    0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
  ]);

  // Initial hash values (first 32 bits of the fractional parts of the square roots of the first 8 primes)
  let H = new Uint32Array([
    0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,
    0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19
  ]);

  // Pre-processing: padding the message
  const l = msgBytes.length * 8;
  // Append 0x80 then zero bytes, then 64-bit big-endian length
  const k = (512 - ((l + 8 + 64) % 512)) % 512; // number of zero bits
  const totalBits = l + 1 + k + 64;
  const totalBytes = totalBits / 8;
  const padded = new Uint8Array(totalBytes);

  // copy message
  padded.set(msgBytes);

  // append 1 bit (0x80)
  padded[msgBytes.length] = 0x80;

  // append length in bits as 64-bit big-endian integer
  const lenPos = totalBytes - 8;
  for (let i = 0; i < 8; i++) {
    padded[lenPos + 7 - i] = (l >>> (i * 8)) & 0xff;
  }

  // Process the message in successive 512-bit chunks
  const W = new Uint32Array(64);

  function ROTR(n, x) { return (x >>> n) | (x << (32 - n)); }
  function Σ0(x) { return ROTR(2,x) ^ ROTR(13,x) ^ ROTR(22,x); }
  function Σ1(x) { return ROTR(6,x) ^ ROTR(11,x) ^ ROTR(25,x); }
  function σ0(x) { return ROTR(7,x) ^ ROTR(18,x) ^ (x >>> 3); }
  function σ1(x) { return ROTR(17,x) ^ ROTR(19,x) ^ (x >>> 10); }

  for (let chunkStart = 0; chunkStart < padded.length; chunkStart += 64) {
    // prepare message schedule W[0..63]
    for (let i = 0; i < 16; i++) {
      const j = chunkStart + i * 4;
      W[i] = (padded[j] << 24) | (padded[j + 1] << 16) | (padded[j + 2] << 8) | (padded[j + 3]);
    }
    for (let i = 16; i < 64; i++) {
      W[i] = (σ1(W[i - 2]) + W[i - 7] + σ0(W[i - 15]) + W[i - 16]) >>> 0;
    }

    // initialize working variables
    let a = H[0], b = H[1], c = H[2], d = H[3];
    let e = H[4], f = H[5], g = H[6], h = H[7];

    for (let t = 0; t < 64; t++) {
      const T1 = (h + Σ1(e) + ((e & f) ^ (~e & g)) + K[t] + W[t]) >>> 0;
      const T2 = (Σ0(a) + ((a & b) ^ (a & c) ^ (b & c))) >>> 0;
      h = g;
      g = f;
      f = e;
      e = (d + T1) >>> 0;
      d = c;
      c = b;
      b = a;
      a = (T1 + T2) >>> 0;
    }

    // compute intermediate hash value
    H[0] = (H[0] + a) >>> 0;
    H[1] = (H[1] + b) >>> 0;
    H[2] = (H[2] + c) >>> 0;
    H[3] = (H[3] + d) >>> 0;
    H[4] = (H[4] + e) >>> 0;
    H[5] = (H[5] + f) >>> 0;
    H[6] = (H[6] + g) >>> 0;
    H[7] = (H[7] + h) >>> 0;
  }

  // produce the final hash (big-endian)
  let hex = "";
  for (let i = 0; i < 8; i++) {
    hex += ("00000000" + H[i].toString(16)).slice(-8);
  }
  return hex;
}

function v3Encoder(vec3) { // THREE.Vector3 to Float32Array(3)
    const arr = new Float32Array(3);
    arr[0] = vec3.x;
    arr[1] = vec3.y;
    arr[2] = vec3.z;
    return arr;
}

function v3Decoder(arr) { // Float32Array(3) to THREE.Vector3
    return new THREE.Vector3(arr[0], arr[1], arr[2]);
}

function eulerEncoder(euler) { // THREE.Euler to Float32Array(3)
    const arr = new Float32Array(3);
    arr[0] = euler.x;
    arr[1] = euler.y;
    arr[2] = euler.z;
    return arr;
}

function eulerDecoder(arr) { // Float32Array(3) to THREE.Euler
    return new THREE.Euler(arr[0], arr[1], arr[2]);
}

const encoders = {
    Vector3: { encode: v3Encoder, decode: v3Decoder },
    Euler: { encode: eulerEncoder, decode: eulerDecoder },
    bool: { encode: (bool)=>bool, decode:(bool)=>bool}
    // Add more as needed
};

export { guidGenerator, sha256, encoders };