import com.alibaba.fastjson2.JSONObject;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.google.common.collect.ImmutableMap;
import com.jsowell.JsowellApplication;
import com.jsowell.common.constant.CacheConstants;
import com.jsowell.common.constant.Constants;
import com.jsowell.common.core.domain.ykc.LoginRequestData;
import com.jsowell.common.core.domain.ykc.TransactionRecordsData;
import com.jsowell.common.core.redis.RedisCache;
import com.jsowell.common.enums.ykc.OrderStatusEnum;
import com.jsowell.common.exception.BusinessException;
import com.jsowell.common.util.*;
import com.jsowell.common.util.http.HttpUtils;
import com.jsowell.common.util.id.SnUtils;
import com.jsowell.common.util.id.SnowflakeIdWorker;
import com.jsowell.common.util.ip.AddressUtils;
import com.jsowell.common.util.lianlian.LianLianUtils;
import com.jsowell.netty.command.ykc.IssueQRCodeCommand;
import com.jsowell.netty.command.ykc.ProofreadTimeCommand;
import com.jsowell.netty.handler.HeartbeatRequestHandler;
import com.jsowell.netty.service.yunkuaichong.YKCBusinessService;
import com.jsowell.netty.service.yunkuaichong.YKCPushCommandService;
import com.jsowell.pile.domain.OrderBasicInfo;
import com.jsowell.pile.domain.PileAuthCard;
import com.jsowell.pile.domain.PileBillingDetail;
import com.jsowell.pile.domain.PileBillingTemplate;
import com.jsowell.pile.domain.PileStationInfo;
import com.jsowell.pile.domain.WxpayCallbackRecord;
import com.jsowell.pile.dto.*;
import com.jsowell.pile.mapper.MemberBasicInfoMapper;
import com.jsowell.pile.mapper.PileBillingTemplateMapper;
import com.jsowell.pile.service.IOrderBasicInfoService;
import com.jsowell.pile.service.IPileAuthCardService;
import com.jsowell.pile.service.IPileBasicInfoService;
import com.jsowell.pile.service.IPileBillingTemplateService;
import com.jsowell.pile.service.IPileMsgRecordService;
import com.jsowell.pile.service.IPileStationInfoService;
import com.jsowell.pile.service.SimCardService;
import com.jsowell.pile.service.WechatPayService;
import com.jsowell.pile.service.WxpayCallbackRecordService;
import com.jsowell.pile.vo.web.BillingTemplateVO;
import com.jsowell.pile.vo.web.OrderListVO;
import com.jsowell.pile.vo.web.PileDetailVO;
import com.jsowell.service.MemberService;
import com.jsowell.service.OrderService;
import com.jsowell.service.PileRemoteService;
import com.jsowell.service.PileService;
import com.jsowell.thirdparty.domain.StationInfo;
import com.jsowell.thirdparty.service.LianLianService;
import com.jsowell.wxpay.common.WeChatPayParameter;
import com.jsowell.wxpay.dto.AppletTemplateMessageSendDTO;
import com.jsowell.wxpay.dto.WeChatRefundDTO;
import com.jsowell.wxpay.response.WechatPayRefundRequest;
import com.jsowell.wxpay.service.WxAppletRemoteService;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.compress.utils.Lists;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.util.StopWatch;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

