// 利用 base64, 浏览器环境自带 btoa / atob 方法
// Node.js 需要引入相关库
const str = "abcdefg";

console.log(btoa(str));
console.log(atob(btoa(str)));

// 凯撒密码
const encodeCaesar = ({str = "", padding = 3}) =>
  !str
    ? str
    : str
        .split("")
        .map((s) => String.fromCharCode(s.charCodeAt() + padding))
        .join("");

const decodeCaesar = ({str = "", padding = 3}) =>
  !str
    ? str
    : str
        .split("")
        .map((s) => String.fromCharCode(s.charCodeAt() - padding))
        .join("");

console.log(encodeCaesar({str: "hello world"}));
console.log(decodeCaesar({str: "khoor#zruog"}));

function encode (str) {
	return btoa(encodeURIComponent(str));
}

function decode (str) {
	return decodeURIComponent(atob(str));
}

function strEncrypt(str) {
  return str.split('').map(s => {
    return String.fromCharCode(s.charCodeAt() + 1)
  }).join('')
}

console.log(strEncrypt('hello world')) // ifmmp!xpsme

//param:   method可选参数：encodeStr(加密)与decodeStr(解密)
var codeStr=(method,str)=>{
    var hit = method=='encodeStr'?'*':'/';
    return [...str].map((item)=>{
        return String.fromCharCode(eval(item.charCodeAt()+hit+10));
    }).join('');
}
console.log(codeStr('encodeStr','SDSAH'));

function encodeStr(str, key) {
  return str
    .split("")
    .map(item => {
      return item.charCodeAt() * key;
    })
    .join("#");
}
function decodeStr(str, key) {
  return str
    .split("#")
    .map(item => {
      return String.fromCharCode(+item / key);
    })
    .join("");
}

console.log(decodeStr(encodeStr("hello world", 665), 665));

// 字符转换加密/解密
function strEnDecrypt(str, method) {
    // 加解密对应不同运算符(默认解密)
    let operator = method === "encrypt" ? "*" : "/";

    return [...str]
        .map((char) => {
        return String.fromCharCode(eval(char.charCodeAt() + operator + 10));
    	})
        .join("");
}
console.log(strEnDecrypt("absgdi", "encrypt"));
console.log(strEnDecrypt("ϊϔѾІϨК", "decrypt"));

//  encodeURIComponent方法
function strEnDecrypt1(str, method) {
    // 0加密 1解密
    if (method === 0) {
        return btoa(encodeURIComponent(str));
    } else if (method === 1) {
        return decodeURIComponent(atob(str));
    } else {
        return "输入参数不正确";
    }
}
console.log(strEnDecrypt1("absgdi", 0));
console.log(strEnDecrypt1("YWJzZ2Rp", 1));

function strEncrypt(str) {
    let timeCon = Date.now().toString().substr(0, 5); // 时间戳转字符串取前五位
    let order = [",", "[", "-", "j", "=", "f", "/", "?", "*", "%"];
    let newStr = "";
    for (let char of [...(str + timeCon)].reverse()) {
        newStr += order[char];
    }
    return newStr;
}
function strDecrypt(str) {
    let pwd = str.slice(5);
    let order = [",", "[", "-", "j", "=", "f", "/", "?", "*", "%"];
    let newStr = "";
    for (let char of [...pwd].reverse()) {
        newStr += order.indexOf(char);
    }
    return newStr;
}
console.log(strEncrypt("2323232"));
console.log(strDecrypt("-fj/[-j-j-j-"));

// XOR加密

// 生成一个随机的 key
// 生成一个随机整数
function getRandomInt(min, max) {
    return Math.floor(Math.random() * (max - min + 1) + min);
}

// 生成一个随机的十六进制数
function getHex() {
    let n = 0;
    for (let i = 4; i > 0; i--) {
        n = getRandomInt(0, 1) << (i - 1 + n);
    }
    return n.toString(16);
}

// 生成一个32位的十六进制值，用作一次性key
function getOTP() {
    const arr = [];
    for (let i = 0; i < 32; i++) {
        arr.push(getHex());
    }
    return arr.join("");
}

