// Math module for lance3d
var model_c = use('model')
var math = use('math/radians')
var random = use('random')

// Private RNG state
var _rng_seed = 12345

function seed(seed_int) {
  _rng_seed = seed_int
}

function rand() {
  // Simple LCG for deterministic random
  _rng_seed = (_rng_seed * 1103515245 + 12345) & 0x7fffffff
  return _rng_seed / 0x7fffffff
}

function irand(min_inclusive, max_inclusive) {
  return floor(rand() * (max_inclusive - min_inclusive + 1)) + min_inclusive
}

// Matrix helpers
function identity_matrix() {
  return model_c.mat4_identity()
}

function translation_matrix(x, y, z) {
  return model_c.mat4_from_trs(x, y, z, 0, 0, 0, 1, 1, 1, 1)
}

function rotation_matrix(qx, qy, qz, qw) {
  return model_c.mat4_from_trs(0, 0, 0, qx, qy, qz, qw, 1, 1, 1)
}

function scale_matrix(sx, sy, sz) {
  return model_c.mat4_from_trs(0, 0, 0, 0, 0, 0, 1, sx, sy, sz)
}

function trs_matrix(x, y, z, qx, qy, qz, qw, sx, sy, sz) {
  return model_c.mat4_from_trs(x, y, z, qx, qy, qz, qw, sx, sy, sz)
}

function euler_to_quat(pitch, yaw, roll) {
  var cy = math.cosine(yaw * 0.5)
  var sy = math.sine(yaw * 0.5)
  var cp = math.cosine(pitch * 0.5)
  var sp = math.sine(pitch * 0.5)
  var cr = math.cosine(roll * 0.5)
  var sr = math.sine(roll * 0.5)

  return {
    x: sr * cp * cy - cr * sp * sy,
    y: cr * sp * cy + sr * cp * sy,
    z: cr * cp * sy - sr * sp * cy,
    w: cr * cp * cy + sr * sp * sy
  }
}

function euler_matrix(pitch, yaw, roll) {
  var q = euler_to_quat(pitch, yaw, roll)
  return model_c.mat4_from_trs(0, 0, 0, q.x, q.y, q.z, q.w, 1, 1, 1)
}

function multiply_matrices(a, b) {
  return model_c.mat4_mul(a, b)
}

// Vector helpers
function vec3_add(a, b) {
  return {x: a.x + b.x, y: a.y + b.y, z: a.z + b.z}
}

function vec3_sub(a, b) {
  return {x: a.x - b.x, y: a.y - b.y, z: a.z - b.z}
}

function vec3_scale(v, s) {
  return {x: v.x * s, y: v.y * s, z: v.z * s}
}

function vec3_dot(a, b) {
  return a.x * b.x + a.y * b.y + a.z * b.z
}

function vec3_cross(a, b) {
  return {
    x: a.y * b.z - a.z * b.y,
    y: a.z * b.x - a.x * b.z,
    z: a.x * b.y - a.y * b.x
  }
}

function vec3_length(v) {
  return math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z)
}

function vec3_normalize(v) {
  var len = vec3_length(v)
  if (len < 0.0001) return {x: 0, y: 0, z: 0}
  return {x: v.x / len, y: v.y / len, z: v.z / len}
}

function lerp(a, b, t) {
  return a + (b - a) * t
}

function clamp(v, min, max) {
  if (v < min) return min
  if (v > max) return max
  return v
}

return {
  seed: seed,
  rand: rand,
  irand: irand,
  identity_matrix: identity_matrix,
  translation_matrix: translation_matrix,
  rotation_matrix: rotation_matrix,
  scale_matrix: scale_matrix,
  trs_matrix: trs_matrix,
  euler_to_quat: euler_to_quat,
  euler_matrix: euler_matrix,
  multiply_matrices: multiply_matrices,
  vec3_add: vec3_add,
  vec3_sub: vec3_sub,
  vec3_scale: vec3_scale,
  vec3_dot: vec3_dot,
  vec3_cross: vec3_cross,
  vec3_length: vec3_length,
  vec3_normalize: vec3_normalize,
  lerp: lerp,
  clamp: clamp
}