/**
 * Copyright (c) 2015,TravelSky. 
 * All Rights Reserved.
 * TravelSky CONFIDENTIAL
 * 
 * Project Name:ShoppinguiOnlineScript
 * Package Name:com.travelsky.shoppingui.utils
 * File Name:JavaScriptUtil.java
 * Date:2015年6月8日 下午2:35:12
 * 
 */
package com.ruoyi.web.controller.tool;


import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.RandomUtils;

import java.util.Formatter;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.StringTokenizer;


/**
 * JavaScript工具类。
 * 
 * @author Michael J Chane
 * @version $Revision: 1.2 $ $Date: 2009/09/10 15:08:30 $
 */
public final class JavaScriptUtil {

  /**
   * 特殊字符
   */
  private static final String SPECIAL_CHARACTERS = "\n\r\f\'\"\\";

  /**
   * 特殊字符-转义字符的映射
   */
  private static final Properties ESCAPE_MAP = new Properties();
  static {
    ESCAPE_MAP.put("\n", "\\n");
    ESCAPE_MAP.put("\r", "\\r");
    ESCAPE_MAP.put("\f", "\\f");
    ESCAPE_MAP.put("\'", "\\\'");
    ESCAPE_MAP.put("\"", "\\\"");
    ESCAPE_MAP.put("\\", "\\\\");
  }

  /**
   * 不需要实例化
   */
  private JavaScriptUtil() {
  }

  /**
   * 对JavaScript字符串内部的文本进行转义操作，避免字符串内的特殊字符影响JavaScript代码的执行。
   * 
   * @param text
   *          要转义的字符串文本
   * @return 转义后的字符串文本
   */
  public static String escapeInStringLiterals(CharSequence text) {
    // 对null返回空白字符串
    if (text == null) {
      return "";
    }

    // 字符串缓冲
    StringBuilder buff = new StringBuilder(text.length() + 16);
    // 以特殊字符为分隔符，将文本分段（含特殊字符）
    StringTokenizer st = new StringTokenizer(text.toString(),
        SPECIAL_CHARACTERS, true);

    while (st.hasMoreTokens()) {
      // 当前片段
      String token = st.nextToken();
      // 如果是特殊字符则转义，否则返回本身
      buff.append(ESCAPE_MAP.getProperty(token, token));
    }

    return buff.toString();
  }

  /**
   * 将指定的JavaScript代码进行混淆。
   * 
   * @param script
   *          指定的JavaScript代码
   * @return 混淆后的JavaScript代码
   */
  public static String obfuscateScript(CharSequence script) {
    if (script == null) {
      return "";
    }

    // String.fromCharCode中参数最大个数
    final int stringFromCharCodeLimit = 100;
    // 每行的参数个数
    final int parametersPerLine = 10;
    // 使用xor函数的比例
    final float xorRate = 0.1f;
    // 字符缓冲
    StringBuilder buff = new StringBuilder(script.length() * 10 + 500);
    // 格式化输出到字符串缓冲
    Formatter formatter = new Formatter(buff);

    // 输出String.fromCharCode的别名定义，并返回其别名
    String stringFromCharCode = stringFromCharCode(formatter);
    // 输出xor函数，并返回函数名列表及对应的xor阈值
    Map<String, Integer> xorFunctions = xorFunctions(formatter);
    // xor函数名称
    String[] xorFuncNames = xorFunctions.keySet().toArray(new String[0]);

    // eval函数开始，其中第一个使用String.fromCharCode(32)即空格
    formatter.format("/*%2$s*/\\u0065\\u0076\\u0061\\u006c/*%3$s*/(%1$s(32",
                     formatArguments(3, stringFromCharCode));

    // 遍历代码中的所有字符
    for (int i = 0; i < script.length(); i++) {
      // 当前字符
      int code = script.charAt(i);

      if (i % stringFromCharCodeLimit == 0) {
        // 结束旧的String.fromCharCode，
        formatter.format(")%n");
        // 开始新的String.fromCharCode
        formatter.format("+/*%2$s*/%1$s(", formatArguments(2,
                                                           stringFromCharCode));
      } else {
        // 一般的String.fromCharCode参数之间使用逗号分隔
        buff.append(",");
        if (i % parametersPerLine == 0) {
          // 当前字符结束后需要换行
          formatter.format("%n");
        }
      }

      // 根据xorRate确定的比例，输出当前字符参数
      if (RandomUtils.nextFloat() < xorRate) {
        // 使用xor参数的名称
        String xorFunc = xorFuncNames[i % xorFuncNames.length];
        // 对应的异或计算阈值
        int xor = xorFunctions.get(xorFunc);
        // 进行过异或计算后的结果
        int xorCode = code ^ xor;
        // 输出函数调用
        formatter.format("%1$s(", xorFunc);
        // 输出函数参数
        formatter.format(numberFormat(i), xorCode);
        // 调用结束
        buff.append(")");
      } else {
        // 正常输出
        formatter.format(numberFormat(i), code);
      }
    }

    // 最后一个String.fromCharCode和eval函数的结尾
    formatter.format("/*%1$s%2$s*/));/*%3$s*/%n", formatArguments(3));

    // 返回混淆代码
    return buff.toString();
  }

