package com.ruoyi.order.controller;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;


import com.alibaba.fastjson2.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.ruoyi.account.api.feignClient.AppCouponClient;
import com.ruoyi.account.api.feignClient.AppUserAddressClient;
import com.ruoyi.account.api.feignClient.AppUserClient;
import com.ruoyi.account.api.model.TAppUserAddress;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.dto.ExchangeDto;
import com.ruoyi.common.core.utils.OrderCodeUtil;
import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.page.PageInfo;
import com.ruoyi.common.log.annotation.Log;
import com.ruoyi.common.log.enums.BusinessType;
import com.ruoyi.common.log.enums.OperatorType;
import com.ruoyi.common.security.annotation.Logical;
import com.ruoyi.common.security.annotation.RequiresPermissions;
import com.ruoyi.common.security.service.TokenService;
import com.ruoyi.order.api.model.TChargingOrderRefund;
import com.ruoyi.order.api.model.TExchangeOrder;
import com.ruoyi.order.api.model.TShoppingOrder;
import com.ruoyi.order.api.model.TShoppingOrderRefund;
import com.ruoyi.order.api.query.ShoppingOrderQuery;
import com.ruoyi.order.dto.*;
import com.ruoyi.order.service.TShoppingOrderRefundService;
import com.ruoyi.order.service.TShoppingOrderService;
import com.ruoyi.other.api.domain.TCoupon;
import com.ruoyi.other.api.domain.TGoods;
import com.ruoyi.other.api.feignClient.CouponClient;
import com.ruoyi.other.api.feignClient.GoodsClient;
import com.ruoyi.payment.api.feignClient.AliPaymentClient;
import com.ruoyi.payment.api.feignClient.WxPaymentClient;
import com.ruoyi.payment.api.model.RefundReq;
import com.ruoyi.payment.api.model.RefundResp;
import com.ruoyi.payment.api.model.WxPaymentRefundModel;
import com.ruoyi.payment.api.vo.WxRefundNotifyResp;
import com.ruoyi.system.api.domain.SysUser;
import com.ruoyi.system.api.feignClient.SysUserClient;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.time.format.DateTimeFormatter;
import java.util.*;

/**
 * <p>
 * 前端控制器
 * </p>
 *
 * @author xiaochen
 * @since 2024-08-07
 */
@Api(tags = "购物订单")
@RestController
@RequestMapping("/t-shopping-order")
public class TShoppingOrderController {
	
	@Resource
	private TShoppingOrderService shoppingOrderService;
	@Resource
	private AppUserClient appUserClient;
	@Resource
	private GoodsClient goodsClient;
	@Resource
	private CouponClient couponClient;
	@Resource
	private TokenService tokenService;
	@Resource
	private AliPaymentClient aliPaymentClient;
	@Resource
	private WxPaymentClient wxPaymentClient;
	@Resource
	private AppCouponClient appCouponClient;
	@Resource
	private SysUserClient sysUserClient;
	@Resource
	private TShoppingOrderRefundService shoppingOrderRefundService;
	@Resource
	private AppUserAddressClient appUserAddressClient;
	
	
	
	
	
	/**
	 * 远程管理后台取消订单后退款回调
	 */
	@ResponseBody
	@PostMapping(value = "/shoppingOrderWxRefund")
	public void shoppingOrderWxRefund(@RequestParam("out_trade_no") String out_refund_no,
													@RequestParam("out_trade_no") String refund_id,
													@RequestParam("out_trade_no") String tradeState,
													@RequestParam("out_trade_no") String success_time){
		if("SUCCESS".equals(tradeState)){
			TShoppingOrderRefund one = shoppingOrderRefundService.getOne(new LambdaQueryWrapper<TShoppingOrderRefund>().eq(TShoppingOrderRefund::getRefundCode, out_refund_no));
			one.setRefundSerialNumber(refund_id);
			one.setRefundStatus(2);
			one.setRefundTime(LocalDateTime.parse(success_time, DateTimeFormatter.ofPattern("yyyy-MM-DDTHH:mm:ss+TIMEZONE")));
			shoppingOrderRefundService.updateById(one);
			TShoppingOrder byId = shoppingOrderService.getById(one.getShoppingOrderId());
			byId.setStatus(4);
			shoppingOrderService.updateById(byId);
			if (byId.getAppCouponId() != null) {
				appCouponClient.refund(byId.getAppCouponId().toString());
			}
		}
	}
	
