import type { EulerRotation, Vector3 } from './types.js';

const UINT32_MAX_PLUS_ONE = 0x1_0000_0000;

export function hashString(value: string): number {
  let hash = 2166136261;
  for (let index = 0; index < value.length; index += 1) {
    hash ^= value.charCodeAt(index);
    hash = Math.imul(hash, 16777619);
  }
  return hash >>> 0;
}

export function normalizeSeed(seed: number | string): number {
  const normalized = typeof seed === 'number' ? seed >>> 0 : hashString(seed);
  return normalized === 0 ? 0x6d2b79f5 : normalized;
}

export class DeterministicRandom {
  private value: number;

  constructor(seed: number | string) {
    this.value = normalizeSeed(seed);
  }

  get state(): number {
    return this.value >>> 0;
  }

  set state(value: number) {
    this.value = normalizeSeed(value);
  }

  next(): number {
    let value = (this.value += 0x6d2b79f5);
    value = Math.imul(value ^ (value >>> 15), value | 1);
    value ^= value + Math.imul(value ^ (value >>> 7), value | 61);
    this.value = this.value >>> 0;
    return ((value ^ (value >>> 14)) >>> 0) / UINT32_MAX_PLUS_ONE;
  }

  int(minInclusive: number, maxInclusive: number): number {
    if (!Number.isInteger(minInclusive) || !Number.isInteger(maxInclusive) || maxInclusive < minInclusive) {
      throw new RangeError('Invalid deterministic integer range');
    }
    return minInclusive + Math.floor(this.next() * (maxInclusive - minInclusive + 1));
  }

  float(minInclusive: number, maxExclusive: number): number {
    if (!Number.isFinite(minInclusive) || !Number.isFinite(maxExclusive) || maxExclusive < minInclusive) {
      throw new RangeError('Invalid deterministic float range');
    }
    return minInclusive + this.next() * (maxExclusive - minInclusive);
  }

  bool(probability = 0.5): boolean {
    if (probability < 0 || probability > 1) throw new RangeError('Probability must be between zero and one');
    return this.next() < probability;
  }

  pick<T>(values: readonly T[]): T {
    if (values.length === 0) throw new RangeError('Cannot choose from an empty collection');
    return values[this.int(0, values.length - 1)] as T;
  }

  shuffle<T>(values: readonly T[]): T[] {
    const result = [...values];
    for (let index = result.length - 1; index > 0; index -= 1) {
      const other = this.int(0, index);
      [result[index], result[other]] = [result[other] as T, result[index] as T];
    }
    return result;
  }
}

export function deterministicId(namespace: string, index: number | string): string {
  return `${namespace}-${String(index).padStart(3, '0')}`;
}

export function vector(x = 0, y = 0, z = 0): Vector3 {
  return { x, y, z };
}

export function rotation(pitch = 0, yaw = 0, roll = 0): EulerRotation {
  return { pitch, yaw, roll };
}

export function addVector(left: Vector3, right: Vector3): Vector3 {
  return { x: left.x + right.x, y: left.y + right.y, z: left.z + right.z };
}

export function subtractVector(left: Vector3, right: Vector3): Vector3 {
  return { x: left.x - right.x, y: left.y - right.y, z: left.z - right.z };
}

export function scaleVector(value: Vector3, scalar: number): Vector3 {
  return { x: value.x * scalar, y: value.y * scalar, z: value.z * scalar };
}

export function magnitude(value: Vector3): number {
  return Math.hypot(value.x, value.y, value.z);
}

export function normalizeVector(value: Vector3): Vector3 {
  const length = magnitude(value);
  return length <= Number.EPSILON ? vector() : scaleVector(value, 1 / length);
}

export function clampMagnitude(value: Vector3, maximum: number): Vector3 {
  const length = magnitude(value);
  return length > maximum && length > 0 ? scaleVector(value, maximum / length) : { ...value };
}

export function distance(left: Vector3, right: Vector3): number {
  return magnitude(subtractVector(left, right));
}

export function clamp(value: number, minimum: number, maximum: number): number {
  return Math.min(maximum, Math.max(minimum, value));
}

export function round(value: number, digits = 6): number {
  const factor = 10 ** digits;
  return Math.round(value * factor) / factor;
}

export function stableStringify(value: unknown): string {
  const seen = new WeakSet<object>();
  const normalize = (entry: unknown): unknown => {
    if (entry === null || typeof entry !== 'object') return entry;
    if (seen.has(entry)) throw new TypeError('Cannot serialize cyclic simulation state');
    seen.add(entry);
    if (Array.isArray(entry)) return entry.map(normalize);
    const record = entry as Record<string, unknown>;
    const normalized: Record<string, unknown> = {};
    for (const key of Object.keys(record).sort()) normalized[key] = normalize(record[key]);
    return normalized;
  };
  return JSON.stringify(normalize(value));
}

export function checksum(value: unknown): string {
  return hashString(stableStringify(value)).toString(16).padStart(8, '0');
}

export function deepClone<T>(value: T): T {
  return JSON.parse(JSON.stringify(value)) as T;
}