package com.ruoyi.order.service.impl;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.account.api.feignClient.AppUserClient;
import com.ruoyi.account.api.model.TAppUser;
import com.ruoyi.account.api.model.TAppUserCar;
import com.ruoyi.chargingPile.api.feignClient.ChargingGunClient;
import com.ruoyi.chargingPile.api.feignClient.SiteClient;
import com.ruoyi.chargingPile.api.dto.GetSiteListDTO;
import com.ruoyi.chargingPile.api.model.Partner;
import com.ruoyi.chargingPile.api.model.Site;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.page.PageInfo;
import com.ruoyi.common.security.service.TokenService;
import com.ruoyi.order.api.model.*;
import com.ruoyi.order.api.query.TOrderInvoiceQuery;
import com.ruoyi.order.api.vo.TOrderEvaluateVO;
import com.ruoyi.order.api.vo.TOrderInvoiceVO;
import com.ruoyi.order.dto.*;
import com.ruoyi.order.mapper.TOrderInvoiceMapper;
import com.ruoyi.order.service.*;
import com.ruoyi.other.api.domain.TCoupon;
import com.ruoyi.other.api.domain.TGoods;
import com.ruoyi.other.api.domain.TInvoiceType;
import com.ruoyi.other.api.feignClient.CouponClient;
import com.ruoyi.other.api.feignClient.GoodsClient;
import com.ruoyi.other.api.feignClient.InvoiceTypeClient;
import com.ruoyi.system.api.feignClient.SysUserClient;
import com.ruoyi.system.api.domain.SysUser;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author xiaochen
 * @since 2024-08-07
 */
@Service
public class TOrderInvoiceServiceImpl extends ServiceImpl<TOrderInvoiceMapper, TOrderInvoice> implements TOrderInvoiceService {
	
	@Resource
	private TokenService tokenService;
	
	@Resource
	private TOrderInvoiceDetailService orderInvoiceDetailService;
	
	@Resource
	private InvoiceTypeClient invoiceTypeClient;
	
	@Resource
	private TChargingOrderService chargingOrderService;
	
	@Resource
	private TShoppingOrderService shoppingOrderService;
	
	@Resource
	private ChargingGunClient chargingGunClient;
	
	@Resource
	private SiteClient siteClient;
	
	@Resource
	private GoodsClient goodsClient;
	
	@Resource
	private CouponClient couponClient;
	@Resource
	private AppUserClient appUserClient;

	@Resource
	private SysUserClient sysUserClient;
	
	@Resource
	private TChargingOrderAccountingStrategyService chargingOrderAccountingStrategyService;