	@RequiresPermissions(value = {"/shoppingOrder"}, logical = Logical.OR)
	@PostMapping("/getShoppingOrderList")
	@ApiOperation(value = "列表查询", tags = {"管理后台-购物订单"})
	public AjaxResult<PageInfo<TShoppingOrder>> getShoppingOrderList(@RequestBody ShoppingOrderQuery query) {
		if (StringUtils.hasLength(query.getPhone())) {
			List<Long> data = appUserClient.getUserIdsByPhone(query.getPhone()).getData();
			if (data.isEmpty()) {
				return AjaxResult.success(new PageInfo<TShoppingOrder>());
			}
			query.setUserIds(data);
		}
		if (StringUtils.hasLength(query.getName())) {
			List<Integer> data = goodsClient.getGoodsIdsByName(query.getName()).getData();
			query.setGoodsIds(data);
			List<Integer> data1 = couponClient.getCouponIdsByName(query.getName()).getData();
			query.setCouponIds(data1);
			if (data.isEmpty() && data1.isEmpty()) {
				return AjaxResult.success(new PageInfo<TShoppingOrder>());
			}
		}
		PageInfo<TShoppingOrder> res = shoppingOrderService.pageList(query);
		return AjaxResult.success(res);
	}
	
	@RequiresPermissions(value = {"/shoppingOrder/deliver_goods"}, logical = Logical.OR)
	@GetMapping("/getShoppingOrderInfoById")
	@ApiOperation(value = "根据订单id查看订单详情", tags = {"管理后台-购物订单"})
	public AjaxResult<TShoppingOrder> getShoppingOrderList(String id) {
		TShoppingOrder byId = shoppingOrderService.getById(id);
		if (byId.getConsignerId() != null) {
			SysUser data = sysUserClient.getSysUser(byId.getConsignerId()).getData();
			if (data != null) {
				byId.setConsignerName(data.getUserName());
			}
		}
		if (byId.getCancellationId() != null) {
			SysUser data = sysUserClient.getSysUser(byId.getCancellationId()).getData();
			if (data != null) {
				byId.setCancellationName(data.getUserName());
			}
		}
		if (byId.getAppUserAddressId() != null) {
			TAppUserAddress data = appUserClient.getAddressById(byId.getAppUserAddressId()).getData();
			if (data != null) {
				byId.setReceivingName(data.getName() + "-" + data.getPhone());
				byId.setReceivingAddress(data.getProvince()+data.getCity()
						+(data.getDistrict()==null?"":data.getDistrict())
						+(data.getAddress()==null?"":data.getAddress())
						+(data.getHouseNumber()==null?"":data.getHouseNumber()));
			}
		}
		if (byId.getOrderType()==1){
			TGoods data = goodsClient.getGoodsById(byId.getGoodsId()).getData();
			if (data!=null){
				byId.setName(data.getName());
			}
		}else {
		 TCoupon data = couponClient.getCouponById1(byId.getCouponId()).getData();
		 if (data!=null){
			 byId.setName(data.getName());
		 }
		}
		return AjaxResult.success(byId);
	}
	
	
	@RequiresPermissions(value = {"/shoppingOrder/del"}, logical = Logical.OR)
	@GetMapping("/deleteShoppingOrder")
	@ApiOperation(value = "批量删除订单", tags = {"管理后台-购物订单"})
	public AjaxResult<TShoppingOrder> deleteShoppingOrder(String ids) {
		shoppingOrderService.removeBatchByIds(Arrays.asList(ids.split(",")));
		return AjaxResult.success();
	}
	
	
	@RequiresPermissions(value = {"/shoppingOrder/cancel"}, logical = Logical.OR)
	@GetMapping("/cancelShoppingOrder")
	@ApiOperation(value = "取消订单", tags = {"管理后台-购物订单"})
	public AjaxResult cancelShoppingOrder(String id) {
		TShoppingOrder byId = shoppingOrderService.getById(id);
		Long userid = tokenService.getLoginUser().getUserid();
		// todo 根据支付方式 取消订单
		byId.setCancellationId(userid);
		byId.setCancellationTime(LocalDateTime.now());
		byId.setStatus(5);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
		TShoppingOrderRefund tShoppingOrderRefund = new TShoppingOrderRefund();
		tShoppingOrderRefund.setPayTime(byId.getPayTime());
		tShoppingOrderRefund.setPayCode(byId.getSerialNumber());
		tShoppingOrderRefund.setPayAmount(byId.getPaymentAmount());
		tShoppingOrderRefund.setPayType(1);
		tShoppingOrderRefund.setShoppingOrderId(byId.getId());
		tShoppingOrderRefund.setRefundAmount(byId.getPaymentAmount());
		tShoppingOrderRefund.setRefundStatus(1);
		tShoppingOrderRefund.setCode("GWF" + sdf.format(new Date()) + Double.valueOf(Math.random() * 1000).intValue());
		tShoppingOrderRefund.setRefundTitle("后台取消订单");
		tShoppingOrderRefund.setRefundContent("后台取消订单");
		tShoppingOrderRefund.setRefundReason("后台取消订单");
		tShoppingOrderRefund.setRefundRemark("全额退款");
		tShoppingOrderRefund.setRefundTotalAmount(byId.getPaymentAmount());
		switch (byId.getPaymentType()) {
			case 1:
				// 微信
				WxPaymentRefundModel wxPaymentRefundModel = new WxPaymentRefundModel();
				wxPaymentRefundModel.setTransaction_id(byId.getSerialNumber());
				wxPaymentRefundModel.setOut_trade_no(byId.getCode());
				wxPaymentRefundModel.setOut_refund_no(OrderCodeUtil.getOrderCode("GWTK"));
				wxPaymentRefundModel.setReason("后台购物订单退款");
				wxPaymentRefundModel.setNotify_url("/payment/wx/refund/notify");
				String string = byId.getPaymentAmount().multiply(new BigDecimal("100")).toString();
				if (string.contains(".")) {
					string = string.substring(0, string.indexOf("."));
				}
				int i = Integer.parseInt(string);
				WxPaymentRefundModel.RefundAmount refundAmount = new WxPaymentRefundModel.RefundAmount();
				refundAmount.setTotal(i);
				refundAmount.setCurrency("CNY");
				refundAmount.setRefund(i);
				wxPaymentRefundModel.setAmount(refundAmount);
				R<Map<String, Object>> stringR = wxPaymentClient.refundOrderR(wxPaymentRefundModel);
				if(200 == stringR.getCode()){
					shoppingOrderRefundService.save(tShoppingOrderRefund);
					//手续费
					Map<String, Object> amount1 = (Map<String, Object>) stringR.getData().get("amount");
					Object refund_fee1 = amount1.get("refund_fee");
					BigDecimal refund_fee = new BigDecimal(null == refund_fee1 ? "0" : refund_fee1.toString()).divide(new BigDecimal(100));
					tShoppingOrderRefund.setRefundFee(refund_fee);
					shoppingOrderRefundService.updateById(tShoppingOrderRefund);
				}
				break;
			case 2:
				// 支付宝
				RefundReq refundReq = new RefundReq();
				refundReq.setOutTradeNo(byId.getSerialNumber());
				String gw = OrderCodeUtil.getOrderCode("GWF");
				refundReq.setOutRequestNo(gw);
				refundReq.setRefundAmount(byId.getPaymentAmount().toString());
				refundReq.setRefundReason("后台购物订单退款");
				RefundResp data = aliPaymentClient.refund(refundReq).getData();
				if (data != null) {
					byId.setStatus(4);
					SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-DDTHH:mm:ss+TIMEZONE");
					TShoppingOrderRefund one = shoppingOrderRefundService.getOne(new LambdaQueryWrapper<TShoppingOrderRefund>().eq(TShoppingOrderRefund::getRefundCode, data.getOutTradeNo()));
					one.setRefundSerialNumber(data.getTradeNo());
					one.setRefundStatus(2);
					one.setRefundTime(LocalDateTime.parse(sdf1.format(new Date()), DateTimeFormatter.ofPattern("yyyy-MM-DDTHH:mm:ss+TIMEZONE")));
					shoppingOrderRefundService.updateById(one);
					if (byId.getAppCouponId() != null) {
						// 退款成功 回退优惠券
						appCouponClient.refund(byId.getAppCouponId().toString());
					}
					byId.setRefundCode(gw);
					byId.setRefundAmount(byId.getPaymentAmount());
					byId.setRefundStatus(2);
					byId.setRefundSerialNumber(data.getTradeNo());
					shoppingOrderService.updateById(byId);
				}
				break;
		}
		shoppingOrderService.updateById(byId);
		return AjaxResult.success();
	}
	
	
	@RequiresPermissions(value = {"/shoppingOrder/deliver_goods"}, logical = Logical.OR)
	@GetMapping("/consignerShoppingOrder")
	@ApiOperation(value = "发货", tags = {"管理后台-购物订单"})
	public AjaxResult consignerShoppingOrder(String id, String companyName, String code) {
		TShoppingOrder byId = shoppingOrderService.getById(id);
		byId.setExpressCompany(companyName);
		byId.setExpressNumber(code);
		Long userid = tokenService.getLoginUser().getUserid();
		byId.setConsignerId(userid);
		byId.setConsignerTime(LocalDateTime.now());
		byId.setStatus(2);
		shoppingOrderService.updateById(byId);
		return AjaxResult.success();
	}
	
	
	