  /**
   * 输出String.fromCharCode的别名定义，并返回其别名。
   * 
   * @param formatter
   *          格式化输出
   * @return String.fromCharCode别名
   */
  private static String stringFromCharCode(Formatter formatter) {
    String stringFromCharCode = "__" + randomAlphanumeric(3, 10);
    formatter
        .format("/*%2$s*/var/*%3$s*/%1$s/*%4$s*/=\\u0053\\u0074\\u0072\\u0069\\u006e\\u0067%n/*%5$s*/./*%6$s*/\\u0066r\\u006fm\\u0043ha\\u0072C\\u006fde/*%7$s*/;%n",
                formatArguments(7, stringFromCharCode));
    return stringFromCharCode;
  }

  /**
   * 输出xor函数，并返回函数名列表及对应的xor阈值。
   * 
   * @param formatter
   *          格式化输出
   * @return xor函数名列表及对应的xor阈值
   */
  private static Map<String, Integer> xorFunctions(Formatter formatter) {
    int[] xorArray = new int[5];
    for (int i = 0; i < xorArray.length; i++) {
      xorArray[i] = RandomUtils.nextInt();
    }
    String xorArrayName = "_x_" + randomAlphanumeric(3);
    formatter.format("var/*%2$s*/%1$s = [/*%3$s*/",
                     formatArguments(3, xorArrayName));
    for (int i = 0; i < xorArray.length; i++) {
      formatter.format("%d,", xorArray[i]);
    }
    formatter.format("/*%s*/];//%s%n", formatArguments(2));

    Map<String, Integer> functions = new HashMap<String, Integer>();
    for (int i = 0; i < xorArray.length; i++) {
      String func = "_$" + randomAlphanumeric(3, 5);
      formatter.format("var/*%2$s*/%1$s/*%3$s*/=/*%4$s*/function(/*%5$s*/){%n",
                       formatArguments(5, func));
      formatter.format("/*%1$s*/return/*%2$s*/arguments[/*%3$s*/0]^/*%4$s*/%n",
                       formatArguments(4));
      formatter.format("/*%3$s*/%1$s[/*%4$s*/%2$d];/*%5$s*/}/*%6$s*/;%n",
                       formatArguments(6, xorArrayName, i));
      functions.put(func, xorArray[i]);
    }
    return functions;
  }

  /**
   * 获取格式化输出参数。
   * 
   * @param count
   *          参数个数
   * @param firstFixedParameters
   *          最初的固定参数
   * @return 根据给定的参数个数，在最初的固定参数后生成随机字符串作为格式化输出参数
   */
  private static Object[] formatArguments(int count,
                                          Object... firstFixedParameters) {
    if (count < firstFixedParameters.length) {
      throw new IllegalArgumentException("length < codes.length");
    }
    Object[] args = new Object[count];
    System.arraycopy(firstFixedParameters,
                     0,
                     args,
                     0,
                     firstFixedParameters.length);
    for (int i = firstFixedParameters.length; i < args.length; i++) {
      args[i] = randomAlphanumeric(5, 20);
    }
    return args;
  }

  /**
   * 生成由字母及数字组成的随机字符串。
   * 
   * @param length
   *          随机字符串长度
   * @return 由字母及数字组成的随机字符串
   */
  private static String randomAlphanumeric(int length) {
    return randomAlphanumeric(length, length);
  }

  /**
   * 生成由字母及数字组成的随机字符串。
   * 
   * @param minLength
   *          随机字符串最小长度
   * @param maxLength
   *          随机字符串最大长度
   * @return 由字母及数字组成的随机字符串
   */
  private static String randomAlphanumeric(int minLength, int maxLength) {
    if (minLength <= 0) {
      throw new IllegalArgumentException("minLength <= 0");
    }
    if (maxLength <= 0) {
      throw new IllegalArgumentException("maxLength <= 0");
    }
    if (minLength > maxLength) {
      throw new IllegalArgumentException("minLength > maxLength");
    } else if (minLength == maxLength) {
      return RandomStringUtils.randomAlphanumeric(minLength);
    } else {
      int length = minLength + RandomUtils.nextInt();
      return RandomStringUtils.randomAlphanumeric(length);
    }
  }

  /**
   * 随机的格式化输出格式。
   * 
   * @param seed
   *          随机种子
   * @return 随机的格式化输出格式
   */
  private static String numberFormat(int seed) {
    int rnd = RandomUtils.nextInt();
    switch (rnd % 17) {
      case 0:
        return "0x%x";
      case 1:
        return String.format("-1-~/*%s*/(0x%%x^0)", randomAlphanumeric(2, 5));
      case 2:
        return String.format("%%d%d/0xA", RandomUtils.nextInt());
      case 3:
        return "Math.abs(%d)&-1";
      case 4:
        return "0%o";
      case 5:
        return "%d&(-1^0x00)";
      case 6:
        return "0x0|0x%x";
      case 7:
        return String.format("~/*%s*/~/*%s*/%%d", formatArguments(2));
      case 8:
        return String.format("~(0x%%x^/*%s*/-1)", randomAlphanumeric(2, 5));
      case 9:
        return String.format("0x%%x%d%d/0400",
                             RandomUtils.nextInt(),
                             RandomUtils.nextInt());
      case 10:
        return String.format("0x%%x%d%d>>/*%s*/4>>4",
                             formatArguments(3,
                                             RandomUtils.nextInt(),
                                             RandomUtils.nextInt()));
      case 11:
        return String.format("%%d/*%s*/", randomAlphanumeric(2));
      default:
        return "%d";
    }
  }
}