	@Autowired
	private RedissonClient redissonClient;


	
	
	
	/**
	 * 添加开票申请
	 * @param addOrderInvoice
	 * @return
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public AjaxResult addOrderInvoice(AddOrderInvoice addOrderInvoice) {
		Long userId = tokenService.getLoginUserApplet().getUserId();
		RLock lock = redissonClient.getLock("ADD_ORDER_INVOICE:" + userId);
		boolean locked = false;
		try {
			locked = lock.tryLock(5, 5, TimeUnit.SECONDS);
			if (!locked) {
				return AjaxResult.error("开票申请正在处理中，请勿重复提交");
			}
			String orders = addOrderInvoice.getOrders();
			if (StringUtils.isEmpty(orders)) {
				return AjaxResult.error("请选择有效的订单");
			}
			JSONArray parse = JSONArray.parse(orders);
			if (parse == null || parse.isEmpty()) {
				return AjaxResult.error("请选择有效的订单");
			}
			List<Long> orderIds = new ArrayList<>();
			Map<Long, BigDecimal> amountMap = new HashMap<>();
			for (int i = 0; i < parse.size(); i++) {
				JSONObject jsonObject = parse.getJSONObject(i);
				Long id = jsonObject.getLong("id");
				BigDecimal amount = jsonObject.getBigDecimal("amount");
				if (id == null || amount == null || amount.compareTo(BigDecimal.ZERO) <= 0) {
					return AjaxResult.error("订单金额异常，请刷新后重试");
				}
				orderIds.add(id);
				amountMap.put(id, amount);
			}
			List<TOrderInvoiceDetail> existingDetails = orderInvoiceDetailService.list(new LambdaQueryWrapper<TOrderInvoiceDetail>()
					.eq(TOrderInvoiceDetail::getOrderType, addOrderInvoice.getOrderType())
					.in(TOrderInvoiceDetail::getOrderId, orderIds));
			if (!CollectionUtils.isEmpty(existingDetails)) {
				List<Long> invoiceIds = existingDetails.stream().map(TOrderInvoiceDetail::getOrderInvoiceId).distinct().collect(Collectors.toList());
				long count = this.count(new LambdaQueryWrapper<TOrderInvoice>().in(TOrderInvoice::getId, invoiceIds).ne(TOrderInvoice::getStatus, 4));
				if (count > 0) {
					return AjaxResult.error("不能重复申请开票，请刷新数据后重试");
				}
			}
			//获取开票类型
			TInvoiceType invoiceType = invoiceTypeClient.getInvoiceType(addOrderInvoice.getInvoiceTypeId()).getData();
			if (invoiceType == null) {
				return AjaxResult.error("请选择有效的发票类型");
			}
			Map<Integer, List<Long>> invoiceOrderGroups = buildInvoiceOrderGroups(addOrderInvoice, orderIds);
			for (List<Long> groupOrderIds : invoiceOrderGroups.values()) {
				TOrderInvoice invoice = buildOrderInvoice(addOrderInvoice, userId, invoiceType, groupOrderIds, amountMap);
				this.save(invoice);
				saveInvoiceDetails(invoice, invoiceType, groupOrderIds, amountMap);
			}
			return AjaxResult.success();
		} catch (Exception e) {
			e.printStackTrace();
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return AjaxResult.error("开票申请失败：" + (StringUtils.isEmpty(e.getMessage()) ? "请稍后重试" : e.getMessage()));
		} finally {
			if (locked && lock.isHeldByCurrentThread()) {
				lock.unlock();
			}
		}
	}

	private Map<Integer, List<Long>> buildInvoiceOrderGroups(AddOrderInvoice addOrderInvoice, List<Long> orderIds) {
		Map<Integer, List<Long>> groups = new LinkedHashMap<>();
		if (!Integer.valueOf(1).equals(addOrderInvoice.getOrderType())) {
			groups.put(0, orderIds);
			return groups;
		}
		List<TChargingOrder> chargingOrders = chargingOrderService.listByIds(orderIds);
		Map<Long, Integer> siteIdMap = chargingOrders.stream().collect(Collectors.toMap(TChargingOrder::getId, TChargingOrder::getSiteId, (a, b) -> a));
		for (Long orderId : orderIds) {
			Integer siteId = siteIdMap.get(orderId);
			if (siteId == null) {
				throw new IllegalArgumentException("订单所属电站异常，请刷新后重试");
			}
			groups.computeIfAbsent(siteId, key -> new ArrayList<>()).add(orderId);
		}
		return groups;
	}

	private TOrderInvoice buildOrderInvoice(AddOrderInvoice source, Long userId, TInvoiceType invoiceType, List<Long> orderIds, Map<Long, BigDecimal> amountMap) {
		TOrderInvoice invoice = new TOrderInvoice();
		BeanUtils.copyProperties(source, invoice);
		invoice.setId(null);
		invoice.setCode(generateInvoiceCode());
		invoice.setAppUserId(userId);
		invoice.setInvoicingCompany(invoiceType.getInvoicingCompany());
		invoice.setInvoiceType(invoiceType.getName());
		invoice.setInvoiceMaterial(2);
		invoice.setInvoicingMethod(invoiceType.getInvoicingMethod());
		invoice.setTotalAmount(orderIds.stream().map(amountMap::get).filter(Objects::nonNull).reduce(BigDecimal.ZERO, BigDecimal::add));
		invoice.setInvoiceUrl(null);
		invoice.setBillingUserId(null);
		invoice.setCancelTime(null);
		invoice.setStatus(1);
		invoice.setCreateTime(LocalDateTime.now());
		invoice.setBillingTime(null);
		invoice.setSiteId(null);
		invoice.setPartnerId(null);
		fillInvoiceSite(invoice, orderIds);
		if (Integer.valueOf(2).equals(invoice.getInvoicingMethod())) {
			invoice.setStatus(3);
			invoice.setBillingTime(LocalDateTime.now());
		}
		return invoice;
	}

	private void saveInvoiceDetails(TOrderInvoice invoice, TInvoiceType invoiceType, List<Long> orderIds, Map<Long, BigDecimal> amountMap) {
		for (Long orderId : orderIds) {
			BigDecimal electrovalence = BigDecimal.ZERO;
			BigDecimal serviceCharge = BigDecimal.ZERO;
			if (Integer.valueOf(1).equals(invoice.getOrderType())) {
				List<TChargingOrderAccountingStrategy> list = chargingOrderAccountingStrategyService.list(new LambdaQueryWrapper<TChargingOrderAccountingStrategy>()
						.eq(TChargingOrderAccountingStrategy::getChargingOrderId, orderId));
				electrovalence = list.stream().map(TChargingOrderAccountingStrategy::getElectrovalence).filter(Objects::nonNull).reduce(BigDecimal.ZERO, BigDecimal::add);
				serviceCharge = list.stream().map(TChargingOrderAccountingStrategy::getServiceCharge).filter(Objects::nonNull).reduce(BigDecimal.ZERO, BigDecimal::add);
			}

			TOrderInvoiceDetail orderInvoiceDetail = new TOrderInvoiceDetail();
			orderInvoiceDetail.setOrderInvoiceId(invoice.getId());
			orderInvoiceDetail.setInvoiceAmount(amountMap.get(orderId));
			orderInvoiceDetail.setOrderType(invoice.getOrderType());
			orderInvoiceDetail.setOrderId(orderId);
			orderInvoiceDetail.setElectricityTariff(invoiceType.getElectricityTariff());
			orderInvoiceDetail.setServiceTariff(invoiceType.getServiceTariff());
			orderInvoiceDetail.setAddedServiceTariff(invoiceType.getAddedServiceTariff());
			orderInvoiceDetail.setElectrovalence(electrovalence);
			orderInvoiceDetail.setServiceCharge(serviceCharge);
			orderInvoiceDetail.setAddedService(serviceCharge.multiply(null == invoiceType.getAddedServiceTariff()
					? new BigDecimal(1) : invoiceType.getAddedServiceTariff().divide(new BigDecimal(100))));
			orderInvoiceDetailService.save(orderInvoiceDetail);
		}
	}

	private String generateInvoiceCode() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
		return Double.valueOf(Math.random() * 1000).intValue() + sdf.format(new Date());
	}

	private void fillInvoiceSite(TOrderInvoice invoice, List<Long> orderIds) {
		if (!Integer.valueOf(1).equals(invoice.getOrderType()) || CollectionUtils.isEmpty(orderIds)) {
			return;
		}
		List<TChargingOrder> chargingOrders = chargingOrderService.listByIds(orderIds);
		if (CollectionUtils.isEmpty(chargingOrders)) {
			return;
		}
		Integer siteId = chargingOrders.get(0).getSiteId();
		invoice.setSiteId(siteId);
		List<Site> sites = siteClient.getSiteByIds(Collections.singletonList(siteId)).getData();
		if (!CollectionUtils.isEmpty(sites)) {
			Site site = sites.get(0);
			invoice.setPartnerId(site.getPartnerId());
			if (!Integer.valueOf(1).equals(site.getBusinessCategory()) && site.getPartnerId() != null) {
				Partner partner = siteClient.getPartnerR(site.getPartnerId()).getData();
				if (partner != null && org.springframework.util.StringUtils.hasLength(partner.getName())) {
					invoice.setInvoicingCompany(partner.getName());
				}
			}
		}
	}
	
	
	/**
	 * 获取开票记录列表
	 * @param query
	 * @return
	 */
	@Override
	public List<OrderInvoiceList> getMyOrderInvoiceList(GetOrderInvoiceList query) {
		Long userId = tokenService.getLoginUserApplet().getUserId();
		Integer pageCurr = (query.getPageCurr() - 1) * query.getPageSize();
		LambdaQueryWrapper<TOrderInvoice> wrapper = new LambdaQueryWrapper<TOrderInvoice>().eq(TOrderInvoice::getAppUserId, userId);
		if(query.getStatus() != null){
			wrapper.eq(TOrderInvoice::getStatus, query.getStatus());
		}
		List<TOrderInvoice> list = this.list(wrapper.orderByDesc(TOrderInvoice::getCreateTime).last(" limit " + pageCurr + ", " + query.getPageSize()));
		List<OrderInvoiceList> pageList = new ArrayList<>();
		for (TOrderInvoice tOrderInvoice : list) {
			OrderInvoiceList orderInvoiceList = new OrderInvoiceList();
			orderInvoiceList.setId(tOrderInvoice.getId().toString());
			orderInvoiceList.setOrderType(tOrderInvoice.getOrderType());
			orderInvoiceList.setTotalAmount(tOrderInvoice.getTotalAmount());
			orderInvoiceList.setName(tOrderInvoice.getName());
			orderInvoiceList.setStatus(tOrderInvoice.getStatus());
			orderInvoiceList.setCreateTime(tOrderInvoice.getCreateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
			pageList.add(orderInvoiceList);
		}
		return pageList;
	}
	
	
	/**
	 * 获取开票申请详情
	 * @param id
	 * @return
	 */
	@Override
	public MyOrderInvoiceInfo getMyOrderInvoiceInfo(String id) {
		TOrderInvoice orderInvoice = this.getById(id);
		MyOrderInvoiceInfo myOrderInvoiceInfo = new MyOrderInvoiceInfo();
		myOrderInvoiceInfo.setId(id);
		myOrderInvoiceInfo.setCode(orderInvoice.getCode());
		myOrderInvoiceInfo.setInvoiceType(orderInvoice.getInvoiceType());
		myOrderInvoiceInfo.setOrderType(orderInvoice.getOrderType());
		myOrderInvoiceInfo.setInvoicingObjectType(orderInvoice.getInvoicingObjectType());
		myOrderInvoiceInfo.setTotalAmount(orderInvoice.getTotalAmount());
		myOrderInvoiceInfo.setInvoiceUrl(orderInvoice.getInvoiceUrl());
		myOrderInvoiceInfo.setStatus(orderInvoice.getStatus());
		Integer orderType = orderInvoice.getOrderType();
		List<TOrderInvoiceDetail> list = orderInvoiceDetailService.list(new LambdaQueryWrapper<TOrderInvoiceDetail>().eq(TOrderInvoiceDetail::getOrderInvoiceId, id));
		List<Long> orderIds = list.stream().map(TOrderInvoiceDetail::getOrderId).collect(Collectors.toList());
		//充电订单
		if(orderType == 1){
			List<TChargingOrder> orderList = chargingOrderService.listByIds(orderIds);
			List<MyChargingOrderList> chargingOrder = new ArrayList<>();
			for (TChargingOrder tChargingOrder : orderList) {
				MyChargingOrderList myChargingOrderList = new MyChargingOrderList();
				myChargingOrderList.setId(tChargingOrder.getId().toString());
				myChargingOrderList.setStatus(tChargingOrder.getStatus());
				Site site = siteClient.getSiteByIds(Arrays.asList(tChargingOrder.getSiteId())).getData().get(0);
				myChargingOrderList.setTitle(site.getName());
				myChargingOrderList.setChargingDegree(tChargingOrder.getChargingCapacity());
				String name = chargingGunClient.getAllName(tChargingOrder.getChargingGunId()).getData();
				myChargingOrderList.setName(name);
				myChargingOrderList.setEndMode(tChargingOrder.getEndMode());
				BigDecimal payMoney = tChargingOrder.getStatus() < 4 ? tChargingOrder.getRechargeAmount() : tChargingOrder.getPaymentAmount();
				myChargingOrderList.setPayMoney(payMoney);
				myChargingOrderList.setCreateTime(tChargingOrder.getCreateTime().format(DateTimeFormatter.ofPattern("yyyy.MM.dd HH:mm:ss")));
				myChargingOrderList.setElectricCharge(tChargingOrder.getElectrovalence());
				myChargingOrderList.setServiceCharge(tChargingOrder.getServiceCharge());
				chargingOrder.add(myChargingOrderList);
			}
			myOrderInvoiceInfo.setChargingOrder(chargingOrder);
		}
		//购物订单
		if(orderType == 2){
			List<TShoppingOrder> orderList = shoppingOrderService.listByIds(orderIds);
			List<MyShoppingOrderList> shoppingOrder = new ArrayList<>();
			for (TShoppingOrder tShoppingOrder : orderList) {
				MyShoppingOrderList myShoppingOrderList = new MyShoppingOrderList();
				myShoppingOrderList.setId(tShoppingOrder.getId().toString());
				String name = "";
				String imgUrl = "";
				if(tShoppingOrder.getOrderType() == 1){
					TGoods goods = goodsClient.getGoodsById(tShoppingOrder.getGoodsId()).getData();
					name = goods.getName();
					imgUrl = goods.getCoverPicture();
				}else{
					TCoupon coupon = couponClient.getCouponById1(tShoppingOrder.getGoodsId()).getData();
					name = coupon.getName();
					imgUrl = coupon.getCoverPicture();
				}
				myShoppingOrderList.setName(name);
				myShoppingOrderList.setImgUrl(imgUrl);
				myShoppingOrderList.setStatus(tShoppingOrder.getStatus());
				BigDecimal unitPrice = tShoppingOrder.getPaymentAmount().divide(new BigDecimal(tShoppingOrder.getPurchaseQuantity())).setScale(2, BigDecimal.ROUND_HALF_EVEN);
				myShoppingOrderList.setUnitPrice(unitPrice);
				myShoppingOrderList.setNumber(tShoppingOrder.getPurchaseQuantity());
				myShoppingOrderList.setPaymentAmount(tShoppingOrder.getPaymentAmount());
				myShoppingOrderList.setCreateTime(tShoppingOrder.getCreateTime().format(DateTimeFormatter.ofPattern("yyyy.MM.dd HH:mm:ss")));
				shoppingOrder.add(myShoppingOrderList);
			}
			myOrderInvoiceInfo.setShoppingOrder(shoppingOrder);
		}
		return myOrderInvoiceInfo;
	}

	@Override
	public PageInfo<TOrderInvoiceVO> pageList(TOrderInvoiceQuery query) {
		applyPartnerSiteScope(query);
		List<TAppUser> tAppUsers = new ArrayList<>();
		// 查询申请用户
		if (org.springframework.util.StringUtils.hasLength(query.getUserPhone())){
			 tAppUsers = appUserClient.selectByPhoneLike(query.getUserPhone()).getData();
			if(CollectionUtils.isEmpty(tAppUsers)){
				return new PageInfo<>();
			}
		}
		query.setUserIds(tAppUsers.stream().map(TAppUser::getId).collect(Collectors.toList()));
		PageInfo<TOrderInvoiceVO> pageInfo = new PageInfo<>(query.getPageCurr(),query.getPageSize());
		List<TOrderInvoiceVO> list = this.baseMapper.pageList(query,pageInfo);
        List<Site> siteList = siteClient.getSiteAll().getData();
        for (TOrderInvoiceVO tOrderInvoiceVO : list) {
			tOrderInvoiceVO.setUid(tOrderInvoiceVO.getId().toString());
			List<Long> collect = orderInvoiceDetailService.lambdaQuery().eq(TOrderInvoiceDetail::getOrderInvoiceId, tOrderInvoiceVO.getId()).list().stream()
					.map(TOrderInvoiceDetail::getOrderId).collect(Collectors.toList());
			Integer siteId = tOrderInvoiceVO.getSiteId();
			if (siteId == null && !CollectionUtils.isEmpty(collect) && Integer.valueOf(1).equals(tOrderInvoiceVO.getOrderType())) {
				List<TChargingOrder> chargingOrders = chargingOrderService.listByIds(collect);
				if (!CollectionUtils.isEmpty(chargingOrders)) {
					siteId = chargingOrders.get(0).getSiteId();
					tOrderInvoiceVO.setSiteId(siteId);
				}
			}
            Site site = null;
            if (!CollectionUtils.isEmpty(siteList) && siteId != null) {
                for (Site item : siteList) {
                    if (siteId.equals(item.getId())) {
                        site = item;
                        break;
                    }
                }
            }
            if(null != site){
                tOrderInvoiceVO.setSiteName(site.getName());
				tOrderInvoiceVO.setPartnerId(site.getPartnerId());
				tOrderInvoiceVO.setBusinessCategory(site.getBusinessCategory());
				if (site.getPartnerId() != null) {
					try {
						tOrderInvoiceVO.setPartnerName(siteClient.getPartnerR(site.getPartnerId()).getData().getName());
					} catch (Exception ignored) {
					}
				}
            }
            // 将其全部转化为String
			tOrderInvoiceVO.setIds(collect.stream().map(String::valueOf).collect(Collectors.toList()));
			TAppUser appUser = appUserClient.getUserById(tOrderInvoiceVO.getAppUserId()).getData();
			if (appUser!=null){
				tOrderInvoiceVO.setUserPhone(appUser.getPhone());
			}

		}
		// 查询这个开票的订单ids

		if (!list.isEmpty()){
			List<Long> ids = list.stream().map(TOrderInvoiceVO::getId).collect(Collectors.toList());

			List<TOrderInvoiceDetail> orderInvoiceDetailList = orderInvoiceDetailService.list(new LambdaQueryWrapper<TOrderInvoiceDetail>()
					.in(TOrderInvoiceDetail::getOrderInvoiceId, ids));

			List<TAppUser> finalTAppUsers = tAppUsers;
			list.forEach(e -> fillInvoiceDetailAmount(e, orderInvoiceDetailList));
		}


		pageInfo.setRecords(list);
		return pageInfo;
	}

	@Override
	public List<String> invoicingCompanyOptions(TOrderInvoiceQuery query) {
		if (query == null) {
			query = new TOrderInvoiceQuery();
		}
		applyPartnerSiteScope(query);
		return this.baseMapper.invoicingCompanyOptions(query);
	}

	@Override
	public Map<String, Integer> statusCount(TOrderInvoiceQuery query) {
		applyPartnerSiteScope(query);
		Map<String, Integer> map = new HashMap<>();
		List<TAppUser> tAppUsers = new ArrayList<>();

		if (org.springframework.util.StringUtils.hasLength(query.getUserPhone())){
	tAppUsers = appUserClient.selectByPhoneLike(query.getUserPhone()).getData();
			if(CollectionUtils.isEmpty(tAppUsers)){
				map.put("notAccepted",0);
				map.put("processing",0);
				map.put("finished",0);
				return map;
			}
		}

		query.setUserIds(tAppUsers.stream().map(TAppUser::getId).collect(Collectors.toList()));
		map = this.baseMapper.statusCount(query);
		return map;
	}

	@Override
	public List<TOrderInvoiceVO> export(TOrderInvoiceQuery query) {
		applyPartnerSiteScope(query);
		List<TAppUser> tAppUsers = new ArrayList<>();
		// 查询申请用户
		if (org.springframework.util.StringUtils.hasLength(query.getUserPhone())){
			tAppUsers = appUserClient.selectByPhoneLike(query.getUserPhone()).getData();
			if(CollectionUtils.isEmpty(tAppUsers)){
				return new ArrayList<TOrderInvoiceVO>();
			}
		}
		query.setUserIds(tAppUsers.stream().map(TAppUser::getId).collect(Collectors.toList()));
		PageInfo<TOrderInvoiceVO> pageInfo = new PageInfo<>(query.getPageCurr(),query.getPageSize());
		List<TOrderInvoiceVO> list = this.baseMapper.export(query);
		if (CollectionUtils.isEmpty(list)) {
			return list;
		}
		List<Long> ids = list.stream().map(TOrderInvoiceVO::getId).collect(Collectors.toList());
		List<TOrderInvoiceDetail> orderInvoiceDetailList = orderInvoiceDetailService.list(new LambdaQueryWrapper<TOrderInvoiceDetail>()
				.in(TOrderInvoiceDetail::getOrderInvoiceId, ids));
		List<TAppUser> finalTAppUsers = tAppUsers;
		list.forEach(e->{
			fillInvoiceDetailAmount(e, orderInvoiceDetailList);
			TAppUser appUser = appUserClient.getUserById(e.getAppUserId()).getData();
			if (appUser != null) {
				e.setUserPhone(appUser.getPhone());
			}
			fillInvoiceSiteName(e);
		});
		return list;
	}

	private void applyPartnerSiteScope(TOrderInvoiceQuery query) {
		if (query == null) {
			return;
		}
		Long userId = tokenService.getLoginUser().getUserid();
		SysUser sysUser = sysUserClient.getSysUser(userId).getData();
		if (sysUser == null || !Integer.valueOf(2).equals(sysUser.getRoleType())) {
			return;
		}
		List<GetSiteListDTO> sites = siteClient.getSiteListByUserId(userId).getData();
		List<Integer> siteIds = sites == null ? new ArrayList<>() : sites.stream()
				.map(GetSiteListDTO::getId)
				.filter(Objects::nonNull)
				.collect(Collectors.toList());
		if (query.getSiteId() != null) {
			siteIds = siteIds.contains(query.getSiteId())
					? Collections.singletonList(query.getSiteId())
					: Collections.singletonList(-1);
		}
		if (siteIds.isEmpty()) {
			siteIds = Collections.singletonList(-1);
		}
		query.setSiteIds(siteIds);
	}

	private void fillInvoiceDetailAmount(TOrderInvoiceVO invoice, List<TOrderInvoiceDetail> details) {
		List<TOrderInvoiceDetail> currentDetails = details.stream()
				.filter(t -> t.getOrderInvoiceId().equals(invoice.getId()))
				.collect(Collectors.toList());
		if (CollectionUtils.isEmpty(currentDetails)) {
			invoice.setServiceTariff(BigDecimal.ZERO);
			invoice.setElectricityTariff(BigDecimal.ZERO);
			invoice.setAddedServiceTariff(BigDecimal.ZERO);
			invoice.setAddedService(BigDecimal.ZERO);
			invoice.setElectrovalence(BigDecimal.ZERO);
			invoice.setServiceCharge(BigDecimal.ZERO);
			return;
		}
		TOrderInvoiceDetail first = currentDetails.get(0);
		invoice.setServiceTariff(Integer.valueOf(1).equals(invoice.getOrderType()) ? first.getServiceTariff() : BigDecimal.ZERO);
		invoice.setElectricityTariff(first.getElectricityTariff());
		invoice.setAddedServiceTariff(first.getAddedServiceTariff());
		invoice.setAddedService(currentDetails.stream().filter(t -> t.getAddedService() != null).map(TOrderInvoiceDetail::getAddedService).reduce(BigDecimal.ZERO, BigDecimal::add));
		invoice.setElectrovalence(currentDetails.stream().filter(t -> t.getElectrovalence() != null).map(TOrderInvoiceDetail::getElectrovalence).reduce(BigDecimal.ZERO, BigDecimal::add));
		invoice.setServiceCharge(currentDetails.stream().filter(t -> t.getServiceCharge() != null).map(TOrderInvoiceDetail::getServiceCharge).reduce(BigDecimal.ZERO, BigDecimal::add));
	}

	private void fillInvoiceSiteName(TOrderInvoiceVO invoice) {
		if (invoice.getSiteId() == null) {
			return;
		}
		List<Site> sites = siteClient.getSiteByIds(Collections.singletonList(invoice.getSiteId())).getData();
		if (CollectionUtils.isEmpty(sites)) {
			return;
		}
		Site site = sites.get(0);
		invoice.setSiteName(site.getName());
		invoice.setPartnerId(site.getPartnerId());
		invoice.setBusinessCategory(site.getBusinessCategory());
		if (site.getPartnerId() != null) {
			try {
				invoice.setPartnerName(siteClient.getPartnerR(site.getPartnerId()).getData().getName());
			} catch (Exception ignored) {
			}
		}
	}
}