package com.jsowell.common.util;

import com.google.common.collect.ImmutableMap;
import com.google.common.primitives.Bytes;
import com.jsowell.common.constant.Constants;
import com.jsowell.common.core.domain.ykc.YKCFrameTypeCode;
import com.jsowell.common.enums.ykc.ReturnCodeEnum;
import com.jsowell.common.exception.BusinessException;
import lombok.extern.slf4j.Slf4j;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Map;

@Slf4j
public class YKCUtils {

	private static final BigDecimal multiple = new BigDecimal("100000");

	/**
	 * 校验云快充请求数据格式
	 *
	 * @param msg 请求报文
	 * @return
	 */
	public static boolean checkMsg(byte[] msg) {
		// log.info("checkMsg:{}", BytesUtil.binary(msg, 16));
		// 起始标志
		byte[] head = BytesUtil.copyBytes(msg, 0, 1);
		// 数据长度
		byte[] length = BytesUtil.copyBytes(msg, 1, 1);
		// 序列号域
		byte[] serialNumber = BytesUtil.copyBytes(msg, 2, 2);
		// 加密标志
		byte[] encryptFlag = BytesUtil.copyBytes(msg, 4, 1);
		// 帧类型标志
		byte[] frameType = BytesUtil.copyBytes(msg, 5, 1);
		// 消息体
		byte[] msgBody = BytesUtil.copyBytes(msg, 6, msg.length - 8);
		// 帧校验域
		byte[] crcByte = new byte[]{msg[msg.length - 2], msg[msg.length - 1]};

		//起始位必须是0x68
		if (0x68 != head[0]) {
			log.error("起始位必须是0x68");
			return false;
		}
		// 序列号域+加密标志+帧类型标志+消息体
		byte[] data = Bytes.concat(serialNumber, encryptFlag, frameType, msgBody);
		// 校验长度
		if (data.length != BytesUtil.bytesToIntLittle(length)) {
			log.error("数据长度不正确, 数据长度:{}, 实际长度:{}", BytesUtil.bytesToIntLittle(length), data.length);
			return false;
		}
		// CRC校验 source target
		String sourceCRC = String.format("%04x", BytesUtil.bytesToInt(crcByte, 0));
		String targetCRC = String.format("%04x", CRC16Util.calcCrc16(data));
		String oldTargetCRC = String.format("%04x", CRC16Util.calcCrc16Old(data));
		// 将高低位位置反转，得出新的crc
		String lowString = StringUtils.substring(targetCRC, 0, 2);
		String highString = StringUtils.substring(targetCRC, 2, 4);
		String crc = highString + lowString;
		// 若目标crc和高低位反转前/后的crc都不一致，则校验不通过
		if (sourceCRC.equalsIgnoreCase(targetCRC) || sourceCRC.equalsIgnoreCase(crc)) {
			return true;
		}
		log.error("CRC校验不通过, 源crc:{}, 计算得出crc:{}, 老crc计算:{}, 高低位反转后crc:{}, 帧类型:{}, 帧名称:{},报文：{}, msg:{}"
				, sourceCRC, targetCRC, oldTargetCRC, crc, YKCUtils.frameType2Str(frameType),
				YKCFrameTypeCode.getFrameTypeStr(YKCUtils.frameType2Str(frameType)),
				BytesUtil.binary(msg, 16), Arrays.toString(msg));
		return false;
	}

	/**
	 * 转换电压电流以及起始soc
	 * 精确到小数点后一位；待机置零
	 *
	 * @param bytes
	 * @return
	 */
	public static String convertVoltageCurrent(byte[] bytes) {
		// 转换为int 最后一位是小数位
		int i = BytesUtil.bytesToIntLittle(bytes);
		// 使用BigDecimal
		BigDecimal bigDecimal = new BigDecimal(i);
		BigDecimal divide = bigDecimal.divide(new BigDecimal(10), 1, BigDecimal.ROUND_UP);
		return divide.toString();
	}

	/**
	 * 转换小数点
	 *
	 * @param bytes
	 * @param scale 小数位
	 * @return
	 */
	public static String convertDecimalPoint(byte[] bytes, int scale) {
		// 转换为int 
		int i = BytesUtil.bytesToIntLittle(bytes);
		// 使用BigDecimal
		BigDecimal bigDecimal = new BigDecimal(i);
		BigDecimal divide = bigDecimal.divide(BigDecimal.valueOf(Math.pow(10d, scale)), scale, BigDecimal.ROUND_UP);
		return divide.toString();
	}

	/**
	 * 获取价格byte数组
	 * 价格转换为byte数组
	 * @param price 实际价格，单位元
	 * @param scale 保留小数位
	 * @return
	 */
	public static byte[] getPriceByte(String price, int scale) {
		// 保留小数位 例:保留5位小数，需要乘以10的5次方
		BigDecimal value = BigDecimal.valueOf(Math.pow(10d, scale));
		int i = new BigDecimal(price).multiply(value).intValue();
		return BytesUtil.intToBytesLittle(i, 4);
	}