@ActiveProfiles("dev")
@SpringBootTest(classes = JsowellApplication.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@RunWith(SpringRunner.class)
public class SpringBootTestController {

	private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

	@Autowired
	private SnUtils snUtils;

	@Autowired
	private PileService pileService;

	@Autowired
	private YKCPushCommandService ykcPushCommandService;

	@Autowired
	private IPileMsgRecordService pileMsgRecordService;

	@Autowired
	private IPileStationInfoService pileStationInfoService;

	@Autowired
	private YKCPushCommandService ykcPushBusinessService;

	@Autowired
	private HeartbeatRequestHandler heartbeatRequestHandler;

	@Autowired
	private YKCBusinessService ykcBusinessService;

	@Autowired
	private PileBillingTemplateMapper pileBillingTemplateMapper;

	@Autowired
	private PileRemoteService pileRemoteService;

	@Autowired
	private MemberService memberService;

	@Autowired
	private OrderService orderService;

	@Autowired
	private IPileBillingTemplateService pileBillingTemplateService;

	@Autowired
	private MemberBasicInfoMapper memberBasicInfoMapper;

	@Autowired
	private SimCardService simCardService;

	@Autowired
	private IPileBasicInfoService pileBasicInfoService;

	@Autowired
	private WechatPayService wechatPayService;

	@Autowired
	private IOrderBasicInfoService orderBasicInfoService;

	@Autowired
	private WxpayCallbackRecordService wxpayCallbackRecordService;

	@Autowired
	private WxAppletRemoteService wxAppletRemoteService;

	@Autowired
	private RedisCache redisCache;

	@Autowired
	private IPileAuthCardService pileAuthCardService;

	@Autowired
	private LianLianService lianLianService;

	static final String MAC_KEY = "53TtFpc4gdVZbF3x";

	static final String ALGORITHM_MAC = "HmacMD5";

	@Test
	public void testupdateElecAmount() {
		orderBasicInfoService.updateElecAmount();
	}

	@Test
	public void testSelectSomeStatusCardInfo() {
		PileAuthCard pileAuthCard = pileAuthCardService.selectCardInfoByLogicCard("1111111111111111");
		System.out.println(pileAuthCard);
	}

	@Test
	public void testLianLian(){
		// // 获取令牌
		// LianLianGetTokenDTO dto = new LianLianGetTokenDTO();
		// dto.setOperatorId("987654321");
		// dto.setOperatorSecret("1234567890abcdef");
		// String token = lianLianService.getToken(dto);
		// System.out.println("token:" + token);
		//
		//
		// LianLianPushStationInfoDTO dto1 = LianLianPushStationInfoDTO.builder()
		// 		.OperatorID("987654321")
		// 		.DataSecret("1234567890abcdef")
		// 		.DataSecretIV("1234567890abcdef")
		// 		.SigSecret("1234567890abcdef")
		// 		.token(token)
		// 		.stationId(2L)
		//
		// 		.build();
		// lianLianService.pushStationInfo(dto1);

		// 推送订单状态
		// lianLianService.pushConnectorStatus("8800000000000101", "1");

		// 推送订单信息
		// lianLianService.pushOrderInfo("C27680791529");

		// 推送启动充电结果
		// lianLianService.pushStartChargeResult("C27680791529");

		// 推送充电状态
		// lianLianService.pushChargeStatus("C27680791529");

		// 推送停止充电结果
		// lianLianService.pushStopChargeResult("C27680791529");

		// 推送充电订单信息
		lianLianService.pushChargeOrderInfo("C27680791529");
	}


	@Test
	public void testRefundForBalance() {
		BigDecimal refundAmount = new BigDecimal("2");
		// 退款金额 元转分 123
		int refundTotalCents = refundAmount.multiply(new BigDecimal(100)).intValue();

		// 查询用户充值余额订单 过滤掉已经退款的充值订单 refundableOrder
		List<RefundableWxPayOrderData> recordList = Lists.newArrayList();
		// recordList.add(RefundableWxPayOrderData.builder().outTradeNo("1").transactionId("1").payerAmount(new BigDecimal("1000")).refundableAmount(new BigDecimal("0")).build());
		// recordList.add(RefundableWxPayOrderData.builder().outTradeNo("2").transactionId("2").payerAmount(new BigDecimal("1000")).refundableAmount(new BigDecimal("0")).build());
		recordList.add(RefundableWxPayOrderData.builder().outTradeNo("3").transactionId("3").payerAmount(new BigDecimal("500")).refundableAmount(new BigDecimal("300")).build());

		// 也许需要多笔支付订单才够退款
		List<WechatPayRefundRequest> requestList = com.google.common.collect.Lists.newArrayList();
		WechatPayRefundRequest request;
		for (RefundableWxPayOrderData record : recordList) {
			int refundableTotal = record.getRefundableAmount().intValue(); // 该笔支付订单的可退金额，单位分
			int payerTotal = record.getPayerAmount().intValue(); // 该笔支付订单的支付金额，单位分
			// 用户申请退款金额-可退金额
			refundTotalCents = refundTotalCents - refundableTotal; // 123 - 100
			request = new WechatPayRefundRequest();
			request.setTransaction_id(record.getTransactionId()); // 微信支付单号
			request.setOut_trade_no(record.getOutTradeNo()); // 商户订单号
			request.setOut_refund_no(SnowflakeIdWorker.getSnowflakeId()); // 商户退款单号
			request.setNotify_url(WeChatPayParameter.refundNotifyUrl); // 回调接口
			request.setReason("用户余额退款");
			request.setFunds_account("AVAILABLE");
			if (refundTotalCents > 0) {
				// 如果大于0说明，这笔单退完也不够
				WechatPayRefundRequest.Amount amount = new WechatPayRefundRequest.Amount();
				amount.setRefund(refundableTotal); // 退款金额
				amount.setTotal(payerTotal); // 原订单金额
				request.setAmount(amount);
				requestList.add(request);
			} else {
				// 如果小于0，这笔单退一部分
				// 生成退款单号
				WechatPayRefundRequest.Amount amount = new WechatPayRefundRequest.Amount();
				// 部分退
				int i = refundableTotal + refundTotalCents;
				amount.setRefund(i); // 退款金额
				amount.setTotal(payerTotal); // 原订单金额
				request.setAmount(amount);
				requestList.add(request);
				break;
			}
		}

		System.out.println(requestList);
	}

	@Test
	public void testCloseStartFailedOrder() {
		String startTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, DateUtils.addDays(new Date(), -2));
		String endTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, new Date());
		orderBasicInfoService.closeStartFailedOrder(startTime, endTime);
	}

	@Test
	public void testRedisSaveRealTimeData() {
		String pileSn = "88000000000001";
		String connectorCode = "01";
		String orderCode = "88000000000001012211161342359448";

		String pileConnectorCode = pileSn + connectorCode;
		String redisKey = CacheConstants.PILE_REAL_TIME_MONITOR_DATA + pileConnectorCode + "_" + orderCode;

		// for (int i = 0; i < 10; i++) {
		// 	try {
		// 		Thread.sleep(10000);
		// 	} catch (InterruptedException e) {
		// 		e.printStackTrace();
		// 	}
		// 	Date now = new Date();
		// 	redisCache.hset(redisKey, DateUtils.parseDateToStr("yyyy-MM-dd HH:mm:00", now), i + ":" + DateUtils.parseDateToStr("yyyy-MM-dd HH:mm:ss", now));
		// }

		orderBasicInfoService.getChargingRealTimeData(orderCode);
	}

	@Test
	public void testuniformMessageSend() {
		AppletTemplateMessageSendDTO appletTemplateMessageSendDTO = new AppletTemplateMessageSendDTO();
		// String openId = wxAppletRemoteService.getOpenIdByCode("0537u2100jTXsP1Y0Y300j426t47u210");
		// System.out.println("openId:" + openId);

		appletTemplateMessageSendDTO.setTouser("o4REX5MprZfTaLnVNxfdOY-wnwGI"); // openid

		String templateId = "UyBPbADlZfsCj89rh_xvfZGlxTW5J5KURpZtt9CNFrY";
		appletTemplateMessageSendDTO.setTemplate_id(templateId);
		// appletTemplateMessageSendDTO.setPage("跳转的页面");
		Map<String, Object> map = new HashMap<>();
		map.put("amount17", ImmutableMap.of("value", "￥100")); // 结束时间
		map.put("time3", ImmutableMap.of("value", "2022-12-30")); // 结束时间
		map.put("thing7", ImmutableMap.of("value", "thing7")); // 结束原因

		// map.put("thing5", ImmutableMap.of("value", "thing5")); // 结束原因
		// map.put("time2", ImmutableMap.of("value", "time2")); // 结束原因
		appletTemplateMessageSendDTO.setData(map);

		wxAppletRemoteService.uniformMessageSend(appletTemplateMessageSendDTO);
	}

	@Test
	public void testWeChatRefund() {
		WeChatRefundDTO dto = new WeChatRefundDTO();
		dto.setRefundType("2");
		dto.setMemberId("82100864");
		dto.setRefundAmount(new BigDecimal("1.23"));
		orderBasicInfoService.weChatRefund(dto);
	}

	@Test
	public void testSelectBalanceRechargeRecord() {
		List<WxpayCallbackRecord> list = wxpayCallbackRecordService.queryBalanceRechargeRecordOfTheLatestYear("82100864");
		System.out.println(list);
	}

	@Test
	public void testSelectOrderBasicInfoList() {
		QueryOrderDTO orderBasicInfo = new QueryOrderDTO();
		orderBasicInfo.setPileSn("88000000000001");
		orderBasicInfo.setOrderStatus(OrderStatusEnum.IN_THE_CHARGING.getValue());
		List<OrderListVO> orderListVOS = orderBasicInfoService.selectOrderBasicInfoList(orderBasicInfo);
		System.out.println(orderListVOS);
		for (OrderListVO orderListVO : orderListVOS) {
			if (StringUtils.equals(orderListVO.getOrderStatus(), OrderStatusEnum.IN_THE_CHARGING.getValue())) {
				// 修改数据库订单状态
				OrderBasicInfo info = OrderBasicInfo.builder()
						.id(Long.parseLong(orderListVO.getId()))
						.orderStatus(OrderStatusEnum.ABNORMAL.getValue())
						.build();
				orderBasicInfoService.updateOrderBasicInfo(info);
			}
		}
	}

	@Test
	public void testWechatRefund() throws JsonProcessingException {
		WechatPayRefundRequest request = new WechatPayRefundRequest();
		request.setTransaction_id("4200001656202212302746036536"); // 微信支付单号
		request.setOut_trade_no("768677222373363712"); // 商户订单号
		// 生成退款单号
		request.setOut_refund_no(SnowflakeIdWorker.getSnowflakeId()); // 商户退款单号
		request.setNotify_url(WeChatPayParameter.refundNotifyUrl); // 回调接口
		WechatPayRefundRequest.Amount amount = new WechatPayRefundRequest.Amount();
		amount.setRefund(10 * 100); // 退款金额
		amount.setTotal(10 * 100); // 原订单金额
		request.setAmount(amount);
		request.setReason("结算退款");
		request.setFunds_account("AVAILABLE");

		wechatPayService.ApplyForWechatPayRefundV3(request);

		// 退款方法

	}

	@Test
	public void testUpdatePileSimInfo() {
		String pileSn = "88000000000001";
		String iccid = "898604940121C1385725";
		pileBasicInfoService.updatePileSimInfo(pileSn, iccid);
	}

	@Test
	public void testPay() {
		String code = "081zIoGa11GamE0iVVIa1aaJ4G0zIoGE";
		String openId = memberService.getOpenIdByCode(code);
		Map<String, Object> pay = null;
		try {
			WeixinPayDTO dto = new WeixinPayDTO();
			dto.setOpenId(openId);
			dto.setAmount("0.01");
			pay = orderService.weixinPayV3(dto);
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(JSONObject.toJSONString(pay));
	}

	@Test
	public void testMemberRegisterAndLogin() {
		// String phone = "18512341234";
		// String merchantId = "18512341234";
		// String token = memberService.memberRegisterAndLogin(phone, merchantId);
		// System.out.println(token);
		// String memberId = JWTUtils.getMemberId(token);
		// System.out.println(memberId);
	}

	@Test
	public void testMemberBasicInfoMapper() {
		// String memberId = "21772870";
		// BigDecimal principalBalance = new BigDecimal("-10");
		// BigDecimal giftBalance = new BigDecimal("-110");
		// Integer version = 2;
		// int i = memberBasicInfoMapper.updateMemberBalance(memberId, principalBalance, giftBalance, version);
		// if (i == 1) {
		// 	System.out.println("更新余额成功");
		// } else {
		// 	System.out.println("更新余额失败");
		// }
	}

	@Test
	public void testGenerateBillingTemplateMsgBody() {
		String pileSn = "88000000000001";
		// 根据桩号查询计费模板
		BillingTemplateVO billingTemplateVO = pileBillingTemplateService.selectBillingTemplateDetailByPileSn(pileSn);

		byte[] messageBody = pileBillingTemplateService.generateBillingTemplateMsgBody(pileSn, billingTemplateVO);
		System.out.println(BytesUtil.binary(messageBody, 16));
	}

	@Test
	public void testAnalysisPileParameter() {
		BasicPileDTO dto = new BasicPileDTO();
		// 3个都不传的情况
		try {
			System.out.println("3个都不传的情况");
			dto.setPileSn("");
			dto.setConnectorCode("");
			dto.setPileConnectorCode("");
			orderService.analysisPileParameter(dto);
			System.out.println("数据正确");
		} catch (BusinessException e) {
			System.out.println(e.getMessage());
		}
		System.out.println();

		// 只传sn的情况
		try {
			System.out.println("只传sn的情况");
			dto.setConnectorCode("");
			dto.setPileConnectorCode("");
			dto.setPileSn("88000000000001");
			orderService.analysisPileParameter(dto);
			System.out.println("数据正确");
		} catch (BusinessException e) {
			System.out.println(e.getMessage());
		}
		System.out.println();

		//
		try {
			System.out.println("只穿枪口号的情况");
			dto.setConnectorCode("01");
			dto.setPileConnectorCode("");
			dto.setPileSn("");
			orderService.analysisPileParameter(dto);
			System.out.println("数据正确");
		} catch (BusinessException e) {
			System.out.println(e.getMessage());
		}
		System.out.println();

		// 只传充电桩枪口编号的情况
		try {
			System.out.println("只传充电桩枪口编号的情况");
			dto.setPileConnectorCode("8800000000000101");
			dto.setConnectorCode("");
			dto.setPileSn("");
			orderService.analysisPileParameter(dto);
			System.out.println("数据正确");
		} catch (BusinessException e) {
			System.out.println(e.getMessage());
		}

		try {
			System.out.println();
			System.out.println("传充电桩枪sn+枪口号的情况");
			dto.setPileConnectorCode("");
			dto.setConnectorCode("01");
			dto.setPileSn("88000000000001");
			orderService.analysisPileParameter(dto);
			System.out.println("数据正确");
		} catch (BusinessException e) {
			System.out.println(e.getMessage());
		}
	}

	@Test
	public void testImportBillingTemplate() {
		ImportBillingTemplateDTO dto = new ImportBillingTemplateDTO();
		dto.setBillingTemplateId("1");
		// 查询公共计费模板是否存在
		PileBillingTemplate pileBillingTemplate = pileBillingTemplateMapper.selectPileBillingTemplateById(Long.valueOf(dto.getBillingTemplateId()));
		if (pileBillingTemplate == null) {

		}
		List<PileBillingDetail> billingDetailList = pileBillingTemplate.getPileBillingDetailList();
	}

	@Test
	public void testProcess() {
		// 62   68
		String msgString = "680da300000388000000000001010020d06840a40000130000000000000000000000000000000088000000000001010202000000000000000000000000000000000000000000000000000000000000000000001516";
		byte[] msg = BytesUtil.str2Bcd(msgString);
		boolean b = YKCUtils.checkMsg(msg);
		// ykcBusinessService.process(msg, null);
	}

	@Test
	public void testHeartbeat() {
		// heartbeatRequestHandler.updateStatus("88000000000001", "01", "0");

		// heartbeatRequestHandler.updateStatus("88000000000001", "02", "0");
	}

	@Test
	public void testPush() {
		byte[] msg = new byte[]{};
		String pileSn = "88000000000001";
		// ykcPushBusinessService.push(msg, pileSn, YKCFrameTypeCode.READ_REAL_TIME_MONITOR_DATA_CODE);
	}

	@Test
	public void TestMapUtils() {
		String address = "淀山湖镇黄浦江南路278号";
		String areaCode = "320000,320500,320583";
		Map<String, String> longitudeAndLatitude = AddressUtils.getLongitudeAndLatitude(areaCode, address);
		System.out.println(longitudeAndLatitude);
	}

	@Test
	public void testCreatePile() {
		BatchCreatePileDTO dto = BatchCreatePileDTO.builder()
				.merchantId("1")
				.stationId("1")
				.softwareProtocol("1")
				// .connectorNum(1)
				// .num(10)
				// .productionDate(new Date())
				.build();
		pileService.batchCreatePile(dto);
	}

	@Test
	public void testGetIncre() {
		StopWatch stopWatch = new StopWatch();

		// 生成100个
		stopWatch.start("生成100个sn号");
		List<String> list2 = snUtils.generateSN(1);
		stopWatch.stop();
		System.out.println(list2);

		System.out.println(stopWatch.getLastTaskTimeMillis());
	}

	@Test
	public void testDict() {
		String dictValue = DictUtils.getDictValue("query_pile_info", "url");
		String station_type = DictUtils.getDictLabel("station_type", "1");
		System.out.println(station_type);
		System.out.println("123");

	}

	@Test
	public void testSelectByMerchantId() {
		List<PileStationInfo> list = pileStationInfoService.selectStationListByMerchantId(Long.valueOf(Constants.ONE));
		System.out.println(list);
	}

	@Test
	public void testStr2Bcd() {
		String logicCardNum = "00000000";
		byte[] logicCardNumByteArr = BytesUtil.str2Bcd(logicCardNum);
		System.out.println(Arrays.toString(logicCardNumByteArr));
	}

	@Test
	public void testBigDecimalMultiply() {
		BigDecimal a = new BigDecimal("216.5");
		BigDecimal b = new BigDecimal("11.5");

		BigDecimal result = a.multiply(b).setScale(2, BigDecimal.ROUND_HALF_UP);
		System.out.println(result);
	}

	@Test
	public void testRemoteUpdate() {
		ArrayList<String> list = new ArrayList<>();
		list.add("88000000000001");
		pileRemoteService.updateFirmware(list);
	}

	@Test
	public void testGetUserPhoneNum() {
		String code = "0e5394cfa4eb41c6181ed257f2368a86dfe4ebdac0a4fac85df63657637e6cc3";
		wxAppletRemoteService.getMobileNumberByCode(code);
	}

	@Test
	public void testDistance() {
		QueryStationDTO dto = new QueryStationDTO();
		dto.setStationLat("123.2222");
		dto.setStationLng("55.6232");

		// pileStationInfoService.uniAppQueryStationInfos(dto);
	}

	/**
	 * 生成英文字母随机数  RandomStringUtils.randomAlphabetic(10);
	 * 生成数字随机数 RandomStringUtils.randomNumeric(10);
	 * 字母+数字结合  RandomStringUtils.randomAlphanumeric(10);
	 */
	@Test
	public void Test() throws ParseException {
		/*String s = RandomStringUtils.randomAlphanumeric(32);
		System.out.println(s); // PuLe4Tyyg1jSFNPhF5d2Ts9ejRn6E8KQ
		String str = "JS160829";
		System.out.println(Md5Utils.hash(str).toUpperCase(Locale.ROOT));
*/

		Date startTimeDate = sdf.parse("2022-11-26 10:44:11");
		Date endTimeDate = sdf.parse("2022-11-27 12:45:11");

		System.out.println(DateUtils.getDatePoor(endTimeDate, startTimeDate)); // 1天2小时1分钟




		/*String stra = "sp_mchid=1632405339&sub_mchid=1632405339&out_trade_no=1217752501201407033233368318&sp_appid=wxbb3e0d474569481d&sub_appid=wxbb3e0d474569481d" +
				"bbac689f4654b209de4d6944808ec80b";
		System.out.println(Md5Utils.hash(stra).toUpperCase(Locale.ROOT));*/
	}

	@Test
	public void testSimCard() throws ParseException {
		ArrayList<String> list = Lists.newArrayList();
		Collections.addAll(list, "898607B9102090253556", "898607B9102090253560");
		// String s = list.toString().replaceAll("(?:\\[|null|\\]| +)", "");
		// System.out.println(s);
		// List<SimCardVO> simCardVOList = simCardService.selectSimCardInfoByIccId(list);
		// System.out.println(simCardVOList.toString());

		// simCardService.XunZhongSimRenewal(list, 12);
		// System.out.println(s);

		// SimCardVO simCardVO = simCardService.searchByLoop("898607B9102090253556");
		//
		// System.out.println(simCardVO.toString());

		simCardService.WuLianSimRenew(list, 1);


	}

	@Test
	public void testRefund() {
		OrderBasicInfo orderInfo = orderBasicInfoService.getOrderInfoByOrderCode("88000000000001012212171045412218");
		orderInfo.setReason("充电异常中止，急停开入");

		TransactionRecordsData data = TransactionRecordsData.builder()
				.transactionCode("88000000000001012212171045412218")
				.consumptionAmount(String.valueOf(0.00))
				.stopReasonMsg(orderInfo.getReason())
				.totalElectricity("0")
				.sharpUsedElectricity("0")
				.peakUsedElectricity("0")
				.flatUsedElectricity("0")
				.valleyUsedElectricity("0")
				.build();

		orderBasicInfoService.settleOrder(data, orderInfo);
	}


	@Test
	public void testLoginHandler() {
		String msg = "8800000000001001010f63362d333000000000898604b319227036282200";
		byte[] msgBody = BytesUtil.str2Bcd(msg);

		int startIndex = 0;
		int length = 7;

		// 桩编码
		byte[] pileSnByte = BytesUtil.copyBytes(msgBody, startIndex, length);
		String pileSn = BytesUtil.binary(pileSnByte, 16);
		// log.info("桩号：{}", pileSn);


		// 桩类型  0 表示直流桩， 1 表示交流桩
		startIndex += length;
		length = 1;
		byte[] pileTypeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
		String pileType = BytesUtil.bcd2Str(pileTypeByteArr);

		// 充电枪数量
		startIndex += length;
		byte[] connectorNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
		String connectorNum = BytesUtil.bcd2Str(connectorNumByteArr);

		// 通信协议版本  版本号乘 10，v1.0 表示 0x0A
		startIndex += length;
		byte[] communicationVersionByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
		// int i = Integer.parseInt(BytesUtil.bcd2Str(communicationVersionByteArr)); // 0F --> 15
		BigDecimal bigDecimal = new BigDecimal(BytesUtil.bcd2Str(communicationVersionByteArr));
		BigDecimal communicationVersionTemp = bigDecimal.divide(new BigDecimal(10));
		String communicationVersion = "v" + communicationVersionTemp;

		// 程序版本
		startIndex += length;
		length = 8;
		byte[] programVersionByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
		String programVersion = BytesUtil.bcd2Str(programVersionByteArr);

		// 网络连接类型  0x00 SIM 卡  0x01 LAN   0x02 WAN  0x03 其他
		startIndex += length;
		length = 1;
		byte[] internetConnectionTypeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
		String internetConnection = BytesUtil.bcd2Str(internetConnectionTypeByteArr);

		// sim卡
		startIndex += length;
		length = 10;
		byte[] simCardNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
		String iccid = BytesUtil.bin2HexStr(simCardNumByteArr);

		// 运营商  0x00 移动  0x02 电信  0x03 联通  0x04 其他
		startIndex += length;
		length = 1;
		byte[] businessTypeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length);
		String business = BytesUtil.bcd2Str(businessTypeByteArr);

		LoginRequestData loginRequestData = LoginRequestData.builder()
				.pileSn(pileSn)
				.pileType(pileType)
				.connectorNum(connectorNum)
				.communicationVersion(communicationVersion)
				.programVersion(programVersion)
				.internetConnection(internetConnection)
				.iccid(iccid)
				.business(business)
				.build();

		// 结果（默认 0x01:登录失败）
		byte[] flag = Constants.oneByteArray;

		// 通过桩编码SN查询数据库，如果有数据，则登录成功，否则登录失败
		QueryPileDTO dto = new QueryPileDTO();
		dto.setPileSn(pileSn);
		List<PileDetailVO> list = pileBasicInfoService.queryPileInfos(dto);
		if (CollectionUtils.isNotEmpty(list)) {
			flag = Constants.zeroByteArray;
			// 登录成功，保存桩号和channel的关系

			// PileChannelEntity.put(pileSn, channel);
			// 更改桩和该桩下的枪口状态分别为 在线、空闲
			// pileBasicInfoService.updatePileStatus(pileSn, PileStatusEnum.ON_LINE.getValue());
			// pileConnectorInfoService.updateConnectorStatusByPileSn(pileSn, PileConnectorDataBaseStatusEnum.FREE.getValue());

			// 对时
			ProofreadTimeCommand command = ProofreadTimeCommand.builder().pileSn(pileSn).build();
			ykcPushCommandService.pushProofreadTimeCommand(command);

			// 公共方法修改状态
			pileBasicInfoService.updateStatus(BytesUtil.bcd2Str(new byte[]{0x01}), pileSn, null, null, null);


			// 下发二维码
			IssueQRCodeCommand issueQRCodeCommand = IssueQRCodeCommand.builder().pileSn(pileSn).build();
			ykcPushCommandService.pushIssueQRCodeCommand(issueQRCodeCommand);

		}


		// 充电桩使用的sim卡，把信息存库
		if (StringUtils.equals("00", internetConnection)) {
			try {
				pileBasicInfoService.updatePileSimInfo(pileSn, iccid);
			} catch (Exception e) {
				// log.error("更新充电桩sim卡信息失败", e);
				System.out.println(e.getMessage());
			}
		}

		// 保存报文
		String jsonMsg = JSONObject.toJSONString(loginRequestData);
		// pileMsgRecordService.save(pileSn, pileSn, type, jsonMsg, ykcDataProtocol.getHEXString());

		// // 消息体
		// byte[] messageBody = Bytes.concat(pileSnByte, flag);
		// return getResult(ykcDataProtocol, messageBody);
	}

	@Test
	public void testGetMemberToken(){
		String memberId = JWTUtils.getMemberId("eyJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE2NzY1MTY5MzgsImV4cCI6MTY3OTEwODkzOH0.4MwhZIOpnCfQloR7zEm2hwPOh2yyI2qxbBbTcv_SnZ4");
		System.out.println(memberId);
	}

}