package com.hfkj.channel.weixin.utils;

import com.hfkj.channel.weixin.entity.WechatPayReturnParam;
import com.hfkj.channel.weixin.entity.WechatReturn;
import org.apache.commons.lang3.StringUtils;
import org.dom4j.DocumentException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.SAXException;

import javax.xml.parsers.ParserConfigurationException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;

/**
 *
 * @Title:
 * @Description: 微信支付签名工具类
 * @author: 魏真峰
 * @param:
 * @return:
 * @throws
 */
public class SignatureUtil {

	private static Logger logger = LoggerFactory.getLogger(SignatureUtil.class);

	/**
	 * 获取随机字符串
	 * @return	随机字符串
	 */
	public static String createNonceStr(){
		String sl = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
		StringBuilder sb = new StringBuilder();
		for(int i = 0 ; i < 16 ; i ++){
			sb.append(sl.charAt(new Random().nextInt(sl.length())));
		}
		return sb.toString();
	}

	/**
	 * 将字节数组转换为十六进制字符串
	 * @param byteArray
	 * @return
	 */
	private static String byteToStr(byte[] byteArray) {
		String strDigest = "";
		for (int i = 0; i < byteArray.length; i++) {
			strDigest += byteToHexStr(byteArray[i]);
		}
		return strDigest;
	}

	/**
	 * 将字节转换为十六进制字符串
	 *
	 * @param mByte
	 * @return
	 */
	private static String byteToHexStr(byte mByte) {
		char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
		char[] tempArr = new char[2];
		tempArr[0] = Digit[(mByte >>> 4) & 0X0F];
		tempArr[1] = Digit[mByte & 0X0F];
		return new String(tempArr);
	}

	/**
	 * 获取签名
	 *
	 * @param o
	 *            待加密的对象 该处仅限于Class
	 * @return
	 */
	public static String createSign(Object o, String apiKey, String encoding) {
		String result = notSignParams(o, apiKey);
		result = MD5Util.MD5Encode(result, encoding).toUpperCase();
		return result;
	}