// XOR运算
function getXOR(message, key) {
    const arr = [];
    for (let i = 0; i < 32; i++) {
        const m = parseInt(message.substr(i, 1), 16);
        const k = parseInt(key.substr(i, 1), 16);
        arr.push((m ^ k).toString(16));
    }
    return arr.join("");
}

function xorEncrypt(password) {
    const message = md5(password);
    const key = getOTP();
    return getXOR(password, key);
}

console.log(xorEncrypt("1232aewes"));

escape("我是被简单的加密了") // "%u6211%u662F%u88AB%u7B80%u5355%u7684%u52A0%u5BC6%u4E86"

//第8天 写一个加密字符串的方法

function strEncrypt(str) {
  var sault = 3;
  return str
    .split("")
    .map(c => {
      return String.fromCharCode(c.charCodeAt(0) + sault);
    })
    .join("");
}
function strDecrypt(str) {
  var sault = 3;
  return str
    .split("")
    .map(c => {
      return String.fromCharCode(c.charCodeAt(0) - sault);
    })
    .join("");
}

var str = "hello, world";
console.log(strEncrypt(str));
console.log(strDecrypt(strEncrypt(str)));

var str="abcdqwa";
var newStr="";
function encrypt(str){
  for(var i=0;i<str.length;i++){
     newStr+=String.fromCharCode(str[i].charCodeAt()+10);
  };
  return newStr;
};
function decrypt(newStr){
  var char="";
  for(var i=0;i<newStr.length;i++){
     char+=String.fromCharCode(newStr[i].charCodeAt()-10);
  };
  return char;
}

    function fn(str) {
        return str.replace(/\w/g, (s) => {
            var code = s.charCodeAt();
            if (code <= 77) {
                return String.fromCharCode(code + 13);
            } else {
                return String.fromCharCode(code - 13);
            }
        })
    }
    console.log(fn("my family"));//`l YT`\_l

function extend(num, len) {
  let res = `${num}`;
  while (res.length < len) {
    res = "0" + res;
  }
  return res;
}

function random() {
  return Math.floor(Math.random() * 10);
}

function encrypt2(str) {
  return Array.from(str)
    .map((ele) => {
      // 生成随机数，扩展原字符的编码从8至16
      const code = ele.charCodeAt();
      const extendedCode = extend(code, 8);
      const r1 = extendedCode.split("").map((ele) => {
        return random() + ele
      }).join('')

      return r1;
    })
    .map((ele) => {
      // 分成四组,每组四个数字
      const arr = [];

      for (let i = 0; i < ele.length; i = i + 4) {
        const s1 = ele.substr(i, 4);
        arr.push(s1);
      }

      return arr;
    })
    .map((ele) => {
      // 合成最终的字符串
      return ele
        .map((i) => {
          return String.fromCharCode(Number(i) + 33); // 这里33是因为ascii码中0~31是不可显字符，32是空格
        })
        .join("");
    })
    .join("");
}

function decrypt2(str) {
  const arr = [];

  for (let i = 0; i < str.length; i = i + 4) {
    arr.push(str.substr(i, 4));
  }

  return arr.map((ele) => {
    return ele.split("").map((i) => {
      return extend(i.charCodeAt() - 33, 4);
    }).join('');
  }).map((ele) => {
    const targets = []

    for (let i = 1; i < ele.length; i = i+2) {
      targets.push(ele[i])
    }

    return String.fromCharCode(Number(targets.join('')))
  });
}

var encrypted = encrypt2("hello你好");
console.log(encrypted);
console.log(decrypt2(encrypted));

 ή⎣Ꮢ௧௣ࡁᏜѤ⍝ѣ࿠ᯑgល,⎗࿕{вࡖ࿩ᏻ⎒೉ᏹࠥ೺࿼
[ 'h', 'e', 'l', 'l', 'o', '你', '好' ]

ѣࡁ៬⎉ៃ࠭ᐄ࠮ఋ࠷J់ᯓဇ២Яရᾱࠤ⏠⍉Щᾪᑱ఩Aᢼ⎬
[ 'h', 'e', 'l', 'l', 'o', '你', '好' ]

gࡋѐួࡋ௭߲њ⍻ᾝ߼᮳ᐃх࿖ࠫΆఋធ⍩ឨउ᭹⍋①တ
[ 'h', 'e', 'l', 'l', 'o', '你', '好' ]