package com.doumee.service.business.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.model.LoginUserInfo;
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.YwContractBillMapper;
import com.doumee.dao.business.YwContractDetailMapper;
import com.doumee.dao.business.YwContractMapper;
import com.doumee.dao.business.YwContractRevenueMapper;
import com.doumee.dao.business.YwContractRoomMapper;
import com.doumee.dao.business.YwCustomerElectricalMapper;
import com.doumee.dao.business.YwCustomerMapper;
import com.doumee.dao.business.YwElectricalMapper;
import com.doumee.dao.business.YwRoomMapper;
import com.doumee.dao.business.dto.YwCustomerRechargeElectricalDTO;
import com.doumee.dao.business.dto.YwCustomerRechargeDetailVO;
import com.doumee.dao.business.dto.YwCustomerRechargeRecordQueryDTO;
import com.doumee.dao.business.dto.YwCustomerRechargeRecordVO;
import com.doumee.dao.business.dto.h5.*;
import com.doumee.dao.business.model.*;
import com.doumee.dao.system.MultifileMapper;
import com.doumee.dao.system.model.Multifile;
import com.doumee.service.business.YwCustomerDeviceAutoBindService;
import com.doumee.service.business.YwCustomerH5AuthService;
import com.doumee.service.business.YwCustomerH5BizService;
import com.doumee.service.business.YwCustomerRechargeBizService;
import com.doumee.service.business.YwElectricalBizService;
import com.doumee.service.business.YwH5BannerService;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class YwCustomerH5BizServiceImpl implements YwCustomerH5BizService {

    private static final int BILL_DUE_SOON_DAYS = 7;

    @Autowired
    private YwH5BannerService ywH5BannerService;
    @Autowired
    private YwCustomerMapper ywCustomerMapper;
    @Autowired
    private YwCustomerRechargeBizService ywCustomerRechargeBizService;
    @Autowired
    private YwCustomerDeviceAutoBindService ywCustomerDeviceAutoBindService;
    @Autowired
    private YwCustomerElectricalMapper ywCustomerElectricalMapper;
    @Autowired
    private YwElectricalMapper ywElectricalMapper;
    @Autowired
    private YwElectricalBizService ywElectricalBizService;
    @Autowired
    private YwContractMapper ywContractMapper;
    @Autowired
    private YwContractDetailMapper ywContractDetailMapper;
    @Autowired
    private YwContractBillMapper ywContractBillMapper;
    @Autowired
    private YwContractRevenueMapper ywContractRevenueMapper;
    @Autowired
    private YwContractRoomMapper ywContractRoomMapper;
    @Autowired
    private YwRoomMapper ywRoomMapper;
    @Autowired
    private MultifileMapper multifileMapper;
    @Autowired
    private SystemDictDataBiz systemDictDataBiz;
    @Autowired
    private YwCustomerH5AuthService ywCustomerH5AuthService;

    @Override
    public List<YwH5Banner> listBanners() {
        return ywH5BannerService.listEnabledForCustomerWorkbench();
    }

    @Override
    public Map<String, Object> home(Integer customerId, Integer memberId) {
        YwCustomer customer = requireCustomer(customerId);
        LoginUserInfo loginUser = ywCustomerH5AuthService.buildLoginUserInfo(customerId, memberId);
        YwCustomerRechargeDetailVO detail = ywCustomerRechargeBizService.getDetail(customerId);
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("customerName", loginUser.getCustomerName() != null ? loginUser.getCustomerName() : customer.getName());
        map.put("memberName", loginUser.getMemberName());
        map.put("displayName", loginUser.getDisplayName());
        map.put("electricalCount", detail.getElectricalList() != null ? detail.getElectricalList().size() : 0);
        map.put("conditionerCount", detail.getConditionerList() != null ? detail.getConditionerList().size() : 0);
        map.put("gsConfig", detail.getGsConfig());
        map.put("electricalList", detail.getElectricalList());
        return map;
    }

    @Override
    public PageData<CustomerDeviceH5VO> devicePage(PageWrap<CustomerDeviceQueryDTO> pageWrap, Integer customerId) {
        requireCustomer(customerId);
        ywCustomerDeviceAutoBindService.refreshCustomerDevices(customerId, systemUser());
        CustomerDeviceQueryDTO q = pageWrap.getModel() != null ? pageWrap.getModel() : new CustomerDeviceQueryDTO();
        List<CustomerDeviceH5VO> all = new ArrayList<>();
        if (q.getDeviceType() == null || q.getDeviceType() == 0) {
            all.addAll(buildElectricalDevices(customerId));
        }
        if (q.getDeviceType() == null || q.getDeviceType() == 1) {
            all.addAll(buildConditionerDevices(customerId));
        }
        if (q.getStatusFilter() != null) {
            all = all.stream().filter(d -> matchDeviceStatus(d, q.getStatusFilter())).collect(Collectors.toList());
        }
        int p = (int) Math.max(pageWrap.getPage(), 1);
        int size = (int) Math.max(pageWrap.getCapacity(), 10);
        int from = (p - 1) * size;
        int to = Math.min(from + size, all.size());
        PageData<CustomerDeviceH5VO> data = new PageData<>();
        data.setTotal(all.size());
        data.setPage(p);
        data.setCapacity(size);
        data.setRecords(from >= all.size() ? Collections.emptyList() : all.subList(from, to));
        return data;
    }

    @Override
    public CustomerDeviceH5VO deviceDetail(Integer deviceType, Integer deviceId, Integer customerId) {
        PageWrap<CustomerDeviceQueryDTO> pw = new PageWrap<>();
        pw.setPage(1);
        pw.setCapacity(1000);
        CustomerDeviceQueryDTO q = new CustomerDeviceQueryDTO();
        q.setDeviceType(deviceType);
        pw.setModel(q);
        return devicePage(pw, customerId).getRecords().stream()
                .filter(d -> Objects.equals(d.getDeviceType(), deviceType) && Objects.equals(d.getDeviceId(), deviceId))
                .findFirst()
                .orElseThrow(() -> new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "设备不存在"));
    }

    @Override
    public PageData<YwCustomerRechargeRecordVO> rechargeRecordPage(PageWrap<CustomerRechargeRecordH5QueryDTO> pageWrap, Integer customerId) {
        PageWrap<YwCustomerRechargeRecordQueryDTO> wrap = new PageWrap<>();
        wrap.setPage(pageWrap.getPage());
        wrap.setCapacity(pageWrap.getCapacity());
        YwCustomerRechargeRecordQueryDTO model = new YwCustomerRechargeRecordQueryDTO();
        model.setCustomerId(customerId);
        CustomerRechargeRecordH5QueryDTO q = pageWrap.getModel();
        if (q != null) {
            model.setStatus(q.getStatus());
            model.setCreateTimeBegin(q.getCreateTimeBegin());
            model.setCreateTimeEnd(q.getCreateTimeEnd());
            if (StringUtils.isNotBlank(q.getMonth())) {
                try {
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
                    Date start = sdf.parse(q.getMonth());
                    Calendar cal = Calendar.getInstance();
                    cal.setTime(start);
                    cal.add(Calendar.MONTH, 1);
                    model.setCreateTimeBegin(start);
                    model.setCreateTimeEnd(cal.getTime());
                } catch (Exception ignored) {
                }
            }
        }
        wrap.setModel(model);
        return ywCustomerRechargeBizService.findRechargeRecordPage(wrap);
    }

    @Override
    public PageData<YwContract> contractPage(PageWrap<CustomerContractQueryDTO> pageWrap, Integer customerId) {
        requireCustomer(customerId);
        IPage<YwContract> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        CustomerContractQueryDTO q = pageWrap.getModel();
        QueryWrapper<YwContract> qw = new QueryWrapper<>();
        qw.lambda()
                .eq(YwContract::getRenterId, customerId)
                .eq(YwContract::getIsdeleted, Constants.ZERO)
                .eq(q != null && q.getStatus() != null, YwContract::getStatus, q != null ? q.getStatus() : null)
                .orderByDesc(YwContract::getCreateDate);
        IPage<YwContract> result = ywContractMapper.selectPage(page, qw);
        enrichContractListForH5(result.getRecords());
        return PageData.from(result);
    }

    @Override
    public Map<String, Object> contractDetail(Integer contractId, Integer customerId, Integer billType) {
        YwContract contract = requireCustomerContract(contractId, customerId);
        enrichContractForH5(contract, true);
        int type = billType != null ? billType : Constants.ZERO;
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("contract", contract);
        map.put("bills", listContractBillsForH5(contractId, type));
        map.put("billType", type);
        return map;
    }

    @Override
    public PageData<YwContractBill> billPage(PageWrap<CustomerBillQueryDTO> pageWrap, Integer customerId) {
        List<Integer> contractIds = listCustomerContractIds(customerId);
        if (contractIds.isEmpty()) {
            return emptyBillPage(pageWrap);
        }
        IPage<YwContractBill> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        CustomerBillQueryDTO q = pageWrap.getModel();
        MPJLambdaWrapper<YwContractBill> wrapper = new MPJLambdaWrapper<YwContractBill>()
                .selectAll(YwContractBill.class)
                .select(" ( select ifnull( sum( CASE WHEN t.bill_type = 0 and yw.REVENUE_TYPE = 0 THEN yw.ACT_RECEIVABLE_FEE when  t.bill_type = 0 and yw.REVENUE_TYPE = 1 then -yw.ACT_RECEIVABLE_FEE  when t.bill_type = 1 and yw.REVENUE_TYPE = 0 then -yw.ACT_RECEIVABLE_FEE else  yw.ACT_RECEIVABLE_FEE END),0) from  yw_contract_revenue yw where yw.bill_id = t.id and yw.status = 0 and yw.isdeleted = 0 ) as  actReceivableFee  ")
                .in(YwContractBill::getContractId, contractIds)
                .eq(YwContractBill::getIsdeleted, Constants.ZERO)
                .eq(YwContractBill::getBillType, Constants.ZERO);
        if (q != null && q.getPayTab() != null) {
            if (q.getPayTab() == 0) {
                wrapper.in(YwContractBill::getPayStatus, Arrays.asList(Constants.ZERO, Constants.TWO, Constants.THREE));
            } else if (q.getPayTab() == 1) {
                wrapper.eq(YwContractBill::getPayStatus, Constants.ONE);
            }
        }
        if (q != null && q.getCostType() != null) {
            wrapper.eq(YwContractBill::getCostType, q.getCostType());
        }
        wrapper.orderByDesc(YwContractBill::getPlanPayDate);
        IPage<YwContractBill> result = ywContractBillMapper.selectJoinPage(page, YwContractBill.class, wrapper);
        enrichBillsWithContract(result.getRecords());
        return PageData.from(result);
    }

    @Override
    public Map<String, Object> billDetail(Integer billId, Integer customerId) {
        YwContractBill bill = ywContractBillMapper.selectById(billId);
        if (bill == null || Objects.equals(bill.getIsdeleted(), Constants.ONE)) {
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "账单不存在");
        }
        requireCustomerContract(bill.getContractId(), customerId);
        enrichBillWithContract(bill);
        enrichBillWithRooms(bill);
        List<YwContractRevenue> revenues = listBillRevenues(billId, bill);
        BigDecimal paid = sumPaid(revenues, bill.getBillType());
        BigDecimal needPay = bill.getReceivableFee() != null ? bill.getReceivableFee().subtract(paid) : BigDecimal.ZERO;
        bill.setActReceivableFee(paid);
        bill.setNeedReceivableFee(needPay);
        bill.setYwContractRevenueList(revenues);
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("bill", bill);
        map.put("revenues", revenues);
        map.put("paidAmount", paid);
        map.put("needPayAmount", needPay);
        return map;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void applyFirstRechargeIfNeeded(Integer customerId, LoginUserInfo user) {
        YwCustomer customer = requireCustomer(customerId);
        if (Objects.equals(customer.getFirstRechargeDone(), Constants.ONE)) {
            return;
        }
        ywCustomerDeviceAutoBindService.refreshCustomerDevices(customerId, user != null ? user : systemUser());
        List<Integer> electricalIds = ywCustomerDeviceAutoBindService.listElectricalIdsByActiveContracts(customerId);
        for (Integer eid : electricalIds) {
            YwCustomerRechargeElectricalDTO dto = new YwCustomerRechargeElectricalDTO();
            dto.setCustomerId(customerId);
            dto.setElectricalId(eid);
            dto.setResetAction("resetPrepay");
            try {
                ywCustomerRechargeBizService.resetElectricalAccount(dto, user);
            } catch (Exception e) {
                // 已开户则跳过
            }
        }
        try {
            ywCustomerRechargeBizService.cleanConditionerAccount(customerId, user);
        } catch (Exception ignored) {
        }
        ywCustomerMapper.update(null, new UpdateWrapper<YwCustomer>().lambda()
                .set(YwCustomer::getFirstRechargeDone, Constants.ONE)
                .set(YwCustomer::getEditDate, new Date())
                .eq(YwCustomer::getId, customerId));
    }

    private List<CustomerDeviceH5VO> buildElectricalDevices(Integer customerId) {
        List<Integer> ids = ywCustomerDeviceAutoBindService.listElectricalIdsByActiveContracts(customerId);
        if (ids.isEmpty()) {
            return Collections.emptyList();
        }
        List<YwElectrical> list = ywElectricalMapper.selectBatchIds(ids);
        ywElectricalBizService.enrichList(list);
        List<CustomerDeviceH5VO> vos = new ArrayList<>();
        for (YwElectrical e : list) {
            if (e == null || Objects.equals(e.getIsdeleted(), Constants.ONE)) continue;
            CustomerDeviceH5VO vo = new CustomerDeviceH5VO();
            vo.setDeviceType(0);
            vo.setDeviceId(e.getId());
            vo.setDeviceName(e.getName());
            vo.setMeterAccountNo(e.getParamId());
            vo.setMeterAddress(e.getAddress());
            vo.setRoomInfo(e.getRoomNames());
            vo.setBalance(e.getBalance());
            vo.setBalanceLow(e.getBalance() != null && e.getBalance().compareTo(new BigDecimal("50")) < 0);
            vo.setUpdateTime(e.getEditDate());
            boolean online = Objects.equals(e.getOnline(), Constants.ONE);
            vo.setStatusCode(online ? 1 : 2);
            vo.setStatusText(online ? "正常" : "断电");
            List<String> alarms = new ArrayList<>();
            if (!online) alarms.add("断电报警");
            if (Boolean.TRUE.equals(vo.getBalanceLow())) alarms.add("余额不足二级报警");
            vo.setAlarmTags(alarms);
            vos.add(vo);
        }
        return vos;
    }

    private List<CustomerDeviceH5VO> buildConditionerDevices(Integer customerId) {
        List<YwConditioner> list = ywCustomerRechargeBizService.listCustomerConditioner(new PageWrap<>(), customerId).getRecords();
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyList();
        }
        YwCustomerGs gs = ywCustomerRechargeBizService.getCustomerGsConfig(customerId);
        List<CustomerDeviceH5VO> vos = new ArrayList<>();
        for (YwConditioner c : list) {
            CustomerDeviceH5VO vo = new CustomerDeviceH5VO();
            vo.setDeviceType(1);
            vo.setDeviceId(c.getId());
            vo.setDeviceName(StringUtils.defaultIfBlank(c.getName(), c.getCode()));
            vo.setRoomInfo(c.getRoomName());
            if (StringUtils.isNotBlank(c.getRoomName())) {
                vo.setRoomList(Collections.singletonList(c.getRoomName()));
            }
            vo.setBalance(gs != null ? gs.getLeftMoney() : null);
            boolean online = "在线".equals(c.getOnline());
            vo.setStatusCode(online ? 1 : 2);
            vo.setStatusText(online ? "正常" : "离线");
            vo.setUpdateTime(c.getLastSyncDate());
            vos.add(vo);
        }
        return vos;
    }

    private boolean matchDeviceStatus(CustomerDeviceH5VO d, Integer filter) {
        if (filter == 1) return Objects.equals(d.getStatusCode(), 1);
        if (filter == 2) return Objects.equals(d.getStatusCode(), 2);
        return true;
    }

    private LoginUserInfo systemUser() {
        LoginUserInfo user = new LoginUserInfo();
        user.setId(1);
        user.setRealname("system");
        return user;
    }

    private YwCustomer requireCustomer(Integer customerId) {
        YwCustomer c = ywCustomerMapper.selectById(customerId);
        if (c == null || Objects.equals(c.getIsdeleted(), Constants.ONE)) {
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "商户不存在");
        }
        return c;
    }

    private YwContract requireCustomerContract(Integer contractId, Integer customerId) {
        YwContract c = ywContractMapper.selectById(contractId);
        if (c == null || !Objects.equals(c.getRenterId(), customerId)) {
            throw new BusinessException(ResponseStatus.NOT_ALLOWED);
        }
        return c;
    }

    private List<Integer> listCustomerContractIds(Integer customerId) {
        return ywContractMapper.selectList(new QueryWrapper<YwContract>().lambda()
                        .eq(YwContract::getRenterId, customerId)
                        .eq(YwContract::getIsdeleted, Constants.ZERO))
                .stream().map(YwContract::getId).collect(Collectors.toList());
    }

    private void enrichContractListForH5(List<YwContract> contracts) {
        if (CollectionUtils.isEmpty(contracts)) {
            return;
        }
        List<Integer> contractIds = contracts.stream().map(YwContract::getId).collect(Collectors.toList());
        Map<Integer, List<YwRoom>> roomMap = loadContractRoomMap(contractIds);
        Map<Integer, List<YwContractBill>> billMap = loadContractBillMap(contractIds);
        for (YwContract contract : contracts) {
            List<YwRoom> rooms = roomMap.getOrDefault(contract.getId(), Collections.emptyList());
            applyRoomSummary(contract, rooms);
            contract.setPayTypeText(resolvePayTypeText(contract));
            fillBillStatusTip(contract, billMap.getOrDefault(contract.getId(), Collections.emptyList()));
        }
    }

    private void enrichContractForH5(YwContract contract, boolean withFiles) {
        if (contract == null) {
            return;
        }
        Map<Integer, List<YwRoom>> roomMap = loadContractRoomMap(Collections.singletonList(contract.getId()));
        applyRoomSummary(contract, roomMap.getOrDefault(contract.getId(), Collections.emptyList()));
        contract.setPayTypeText(resolvePayTypeText(contract));
        contract.setFreeRentPeriod(resolveFreeRentPeriod(contract));
        initContractDetails(contract);
        fillBillStatusTip(contract, loadContractBillMap(Collections.singletonList(contract.getId()))
                .getOrDefault(contract.getId(), Collections.emptyList()));
        if (withFiles) {
            initContractFiles(contract);
        }
    }

    private Map<Integer, List<YwRoom>> loadContractRoomMap(List<Integer> contractIds) {
        if (CollectionUtils.isEmpty(contractIds)) {
            return Collections.emptyMap();
        }
        List<YwContractRoom> contractRooms = ywContractRoomMapper.selectList(new QueryWrapper<YwContractRoom>().lambda()
                .in(YwContractRoom::getContractId, contractIds)
                .eq(YwContractRoom::getType, Constants.ZERO)
                .eq(YwContractRoom::getIsdeleted, Constants.ZERO));
        if (contractRooms.isEmpty()) {
            return Collections.emptyMap();
        }
        List<Integer> roomIds = contractRooms.stream().map(YwContractRoom::getRoomId).distinct().collect(Collectors.toList());
        Map<Integer, YwRoom> roomById = loadRoomsWithNames(roomIds).stream()
                .collect(Collectors.toMap(YwRoom::getId, r -> r, (a, b) -> a));
        Map<Integer, List<YwRoom>> result = new HashMap<>();
        for (YwContractRoom cr : contractRooms) {
            YwRoom room = roomById.get(cr.getRoomId());
            if (room != null) {
                result.computeIfAbsent(cr.getContractId(), k -> new ArrayList<>()).add(room);
            }
        }
        return result;
    }

    private List<YwRoom> loadRoomsWithNames(List<Integer> roomIds) {
        if (CollectionUtils.isEmpty(roomIds)) {
            return Collections.emptyList();
        }
        MPJLambdaWrapper<YwRoom> wrapper = new MPJLambdaWrapper<YwRoom>()
                .selectAll(YwRoom.class)
                .selectAs(YwProject::getName, YwRoom::getProjectName)
                .selectAs(YwFloor::getName, YwRoom::getFloorName)
                .selectAs(YwBuilding::getName, YwRoom::getBuildingName)
                .leftJoin(YwProject.class, YwProject::getId, YwRoom::getProjectId)
                .leftJoin(YwBuilding.class, YwBuilding::getId, YwRoom::getBuildingId)
                .leftJoin(YwFloor.class, YwFloor::getId, YwRoom::getFloor)
                .in(YwRoom::getId, roomIds)
                .eq(YwRoom::getIsdeleted, Constants.ZERO);
        return ywRoomMapper.selectJoinList(YwRoom.class, wrapper);
    }

    private void applyRoomSummary(YwContract contract, List<YwRoom> rooms) {
        contract.setRoomList(rooms);
        contract.setRoomInfo(buildRoomInfo(rooms));
        BigDecimal totalArea = BigDecimal.ZERO;
        if (!CollectionUtils.isEmpty(rooms)) {
            for (YwRoom room : rooms) {
                totalArea = totalArea.add(Constants.formatBigdecimal(room.getRentArea()));
            }
        }
        contract.setTotalArea(totalArea);
    }

    private String buildRoomInfo(List<YwRoom> rooms) {
        if (CollectionUtils.isEmpty(rooms)) {
            return "";
        }
        return rooms.stream().map(this::formatRoomLine).filter(StringUtils::isNotBlank).collect(Collectors.joining("、"));
    }

    private String formatRoomLine(YwRoom room) {
        if (room == null) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        if (StringUtils.isNotBlank(room.getProjectName())) {
            sb.append(room.getProjectName());
        }
        if (StringUtils.isNotBlank(room.getBuildingName())) {
            if (sb.length() > 0) {
                sb.append("/");
            }
            sb.append(room.getBuildingName());
        }
        if (StringUtils.isNotBlank(room.getFloorName()) || StringUtils.isNotBlank(room.getRoomNum())) {
            if (sb.length() > 0) {
                sb.append("/");
            }
            sb.append(StringUtils.defaultString(room.getFloorName())).append("/").append(StringUtils.defaultString(room.getRoomNum()));
        }
        return sb.toString();
    }

    private String resolvePayTypeText(YwContract contract) {
        Integer type = contract.getType() == null ? Constants.ZERO : contract.getType();
        if (Objects.equals(type, Constants.ONE)) {
            return formatPayType(contract.getWyPayType());
        }
        if (Objects.equals(type, Constants.TWO)) {
            return formatPayType(contract.getZlPayType());
        }
        String zl = formatPayType(contract.getZlPayType());
        String wy = formatPayType(contract.getWyPayType());
        if (StringUtils.isBlank(wy) || StringUtils.equals(zl, wy)) {
            return zl;
        }
        return "租赁" + zl + "；物业" + wy;
    }

    private String formatPayType(Integer payType) {
        if (payType == null) {
            return "-";
        }
        if (Objects.equals(payType, Constants.ONE)) {
            return "每三个月一付";
        }
        if (Objects.equals(payType, Constants.TWO)) {
            return "六个月一付";
        }
        if (Objects.equals(payType, Constants.THREE)) {
            return "一年一付";
        }
        return "一次性付款";
    }

    private String resolveFreeRentPeriod(YwContract contract) {
        Date start;
        Date end;
        if (Objects.equals(contract.getType(), Constants.ONE)) {
            start = contract.getWyFreeStartDate();
            end = contract.getWyFreeEndDate();
        } else {
            start = contract.getZlFreeStartDate();
            end = contract.getZlFreeEndDate();
        }
        if (start == null && end == null) {
            return "-";
        }
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String startText = start != null ? sdf.format(start) : "-";
        String endText = end != null ? sdf.format(end) : "-";
        return startText + " ~ " + endText;
    }

    private Map<Integer, List<YwContractBill>> loadContractBillMap(List<Integer> contractIds) {
        if (CollectionUtils.isEmpty(contractIds)) {
            return Collections.emptyMap();
        }
        List<YwContractBill> bills = ywContractBillMapper.selectList(new QueryWrapper<YwContractBill>().lambda()
                .in(YwContractBill::getContractId, contractIds)
                .eq(YwContractBill::getIsdeleted, Constants.ZERO)
                .orderByDesc(YwContractBill::getPlanPayDate));
        return bills.stream().collect(Collectors.groupingBy(YwContractBill::getContractId));
    }

    private void fillBillStatusTip(YwContract contract, List<YwContractBill> bills) {
        int overdue = 0;
        int dueSoon = 0;
        long now = System.currentTimeMillis();
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, BILL_DUE_SOON_DAYS);
        long dueSoonLimit = Utils.Date.getDayEnd(cal.getTime()).getTime();
        for (YwContractBill bill : bills) {
            if (!isBillCountable(bill) || !isBillUnpaid(bill) || bill.getPlanPayDate() == null) {
                continue;
            }
            long planEnd = Utils.Date.getEnd(bill.getPlanPayDate()).getTime();
            if (planEnd < now) {
                overdue++;
            } else if (planEnd <= dueSoonLimit) {
                dueSoon++;
            }
        }
        if (overdue > 0) {
            contract.setBillStatusTip(overdue + "个账单已逾期，请尽快支付");
            contract.setBillStatusType("danger");
        } else if (dueSoon > 0) {
            contract.setBillStatusTip(dueSoon + "个账单即将到期，请及时支付");
            contract.setBillStatusType("warn");
        } else {
            contract.setBillStatusTip("账单都按时缴费了，很棒！");
            contract.setBillStatusType("ok");
        }
    }

    private boolean isBillCountable(YwContractBill bill) {
        if (bill == null || Objects.equals(bill.getIsdeleted(), Constants.ONE)) {
            return false;
        }
        if (!Constants.equalsInteger(bill.getStatus(), Constants.ZERO)) {
            return false;
        }
        return bill.getReceivableFee() != null && bill.getReceivableFee().compareTo(BigDecimal.ZERO) > 0;
    }

    private boolean isBillUnpaid(YwContractBill bill) {
        Integer payStatus = bill.getPayStatus();
        if (Constants.equalsInteger(payStatus, Constants.ONE) || Constants.equalsInteger(payStatus, Constants.FIVE)) {
            return false;
        }
        return Constants.equalsInteger(payStatus, Constants.ZERO)
                || Constants.equalsInteger(payStatus, Constants.TWO)
                || Constants.equalsInteger(payStatus, Constants.THREE)
                || Constants.equalsInteger(payStatus, Constants.FOUR);
    }

    private void initContractDetails(YwContract contract) {
        if (contract == null || contract.getId() == null) {
            return;
        }
        contract.setZlDetailList(ywContractDetailMapper.selectJoinList(YwContractDetail.class,
                new MPJLambdaWrapper<YwContractDetail>()
                        .selectAll(YwContractDetail.class)
                        .eq(YwContractDetail::getIsdeleted, Constants.ZERO)
                        .eq(YwContractDetail::getContractId, contract.getId())
                        .in(YwContractDetail::getType, Constants.ZERO, Constants.TWO)
                        .orderByAsc(YwContractDetail::getSortnum)));
        contract.setWyDetailList(ywContractDetailMapper.selectJoinList(YwContractDetail.class,
                new MPJLambdaWrapper<YwContractDetail>()
                        .selectAll(YwContractDetail.class)
                        .eq(YwContractDetail::getIsdeleted, Constants.ZERO)
                        .eq(YwContractDetail::getContractId, contract.getId())
                        .in(YwContractDetail::getType, Constants.ONE, Constants.THREE)
                        .orderByAsc(YwContractDetail::getSortnum)));
    }

    private void initContractFiles(YwContract contract) {
        List<Multifile> multifiles = multifileMapper.selectJoinList(Multifile.class, new MPJLambdaWrapper<Multifile>()
                .selectAll(Multifile.class)
                .eq(Multifile::getObjId, contract.getId())
                .eq(Multifile::getObjType, Constants.MultiFile.YW_CONTRACT_FILE.getKey())
                .eq(Multifile::getIsdeleted, Constants.ZERO)
                .orderByAsc(Multifile::getSortnum));
        if (CollectionUtils.isEmpty(multifiles)) {
            contract.setFileList(Collections.emptyList());
            return;
        }
        String path = systemDictDataBiz.queryByCode(Constants.FTP, Constants.FTP_RESOURCE_PATH).getCode()
                + systemDictDataBiz.queryByCode(Constants.FTP, Constants.YW_CONTRACT_FILE).getCode();
        List<Multifile> fileList = new ArrayList<>();
        for (Multifile file : multifiles) {
            if (StringUtils.isBlank(file.getFileurl())) {
                continue;
            }
            file.setFileurlFull(path + file.getFileurl());
            fileList.add(file);
        }
        contract.setFileList(fileList);
    }

    private void enrichBillsWithContract(List<YwContractBill> bills) {
        if (CollectionUtils.isEmpty(bills)) {
            return;
        }
        List<Integer> contractIds = bills.stream()
                .map(YwContractBill::getContractId)
                .filter(Objects::nonNull)
                .distinct()
                .collect(Collectors.toList());
        if (contractIds.isEmpty()) {
            return;
        }
        Map<Integer, YwContract> contractMap = ywContractMapper.selectBatchIds(contractIds).stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toMap(YwContract::getId, c -> c, (a, b) -> a));
        for (YwContractBill bill : bills) {
            applyContractToBill(bill, contractMap.get(bill.getContractId()));
        }
    }

    private void enrichBillWithContract(YwContractBill bill) {
        if (bill == null || bill.getContractId() == null) {
            return;
        }
        YwContract contract = ywContractMapper.selectById(bill.getContractId());
        applyContractToBill(bill, contract);
        if (contract != null && contract.getRenterId() != null) {
            YwCustomer customer = ywCustomerMapper.selectById(contract.getRenterId());
            if (customer != null) {
                bill.setCustomerName(customer.getName());
            }
        }
    }

    private void enrichBillWithRooms(YwContractBill bill) {
        if (bill == null || bill.getContractId() == null) {
            return;
        }
        List<YwRoom> rooms = loadContractRoomMap(Collections.singletonList(bill.getContractId()))
                .getOrDefault(bill.getContractId(), Collections.emptyList());
        bill.setRoomList(rooms);
        bill.setRoomInfo(buildRoomInfo(rooms));
    }

    private void applyContractToBill(YwContractBill bill, YwContract contract) {
        if (bill == null || contract == null) {
            return;
        }
        bill.setContractCode(contract.getCode());
        bill.setContractStartDate(contract.getStartDate());
        bill.setContractEndDate(contract.getEndDate());
    }

    private List<YwContractBill> listContractBillsForH5(Integer contractId, Integer billType) {
        List<YwContractBill> bills = ywContractBillMapper.selectJoinList(YwContractBill.class,
                new MPJLambdaWrapper<YwContractBill>()
                        .selectAll(YwContractBill.class)
                        .select(" ( select ifnull( sum( CASE WHEN t.bill_type = 0 and yw.REVENUE_TYPE = 0 THEN yw.ACT_RECEIVABLE_FEE when  t.bill_type = 0 and yw.REVENUE_TYPE = 1 then -yw.ACT_RECEIVABLE_FEE  when t.bill_type = 1 and yw.REVENUE_TYPE = 0 then -yw.ACT_RECEIVABLE_FEE else  yw.ACT_RECEIVABLE_FEE END),0) from  yw_contract_revenue yw where yw.bill_id = t.id and yw.status = 0 and yw.isdeleted = 0 ) as  actReceivableFee  ")
                        .eq(YwContractBill::getIsdeleted, Constants.ZERO)
                        .eq(YwContractBill::getStatus, Constants.ZERO)
                        .eq(YwContractBill::getContractId, contractId)
                        .eq(YwContractBill::getBillType, billType != null ? billType : Constants.ZERO)
                        .orderByDesc(YwContractBill::getPlanPayDate)
                        .orderByDesc(YwContractBill::getId));
        enrichContractBillsForH5(bills);
        return bills;
    }

    private void enrichContractBillsForH5(List<YwContractBill> bills) {
        if (CollectionUtils.isEmpty(bills)) {
            return;
        }
        for (YwContractBill bill : bills) {
            if (bill.getReceivableFee() != null && bill.getActReceivableFee() != null) {
                bill.setNeedReceivableFee(bill.getReceivableFee().subtract(bill.getActReceivableFee()));
            }
            if (Constants.equalsInteger(bill.getStatus(), Constants.ZERO)
                    && (Constants.equalsInteger(bill.getPayStatus(), Constants.ZERO)
                    || Constants.equalsInteger(bill.getPayStatus(), Constants.TWO)
                    || Constants.equalsInteger(bill.getPayStatus(), Constants.THREE)
                    || Constants.equalsInteger(bill.getPayStatus(), Constants.FOUR))
                    && bill.getPlanPayDate() != null
                    && Utils.Date.getEnd(bill.getPlanPayDate()).getTime() < System.currentTimeMillis()) {
                bill.setIsOverdue(Constants.ONE);
            } else {
                bill.setIsOverdue(Constants.ZERO);
            }
        }
    }

    /**
     * 与 PC 端收支流水一致：经账单关联合同承租人，填充对方单位名称
     */
    private List<YwContractRevenue> listBillRevenues(Integer billId, YwContractBill bill) {
        List<YwContractRevenue> revenues = ywContractRevenueMapper.selectJoinList(YwContractRevenue.class, new MPJLambdaWrapper<YwContractRevenue>()
                .selectAll(YwContractRevenue.class)
                .selectAs(YwCustomer::getName, YwContractRevenue::getCustomerName)
                .leftJoin(YwContractBill.class, YwContractBill::getId, YwContractRevenue::getBillId)
                .leftJoin(YwContract.class, YwContract::getId, YwContractBill::getContractId)
                .leftJoin(YwCustomer.class, YwCustomer::getId, YwContract::getRenterId)
                .eq(YwContractRevenue::getStatus, Constants.ZERO)
                .eq(YwContractRevenue::getBillId, billId)
                .orderByDesc(YwContractRevenue::getId));
        fillRevenueCustomerNames(revenues, bill);
        return revenues;
    }

    private void fillRevenueCustomerNames(List<YwContractRevenue> revenues, YwContractBill bill) {
        if (CollectionUtils.isEmpty(revenues) || bill == null || StringUtils.isBlank(bill.getCustomerName())) {
            return;
        }
        for (YwContractRevenue revenue : revenues) {
            if (StringUtils.isBlank(revenue.getCustomerName())) {
                revenue.setCustomerName(bill.getCustomerName());
            }
        }
    }

    private BigDecimal sumPaid(List<YwContractRevenue> revenues, Integer billType) {
        if (CollectionUtils.isEmpty(revenues)) return BigDecimal.ZERO;
        BigDecimal total = BigDecimal.ZERO;
        for (YwContractRevenue r : revenues) {
            if (r.getActReceivableFee() == null) continue;
            int sign = Constants.equalsInteger(r.getRevenueType(), Constants.ZERO) ? 1 : -1;
            if (Constants.equalsInteger(billType, Constants.ONE)) sign = -sign;
            total = total.add(r.getActReceivableFee().multiply(BigDecimal.valueOf(sign)));
        }
        return total;
    }

    private PageData<YwContractBill> emptyBillPage(PageWrap<?> pageWrap) {
        PageData<YwContractBill> data = new PageData<>();
        data.setRecords(Collections.emptyList());
        data.setTotal(0);
        data.setPage(pageWrap.getPage());
        data.setCapacity(pageWrap.getCapacity());
        return data;
    }
}