	/**
	 * 签名算法
	 *
	 * @param o
	 *            要参与签名的数据对象
	 * @param apiKey
	 *            API密匙
	 * @return 签名
	 * @throws IllegalAccessException
	 */
	public static String notSignParams(Object o, String apiKey) {
		ArrayList<String> list = new ArrayList<>();
		String result = "";
		try {
			Class<?> cls = o.getClass();
			Field[] fields = cls.getDeclaredFields();
			list = getFieldList(fields, o);
			Field[] superFields = cls.getSuperclass().getDeclaredFields(); // 获取父类的私有属性
			list.addAll(getFieldList(superFields, o));
			int size = list.size();
			String[] arrayToSort = list.toArray(new String[size]);
			Arrays.sort(arrayToSort, String.CASE_INSENSITIVE_ORDER); // 严格按字母表顺序排序
			StringBuilder sb = new StringBuilder();
			for (int i = 0; i < size; i++) {
				sb.append(arrayToSort[i]);
			}
			result = sb.toString();
			if (apiKey != null && !"".equals(apiKey)) {
				result += "key=" + apiKey;
			} else {
				result = result.substring(0, result.lastIndexOf("&"));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 将字段集合方法转换
	 *
	 * @param array
	 * @param object
	 * @return
	 * @throws IllegalArgumentException
	 * @throws IllegalAccessException
	 */
	private static ArrayList<String> getFieldList(Field[] array, Object object)
			throws IllegalArgumentException, IllegalAccessException {
		ArrayList<String> list = new ArrayList<String>();
		for (Field f : array) {
			f.setAccessible(true);
			if (f.get(object) != null && f.get(object) != "" && !f.getName().equals("serialVersionUID")
					&& !f.getName().equals("sign")) {
				if (f.getName().equals("packageStr")) {
					list.add("package" + "=" + f.get(object) + "&");
				} else {
					list.add(f.getName() + "=" + f.get(object) + "&");
				}
			}
		}
		return list;
	}

	/**
	 * 通过Map<String,Object>中的所有元素参与签名
	 *
	 * @param map
	 *            待参与签名的map集合
	 * @params apikey apikey中 如果为空则不参与签名，如果不为空则参与签名
	 * @return
	 */
	public static String createSign(Map<Object, Object> map, String apiKey, String characterEncoding) {
		String result = notSignParams(map, apiKey);
		result = MD5Util.MD5Encode(result, characterEncoding).toUpperCase();
		logger.debug("sign result {}", result);
		return result;
	}

	/**
	 * 通过Map<SortedMap,Object>中的所有元素参与签名
	 *
	 * @param map
	 *            待参与签名的map集合
	 * @params apikey apikey中 如果为空则不参与签名，如果不为空则参与签名
	 * @return
	 */
	public static String createSign(SortedMap<Object, Object> map, String apiKey, String characterEncoding) {
		String result = notSignParams(map, apiKey);
		result = MD5Util.MD5Encode(result, characterEncoding).toUpperCase();
		logger.debug("sign result {}", result);
		return result;
	}

	/**
	 * 通过Map<SortedMap,Object>中的所有元素参与签名
	 *
	 * @param map
	 *            待参与签名的map集合
	 * @params apikey apikey中 如果为空则不参与签名，如果不为空则参与签名
	 * @return
	 */
	public static String createSha1Sign(SortedMap<Object, Object> map, String apiKey, String characterEncoding) {
		String result = notSignParams(map, apiKey);
		MessageDigest md = null;
		try {
			md = MessageDigest.getInstance("SHA-1");
			byte[] digest = md.digest(result.getBytes(characterEncoding));
			result = byteToStr(digest);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 返回未加密的字符串
	 *
	 * @param params
	 * @param apiKey
	 * @return 待加密的字符串
	 */
	private static String notSignParams(SortedMap<Object, Object> params, String apiKey) {
		StringBuffer buffer = new StringBuffer();
		for (Map.Entry<Object, Object> entry : params.entrySet()) {
			if (!org.springframework.util.StringUtils.isEmpty(entry.getValue())) {
				buffer.append(entry.getKey() + "=" + entry.getValue() + "&");
			}
		}
		buffer.append("key=" + apiKey);
		return buffer.toString();
	}

	/**
	 * 返回未加密的字符串
	 *
	 * @param params
	 * @param apiKey
	 * @return 待加密的字符串
	 */
	public static String notSignParams(Map<Object, Object> params, String apiKey) {
		ArrayList<String> list = new ArrayList<>();
		for (Map.Entry<Object, Object> entry : params.entrySet()) {
			if (entry.getValue() != "" && entry.getValue() != null) {
				list.add(entry.getKey() + "=" + entry.getValue() + "&");
			}
		}
		int size = list.size();
		String[] arrayToSort = list.toArray(new String[size]);
		Arrays.sort(arrayToSort, String.CASE_INSENSITIVE_ORDER);
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < size; i++) {
			sb.append(arrayToSort[i]);
		}
		String result = sb.toString();
		if (apiKey != null && !"".equals(apiKey)) {
			result += "key=" + apiKey;
		} else {
			result = result.substring(0, result.lastIndexOf("&"));
		}
		return result;
	}

	/**
	 * 从API返回的XML数据里面重新计算一次签名
	 *
	 * @param responseString
	 *            API返回的XML数据
	 * @param apiKey
	 *            Key
	 * @return 新的签名
	 * @throws ParserConfigurationException
	 * @throws IOException
	 * @throws SAXException
	 */
	public static String reCreateSign(String responseString, String apiKey, String encoding)
			throws IOException, SAXException, ParserConfigurationException {
		Map<String, Object> map = com.hfkj.channel.weixin.utils.XmlUtil.parseXmlToMap(responseString, encoding);
		// 清掉返回数据对象里面的Sign数据（不能把这个数据也加进去进行签名），然后用签名算法进行签名
		map.replace("sign","");
		// 将API返回的数据根据用签名算法进行计算新的签名，用来跟API返回的签名进行比较
		return createSign(map, apiKey, encoding);
	}


	/**
	 * 检验API返回的数据里面的签名是否合法,规则是:按参数名称a-z排序,遇到空值的参数不参加签名
	 *
	 * @param resultXml
	 *            API返回的XML数据字符串
	 * @param apiKey
	 *            Key
	 * @return API签名是否合法
	 * @throws ParserConfigurationException
	 * @throws IOException
	 * @throws SAXException
	 * @throws DocumentException
	 */
	public static boolean checkIsSignValidFromWeiXin(String checktXml, String apiKey, String encoding)
			throws ParserConfigurationException, IOException, SAXException, DocumentException {
		SortedMap<String, String> map = com.hfkj.channel.weixin.utils.XmlUtil.parseXmlToTreeMap(checktXml,encoding);
		String signFromresultXml = (String) map.get("sign");
		WechatReturn wechatReturn = new WechatReturn();
		wechatReturn.setAppid((String) map.get("appid"));
		wechatReturn.setMch_id((String) map.get("mch_id"));
		wechatReturn.setNonce_str((String) map.get("nonce_str"));
		wechatReturn.setPrepay_id((String) map.get("prepay_id"));
		wechatReturn.setResult_code((String) map.get("result_code"));
		wechatReturn.setReturn_code((String) map.get("return_code"));
		wechatReturn.setReturn_msg((String) map.get("return_msg"));
		wechatReturn.setTrade_type((String) map.get("trade_type"));
		if (StringUtils.isEmpty(signFromresultXml)) {
			logger.debug("API返回的数据签名数据不存在");
			return false;
		}
		if(!("SUCCESS".equals(map.get("return_code"))) || !("SUCCESS".equals(map.get("result_code")))){
			logger.debug("返回代码不成功！");
			return false;
		}
		logger.debug("服务器回包里面的签名{}", signFromresultXml);
		// 清掉返回数据对象里面的Sign数据（不能把这个数据也加进去进行签名），然后用签名算法进行签名
		// 将API返回的数据根据用签名算法进行计算新的签名，用来跟API返回的签名进行比较
//		String signForAPIResponse = createSign(wechatReturn, apiKey, encoding);
//		if (!signForAPIResponse.equals(signFromresultXml)) {
//			// 签名验不过，表示这个API返回的数据有可能已经被篡改了
//			logger.debug("API返回的数据签名验证不通过");
//			return false;
//		}
		logger.debug("API返回的数据签名验证通过");
		return true;
	}
     /**
      *
      * @Title: reCheckIsSignValidFromWeiXin
      * @Description: 微信支付异步回调，检验签名是否正确
      * @author: 魏真峰
      * @param: [checktXml, apiKey, encoding]
      * @return: boolean
      * @throws
      */
	public static boolean reCheckIsSignValidFromWeiXin(String checktXml, String apiKey, String encoding)
			throws ParserConfigurationException, IOException, SAXException, DocumentException {
		SortedMap<String, String> map = com.hfkj.channel.weixin.utils.XmlUtil.parseXmlToTreeMap(checktXml,encoding);
		String signFromresultXml = (String) map.get("sign");
		WechatPayReturnParam wechatPayReturnParam = new WechatPayReturnParam();
		wechatPayReturnParam.setAppid((String) map.get("appid"));
		wechatPayReturnParam.setAttach((String) map.get("attach"));
		wechatPayReturnParam.setBank_type((String) map.get("bank_type"));
		wechatPayReturnParam.setCash_fee((String) map.get("cash_fee"));
		wechatPayReturnParam.setFee_type((String) map.get("fee_type"));
		wechatPayReturnParam.setIs_subscribe((String) map.get("is_subscribe"));
		wechatPayReturnParam.setMch_id((String) map.get("mch_id"));
		wechatPayReturnParam.setNonce_str((String) map.get("nonce_str"));
		wechatPayReturnParam.setOpenid((String) map.get("openid"));
		wechatPayReturnParam.setOut_trade_no((String) map.get("out_trade_no"));
		wechatPayReturnParam.setResult_code((String) map.get("result_code"));
		wechatPayReturnParam.setReturn_code((String) map.get("return_code"));
		wechatPayReturnParam.setTime_end((String) map.get("time_end"));
		wechatPayReturnParam.setTotal_fee((String) map.get("total_fee"));
		wechatPayReturnParam.setTrade_type((String) map.get("trade_type"));
		wechatPayReturnParam.setTransaction_id((String) map.get("transaction_id"));
		if (StringUtils.isEmpty(signFromresultXml)) {
			logger.debug("API返回的数据签名数据不存在");
			return false;
		}
		if(!("SUCCESS".equals(map.get("return_code"))) || !("SUCCESS".equals(map.get("result_code")))){
			logger.debug("返回代码不成功！");
			return false;
		}
		logger.debug("服务器回包里面的签名{}", signFromresultXml);
		// 清掉返回数据对象里面的Sign数据（不能把这个数据也加进去进行签名），然后用签名算法进行签名
		// 将API返回的数据根据用签名算法进行计算新的签名，用来跟API返回的签名进行比较
		String signForAPIResponse = createSign(wechatPayReturnParam, apiKey, encoding);
		if (!signForAPIResponse.equals(signFromresultXml)) {
			// 签名验不过，表示这个API返回的数据有可能已经被篡改了
			logger.debug("API返回的数据签名验证不通过");
			return false;
		}
		logger.debug("API返回的数据签名验证通过");
		return true;
	}
}