	@GetMapping("/getMyShoppingOrderList")
	@ApiOperation(value = "获取购买订单列表", tags = {"小程序-商城购买订单"})
	public AjaxResult<Map<String, Object>> getMyShoppingOrderList(GetMyShoppingOrderList query) {
		Map<String, Object> list = shoppingOrderService.getMyShoppingOrderList(query);
		return AjaxResult.success(list);
	}
	
	
	
	@GetMapping("/getMyShoppingOrderListNum")
	@ApiOperation(value = "获取购买订单列表数量", tags = {"小程序-商城购买订单"})
	public AjaxResult<Map<String, Object>> getMyShoppingOrderListNum() {
		Long userId = tokenService.getLoginUserApplet().getUserId();
		long dfh = shoppingOrderService.count(new LambdaQueryWrapper<TShoppingOrder>().eq(TShoppingOrder::getDelFlag, 0)
				.eq(TShoppingOrder::getStatus, 1).eq(TShoppingOrder::getAppUserId, userId).eq(TShoppingOrder::getPaymentStatus, 2));
		long dsh = shoppingOrderService.count(new LambdaQueryWrapper<TShoppingOrder>().eq(TShoppingOrder::getDelFlag, 0)
				.eq(TShoppingOrder::getStatus, 2).eq(TShoppingOrder::getAppUserId, userId).eq(TShoppingOrder::getPaymentStatus, 2));
		long ywc = shoppingOrderService.count(new LambdaQueryWrapper<TShoppingOrder>().eq(TShoppingOrder::getDelFlag, 0)
				.eq(TShoppingOrder::getStatus, 3).eq(TShoppingOrder::getAppUserId, userId).eq(TShoppingOrder::getPaymentStatus, 2));
		Map<String, Object> map = new HashMap<>();
		map.put("dfh", dfh);
		map.put("dsh", dsh);
		map.put("ywc", ywc);
		return AjaxResult.success(map);
	}
	
	
	@GetMapping("/getMyShoppingOrderInfo/{id}")
	@ApiOperation(value = "获取购买订单详情", tags = {"管理后台-支付订单-订单信息"})
	public AjaxResult<MyShoppingOrderInfo> getMyShoppingOrderInfo(@PathVariable String id) {
		TShoppingOrder shoppingOrder = shoppingOrderService.getById(id);
		Long userId = tokenService.getLoginUserApplet().getUserId();
		if(!shoppingOrder.getAppUserId().equals(userId)){
			return AjaxResult.error("权限不足");
		}
		MyShoppingOrderInfo info = shoppingOrderService.getMyShoppingOrderInfo(id);
		return AjaxResult.success(info);
	}
	
	
	@GetMapping("/getMyShoppingOrderInfo1/{id}")
	@ApiOperation(value = "获取购买订单详情", tags = {"小程序-商城购买订单"})
	public AjaxResult<MyShoppingOrderInfo> getMyShoppingOrderInfo1(@PathVariable String id) {
		TShoppingOrder shoppingOrder = shoppingOrderService.getById(id);
		Long userId = tokenService.getLoginUserApplet().getUserId();
		if(!shoppingOrder.getAppUserId().equals(userId)){
			return AjaxResult.error("权限不足");
		}
		MyShoppingOrderInfo info = shoppingOrderService.getMyShoppingOrderInfo(id);
		return AjaxResult.success(info);
	}
	
