const
OFFSET = "A".charCodeAt(0),
MOD = "Z".charCodeAt(0) - OFFSET + 1,
AFFINE_A_VALUES = [1,3,5,7,9,11,15,17,19,21,23,25],
AFFINE_B_VALUES = [...Array(26).keys()],
CIPHERED_ALPHA = "WLNCTUZRXHGASDFOQJEBKPVIYM",
VIGENERECIPHER_KEY = "VIGENERECIPHER";

const ceasarCipher = (text, shift) => {
  return text.split("")
             .map(letter =>
               String.fromCharCode(
                 ((letter.charCodeAt(0) + (OFFSET + shift)) % MOD) + OFFSET))
             .join("");
};

const ceasarDecipher = (text, shift) => {
  return ceasarCipher(text, -shift);
};

const ceasarAnalysis = text => {
  for (let i = 0; i < MOD - 1; i++) {
    console.log(ceasarDecipher(text, i));
  }
}

const affineCipher = (text, a, b) => {
  return text.split("")
             .map(letter =>
             String.fromCharCode((((a * (letter.charCodeAt(0) - OFFSET) + b) % MOD) + OFFSET)))
             .join("");
}

const affineDecipher = (text, a, b) => {
  let aInv = 0, flag = 0;
  for (let i = 0; i < MOD; i++) {
    flag = (a * i) % MOD;
    if (flag === 1) {
      aInv = i;
    }
  }
  return text.split("")
             .map(letter =>
             String.fromCharCode((((aInv * (letter.charCodeAt(0) + OFFSET - b)) % MOD) + OFFSET)))
             .join("");
}

const affineAnalysis = text => {
  let i = 0;
  AFFINE_A_VALUES.forEach(a => {
    AFFINE_B_VALUES.forEach(b => {
      console.log(affineDecipher(text, a, b));
      i++;
    });
  });
  console.log(i); // => 312 total
}

const substitutionCipher = (key, text) => {
  let result = "";
  let keySpace = key.split("").map(c => c);
  return text.split("")
             .map(letter =>
               {
                 let index = letter.charCodeAt(0) - OFFSET;
                 if (index > keySpace.length || index < 0) {
                   return letter;
                 } else {
                   return keySpace[index];
                 }
               })
             .join("");
};

const substitutionDecipher = (key, text) => {
  return text.split("")
             .map(letter =>
               {
                 let index = key.indexOf(letter);
                 let ascii = index + 65;
                 if (ascii < 65 || ascii > 90) {
                   return letter;
                 } else {
                   return String.fromCharCode(ascii);
                 }
               })
             .join("");
};

const vigenereCipher = (key, text) => {
  let j = 0;
  return text.split("")
             .map(letter =>
               {
                 let ascii = letter.charCodeAt(0);
                 if (ascii < 65 || ascii > 90) {
                   return letter;
                 } else {
                   let val = (ascii + key.charCodeAt(j) - 2 * OFFSET) % MOD + OFFSET;
                   j = ++j % key.length;
                   return String.fromCharCode(val);
                 }
               })
             .join("");
}

const vigenereDecipher = (key, text) => {
  let j = 0;
  return text.split("")
             .map(letter =>
               {
                 let ascii = letter.charCodeAt(0);
                 if (ascii < 65 || ascii > 90) {
                   return letter;
                 } else {
                   let val = (ascii - key.charCodeAt(j) + MOD) % MOD + OFFSET;
                   j = ++j % key.length;
                   return String.fromCharCode(val);
                 }
               })
             .join("");
}

console.log(ceasarCipher("KRYPTOGRAFIE", 3)); // => NUBSWRJUDILH
console.log(ceasarDecipher("NUBSWRJUDILH", 3)); // => KRYPTOGRAFIE
// ceasarAnalysis("NUBSWRJUDILH");

console.log(affineCipher("THEINITIAL", 5, 9)); // => ASDXWXAXJM
console.log(affineDecipher("ASDXWXAXJM", 5, 9)); // => THEINITIAL
// affineAnalysis("ASDXWXAXJM");

console.log(substitutionCipher(CIPHERED_ALPHA, "MESSAGE")); // => STEEWZT
console.log(substitutionDecipher(CIPHERED_ALPHA, "STEEWZT")); // => MESSAGE

console.log(vigenereCipher(VIGENERECIPHER_KEY, "KRYPTOGRAFIE")); // => FZETGSXVCNXL
console.log(vigenereDecipher(VIGENERECIPHER_KEY, "FZETGSXVCNXL")); // => KRYPTOGRAFIE