/**
 * @description - The affine cipher is a type of monoalphabetic substitution cipher, where each letter in an alphabet is mapped to its numeric equivalent, encrypted using a simple mathematical function, and converted back to a letter
 * @see - [wiki](https://en.wikipedia.org/wiki/Affine_cipher)
 */

import { CoPrimeCheck } from '../Maths/CoPrimeCheck'
// Default key for Affine Cipher
const key = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

/**
 * Fix result for negative value in modulas equation
 * @param {Number} n - Constant number
 * @param {Number} m - Modulos value
 * @return {Number} Return n mod m
 */
function mod(n, m) {
  return ((n % m) + m) % m
}

/**
 * Modular multiplicative inverse
 * @param {Number} a - A coefficient
 * @param {Number} m - Modulos value
 * @return {Number} Return modular multiplicative inverse of coefficient a and modulos m
 */
function inverseMod(a, m) {
  for (let x = 1; x < m; x++) {
    if (mod(a * x, m) === 1) return x
  }
}

/**
 * Argument validation
 * @param {String} str - String to be checked
 * @param {Number} a - A coefficient to be checked
 * @param {Number} b - B coefficient to be checked
 * @return {Boolean} Result of the checking
 */
function isCorrectFormat(str, a, b) {
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw new TypeError('Coefficient a, b should be number')
  }

  if (typeof str !== 'string') {
    throw new TypeError('Argument str should be String')
  }

  if (!CoPrimeCheck(a, 26)) {
    throw new Error(a + ' is not coprime of 26')
  }

  return true
}

/**
 * Find character index based on ASCII order
 * @param {String} char - Character index to be found
 * @return {Boolean} Character index
 */
function findCharIndex(char) {
  return char.toUpperCase().charCodeAt(0) - 'A'.charCodeAt(0)
}

/**
 * Encrypt a Affine Cipher
 * @param {String} str - String to be encrypted
 * @param {Number} a - A coefficient
 * @param {Number} b - B coefficient
 * @return {String} result - Encrypted string
 */

function encrypt(str, a, b) {
  let result = ''
  if (isCorrectFormat(str, a, b)) {
    for (let x = 0; x < str.length; x++) {
      const charIndex = findCharIndex(str[x])
      if (charIndex < 0) result += '-1' + ' '
      else result += key.charAt(mod(a * charIndex + b, 26)) + ' '
    }
  }
  return result.trim()
}

/**
 * Decrypt a Affine Cipher
 * @param {String} str - String to be decrypted
 * @param {Number} a - A coefficient
 * @param {Number} b - B coefficient
 * @return {String} result - Decrypted string
 */
function decrypt(str, a, b) {
  let result = ''
  if (isCorrectFormat(str, a, b)) {
    str = str.split(' ')
    for (let x = 0; x < str.length; x++) {
      if (str[x] === '-1') result += ' '
      else {
        const charIndex = findCharIndex(str[x])
        result += key[mod(inverseMod(a, 26) * (charIndex - b), 26)]
      }
    }
    return result
  }
}
export { encrypt, decrypt }