	@Log(title = "【我的】确认收货操作", businessType = BusinessType.UPDATE,operatorType = OperatorType.MOBILE)
	@PutMapping("/confirmReceipt/{id}")
	@ApiOperation(value = "确认收货操作", tags = {"小程序-商城购买订单"})
	public AjaxResult confirmReceipt(@PathVariable String id) {
		TShoppingOrder shoppingOrder = shoppingOrderService.getById(id);
		Long userId = tokenService.getLoginUserApplet().getUserId();
		if(!shoppingOrder.getAppUserId().equals(userId)){
			return AjaxResult.error("权限不足");
		}
		if (shoppingOrder.getStatus() == 3) {
			return AjaxResult.error("不能重复确认收货");
		}
		if (shoppingOrder.getStatus() == 1) {
			return AjaxResult.error("订单还未发货呢");
		}
		if (shoppingOrder.getStatus() == 4) {
			return AjaxResult.error("订单已取消，不允许操作。");
		}
		shoppingOrder.setStatus(3);
		shoppingOrder.setReceivingTime(LocalDateTime.now());
		shoppingOrderService.updateById(shoppingOrder);
		return AjaxResult.success();
	}
	
	
	@Log(title = "【我的】取消订单操作", businessType = BusinessType.UPDATE,operatorType = OperatorType.MOBILE)
	@PutMapping("/cancelOrder/{id}")
	@ApiOperation(value = "取消订单操作", tags = {"小程序-商城购买订单"})
	public AjaxResult cancelOrder(@PathVariable String id) {
		TShoppingOrder shoppingOrder = shoppingOrderService.getById(id);
		Long userId = tokenService.getLoginUserApplet().getUserId();
		if(!shoppingOrder.getAppUserId().equals(userId)){
			return AjaxResult.error("权限不足");
		}
		return shoppingOrderService.cancelOrder(id);
	}
	