	/**
	 * byte转帧类型字符串 如："01"--> "0x01"
	 * @param bytes
	 * @return
	 */
	public static String frameType2Str(byte[] bytes) {
		String s = BytesUtil.bin2HexStr(bytes);
		return frameType2Str(s);
	}

	/**
	 *  如："01"--> "0x01"
	 * @param frameType 帧类型
	 * @return
	 */
	public static String frameType2Str(String frameType) {
		return Constants.HEX_PREFIX + frameType;
	}

	public static byte[] frameTypeStr2Bytes(String frameTypeStr) {
		byte[] bytes = BytesUtil.hexString2Bytes(frameTypeStr);
		return bytes;
	}

	/**
	 * 转换温度
	 * BIN 码	1	整形，偏移量-50；待机置零
	 */
	public static String transitionTemperature(byte[] bytes) {
		String s = BytesUtil.binary(bytes, 10);
		int i = Integer.parseInt(s);
		if (i > 0) {
			return String.valueOf(i - 50);
		}
		return "一";
	}

	/**
	 * 解析vin
	 */
	public static String parseVin(byte[] vinCodeByteArr) {
		return BytesUtil.ascii2Str(vinCodeByteArr);
	}

	/**
	 * 解析充电桩连接器编号
	 *
	 * @param pileConnectorCode 充电桩连接器编号
	 * @param totalLength       总长度
	 * @param connectorOffset   连接器编号的偏移量
	 * @return 包含桩编号和连接器编号的映射
	 */
	private static Map<String, String> parsePileConnector(String pileConnectorCode, int totalLength, int connectorOffset) {
		String pileSn = StringUtils.substring(pileConnectorCode, 0, totalLength - 2);
		String connectorCode = StringUtils.substring(pileConnectorCode, connectorOffset);

		return ImmutableMap.of("pileSn", pileSn, "connectorCode", connectorCode);
	}

	/**
	 * 解析充电桩编号
	 *
	 * @param pileConnectorCode 充电桩连接器编号
	 * @return 包含桩编号和连接器编号的映射
	 */
	public static Map<String, String> parsePileConnectorCode(String pileConnectorCode) {
		int length = pileConnectorCode.length();

		// 如果length不等于14, 16, 8, 10, 2, 判断为错误的长度
		if (length != Constants.PILE_CONNECTOR_CODE_LENGTH_FOR_EV
				&& length != Constants.PILE_SN_LENGTH_FOR_EV
				&& length != Constants.PILE_CONNECTOR_CODE_LENGTH_FOR_EBIKE
				&& length != Constants.PILE_SN_LENGTH_FOR_EBIKE
				&& length != 2) {
			throw new BusinessException(ReturnCodeEnum.CODE_DATA_LENGTH_ERROR.getValue(), "Invalid pile connector code length: " + length);
		}

		if (length == Constants.PILE_CONNECTOR_CODE_LENGTH_FOR_EV) {
			// 汽车桩
			return parsePileConnector(pileConnectorCode, Constants.PILE_CONNECTOR_CODE_LENGTH_FOR_EV, pileConnectorCode.length() - 2);
		} else if (length == Constants.PILE_CONNECTOR_CODE_LENGTH_FOR_EBIKE) {
			// 电单车
			return parsePileConnector(pileConnectorCode, Constants.PILE_CONNECTOR_CODE_LENGTH_FOR_EBIKE, pileConnectorCode.length() - 2);
		} else if (length == Constants.PILE_SN_LENGTH_FOR_EV || length == Constants.PILE_SN_LENGTH_FOR_EBIKE) {
			// 充电桩编号
			return ImmutableMap.of("pileSn", pileConnectorCode, "connectorCode", "");
		} else {
			// 枪口号
			return ImmutableMap.of("pileSn", "", "connectorCode", pileConnectorCode);
		}
	}

	/**
	 * 获取pileSn
	 * @param pileConnectorCode 充电桩枪口编号
	 * @return
	 */
	public static String getPileSn(String pileConnectorCode) {
		Map<String, String> map = parsePileConnectorCode(pileConnectorCode);
		return map.get("pileSn");
	}

	/**
	 * 获取枪口号
	 * @param pileConnectorCode 充电桩枪口编号
	 * @return
	 */
	public static String getConnectorCode(String pileConnectorCode) {
		Map<String, String> map = parsePileConnectorCode(pileConnectorCode);
		return map.get("connectorCode");
	}

	public static void main(String[] args) {
		String pileConnectorCode = "8800000000000201";
		// pileConnectorCode = "1327388103";
		String pileSn = YKCUtils.getPileSn(pileConnectorCode);
		System.out.println(pileSn);
		String connectorCode = YKCUtils.getConnectorCode(pileConnectorCode);
		System.out.println(connectorCode);
	}
}