#Disclaimer: I did not write this code myself.
# --- POSITONAL MAPPINGS ---
def build_positional_mapping(base)
  digits = "0123456789ABCDEF"[0...base]

  mapping = {}
  index = 0

  ('A'..'Z').each do |letter|
    value = 0
    n = index + base  # Start at "10" in that base

    place = 1
    while n > 0
      digit = n % base
      value += digit * place
      place *= base
      n /= base
    end

    mapping[letter] = value
    index += 1
  end

  mapping
end

# --- BASE CONVERSION ---
def to_base(n, base)
  digits = "0123456789ABCDEF"
  return "0" if n == 0

  result = ""
  while n > 0
    result = digits[n % base] + result
    n /= base
  end

  result
end

# --- DIGITAL REDUCTION ---
def digital_reduction_in_base(number, base)
  digits = "0123456789ABCDEF"

  value = number
  while value >= base
    base_str = to_base(value, base)
    value = base_str.chars.map { |c| digits.index(c) }.sum
  end

  value
end

# --- TIC XENOTATION FUNCTIONS ---
def least_factor(n)
  return n if n <= 3
  return 2 if n % 2 == 0
  return 3 if n % 3 == 0

  i = 5
  while i * i <= n
    return i if n % i == 0
    return i + 2 if n % (i + 2) == 0
    i += 6
  end
  n
end

def factor(n)
  return [] if n < 2
  f = least_factor(n)
  return [n] if f == n
  [f] + factor(n / f)
end

def nth_prime(n)
  primes = []
  num = 2
  while primes.length < n
    primes << num if factor(num) == [num]
    num += 1
  end
  primes[-1]
end

def index_of_prime(p)
  i = 1
  loop do
    return i if nth_prime(i) == p
    i += 1
  end
end

def a2x(n)
  return [''] if n < 2

  factors = factor(n)

  factors.map do |f|
    if f == 2
      ':'
    else
      a2x(index_of_prime(f))
    end
  end
end

def stringify(x)
  if x.is_a?(Array)
    '(' + x.map { |e| stringify(e) }.join + ')'
  else
    x
  end
end

def xenotation(n)
  return '' if n < 2
  a2x(n).map { |e| stringify(e) }.join
end

# --- MAIN LOOP ---
loop do
  puts "Enter a word/number phrase (or 'exit'):"
  input = gets.chomp
  break if input.downcase == 'exit'

  word = input.upcase

  # Build mappings
  base10_map = build_positional_mapping(10)
  base8_map  = build_positional_mapping(8)
  base16_map = build_positional_mapping(16)

  # Compute sums per character, letters via mapping, digits as numeric
  sum10 = word.chars.sum do |c|
    if ('A'..'Z').include?(c)
      base10_map[c]
    elsif ('0'..'9').include?(c)
      c.to_i
    else
      0
    end
  end

  sum8  = word.chars.sum do |c|
    if ('A'..'Z').include?(c)
      base8_map[c]
    elsif ('0'..'9').include?(c)
      c.to_i
    else
      0
    end
  end

  sum16 = word.chars.sum do |c|
    if ('A'..'Z').include?(c)
      base16_map[c]
    elsif ('0'..'9').include?(c)
      c.to_i
    else
      0
    end
  end

  # Output
  puts "\nInput: #{input}"

  # Base 10
  puts "English Gematria Value: #{sum10}"
  puts "Digital Reduction (Base 10): #{digital_reduction_in_base(sum10, 10)}"
  puts "Tic Xenotation (EGV): #{xenotation(sum10)}"

  # Base 8-style
  puts "Hebdomadry Value: #{to_base(sum8, 8)}"
  puts "Digital Reduction (Base 8): #{to_base(digital_reduction_in_base(sum8, 8), 8)}"

  # Base 16
  puts "Hexadecadry Value: #{to_base(sum16, 16)}"
  puts "Digital Reduction (Base 16): #{to_base(digital_reduction_in_base(sum16, 16), 16)}"

  puts
end

puts "Goodbye!"