	/**
	 * 商城订单取消微信退款回调
	 */
	@PostMapping("/cancelShoppingOrderWxRefund")
	public void cancelShoppingOrderWxRefund(@RequestParam("out_refund_no") String out_refund_no,
	                                        @RequestParam("refund_id") String refund_id,
	                                        @RequestParam("tradeState") String tradeState,
	                                        @RequestParam("success_time") String success_time) {
		shoppingOrderService.cancelShoppingOrderWxRefund(out_refund_no, refund_id, tradeState, success_time);
	}
	
	
	@ResponseBody
	@GetMapping(value = "/getNoInvoicedOrder")
	@ApiOperation(value = "获取未开票的订单数据", tags = {"小程序-充电发票"})
	public AjaxResult<List<MyShoppingOrderList>> getNoInvoicedOrder(GetNoInvoicedOrder query) {
		List<MyShoppingOrderList> list = shoppingOrderService.getNoInvoicedOrder(query);
		return AjaxResult.success(list);
	}

	
	@PostMapping("/create")
	public R<TShoppingOrder> shopCreate(@RequestBody ExchangeDto exchangeDto) {
		TShoppingOrder shoppingOrder = new TShoppingOrder();
		shoppingOrder.setTitle(exchangeDto.getTitle());
		shoppingOrder.setCode(OrderCodeUtil.getOrderCode("GW"));
		shoppingOrder.setAppUserId(exchangeDto.getUserId());
		shoppingOrder.setOrderType(exchangeDto.getGoodType());
		if (exchangeDto.getGoodType() == 1) {
			shoppingOrder.setGoodsId(exchangeDto.getGoodId());
			shoppingOrder.setStatus(1);

		} else {
			shoppingOrder.setCouponId(exchangeDto.getGoodId());
			shoppingOrder.setStatus(3);

		}
		shoppingOrder.setPurchaseQuantity(exchangeDto.getNum());
		shoppingOrder.setAppUserAddressId(exchangeDto.getAddressId());
		shoppingOrder.setOrderAmount(exchangeDto.getOrderPrice());
		if (exchangeDto.getCouponId() != null) {
			shoppingOrder.setAppCouponId(exchangeDto.getCouponId());
		}
		shoppingOrder.setCouponDiscountAmount(exchangeDto.getDiscountPrice());
		shoppingOrder.setVipDiscount(new BigDecimal("0"));
		shoppingOrder.setVipDiscountAmount(exchangeDto.getVipDiscount());
		shoppingOrder.setPaymentAmount(exchangeDto.getPayPrice());
		shoppingOrder.setPaymentStatus(1);
		shoppingOrder.setPaymentType(exchangeDto.getPayMethod());
		shoppingOrder.setRemark(exchangeDto.getRemark());
		shoppingOrder.setPhone(exchangeDto.getPhone());
		shoppingOrder.setCreateTime(LocalDateTime.now());
		shoppingOrder.setDelFlag(false);


		TAppUserAddress data = appUserAddressClient.getAppUserAddressById(exchangeDto.getAddressId()).getData();
		shoppingOrder.setAddressJson(JSON.toJSONString(data));
		shoppingOrderService.save(shoppingOrder);
		
		return R.ok(shoppingOrder);
		
	}
	
	@PostMapping("/callBack")
	public R callBack(@RequestParam("code") String code, @RequestParam("outTradeNo") String outTradeNo) {
		shoppingOrderService.callBack(code, outTradeNo);
		return R.ok();
		
	}
}