package com.doumee.service.business.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.model.LoginUserInfo;
import com.doumee.core.utils.Constants;
import com.doumee.dao.business.*;
import com.doumee.dao.business.dto.YwCustomerGsConfigDTO;
import com.doumee.dao.business.model.*;
import com.doumee.service.business.YwCustomerDeviceAutoBindService;
import com.doumee.service.business.YwCustomerRechargeBizService;
import lombok.extern.slf4j.Slf4j;
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.util.*;
import java.util.stream.Collectors;

@Service
@Slf4j
public class YwCustomerDeviceAutoBindServiceImpl implements YwCustomerDeviceAutoBindService {

    private static final int BIND_SOURCE_CONTRACT = 1;

    @Autowired
    private YwContractMapper ywContractMapper;
    @Autowired
    private YwContractRoomMapper ywContractRoomMapper;
    @Autowired
    private YwElectricalRoomMapper ywElectricalRoomMapper;
    @Autowired
    private YwCustomerElectricalMapper ywCustomerElectricalMapper;
    @Autowired
    private YwCustomerConditionerMapper ywCustomerConditionerMapper;
    @Autowired
    private YwConditionerMapper ywConditionerMapper;
    @Autowired
    private YwCustomerRechargeBizService ywCustomerRechargeBizService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void syncByContractId(Integer contractId, LoginUserInfo user) {
        if (contractId == null) {
            return;
        }
        YwContract contract = ywContractMapper.selectById(contractId);
        if (contract == null || Objects.equals(contract.getIsdeleted(), Constants.ONE)) {
            return;
        }
        if (contract.getRenterId() == null) {
            return;
        }
        if (!isActiveContract(contract)) {
            return;
        }
        List<Integer> roomIds = listContractRoomIds(contractId);
        if (roomIds.isEmpty()) {
            return;
        }
        bindElectricals(contract, roomIds, user);
        bindConditioners(contract, roomIds, user);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void syncByCustomerId(Integer customerId, LoginUserInfo user) {
        if (customerId == null) {
            return;
        }
        List<YwContract> contracts = ywContractMapper.selectList(new QueryWrapper<YwContract>().lambda()
                .eq(YwContract::getRenterId, customerId)
                .eq(YwContract::getIsdeleted, Constants.ZERO)
                .in(YwContract::getStatus, Arrays.asList(Constants.ZERO, Constants.ONE, Constants.THREE)));
        for (YwContract c : contracts) {
            if (isActiveContract(c)) {
                syncByContractId(c.getId(), user);
            }
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void unbindByContractId(Integer contractId, LoginUserInfo user) {
        if (contractId == null) {
            return;
        }
        Date now = new Date();
        Integer editor = user != null ? user.getId() : null;
        ywCustomerElectricalMapper.update(null, new UpdateWrapper<YwCustomerElectrical>().lambda()
                .set(YwCustomerElectrical::getIsdeleted, Constants.ONE)
                .set(YwCustomerElectrical::getEditDate, now)
                .set(YwCustomerElectrical::getEditor, editor)
                .eq(YwCustomerElectrical::getContractId, contractId)
                .eq(YwCustomerElectrical::getBindSource, BIND_SOURCE_CONTRACT)
                .eq(YwCustomerElectrical::getIsdeleted, Constants.ZERO));
    }

    private boolean isActiveContract(YwContract contract) {
        if (contract.getStartDate() == null || contract.getEndDate() == null) {
            return false;
        }
        long now = System.currentTimeMillis();
        return contract.getStartDate().getTime() <= now
                && contract.getEndDate().getTime() >= now
                && !Objects.equals(contract.getStatus(), Constants.FOUR);
    }

    private List<Integer> listContractRoomIds(Integer contractId) {
        return ywContractRoomMapper.selectList(new QueryWrapper<YwContractRoom>().lambda()
                        .eq(YwContractRoom::getContractId, contractId)
                        .eq(YwContractRoom::getType, Constants.ZERO)
                        .eq(YwContractRoom::getIsdeleted, Constants.ZERO))
                .stream().map(YwContractRoom::getRoomId).filter(Objects::nonNull).distinct()
                .collect(Collectors.toList());
    }

    private void bindElectricals(YwContract contract, List<Integer> roomIds, LoginUserInfo user) {
        List<YwElectricalRoom> relRooms = ywElectricalRoomMapper.selectList(new QueryWrapper<YwElectricalRoom>().lambda()
                .in(YwElectricalRoom::getRoomId, roomIds)
                .eq(YwElectricalRoom::getType, Constants.ZERO)
                .eq(YwElectricalRoom::getIsdeleted, Constants.ZERO));
        Set<Integer> electricalIds = relRooms.stream().map(YwElectricalRoom::getObjId)
                .filter(Objects::nonNull).collect(Collectors.toCollection(LinkedHashSet::new));
        if (electricalIds.isEmpty()) {
            return;
        }
        Set<Integer> boundOthers = listBoundElectricalIdsExcept(contract.getRenterId());
        Date now = new Date();
        for (Integer eid : electricalIds) {
            if (boundOthers.contains(eid)) {
                log.warn("skip electrical {} already bound to other customer", eid);
                continue;
            }
            YwCustomerElectrical exist = ywCustomerElectricalMapper.selectOne(new QueryWrapper<YwCustomerElectrical>().lambda()
                    .eq(YwCustomerElectrical::getCustomerId, contract.getRenterId())
                    .eq(YwCustomerElectrical::getElectricalId, eid)
                    .eq(YwCustomerElectrical::getIsdeleted, Constants.ZERO)
                    .last("limit 1"));
            if (exist != null) {
                if (exist.getContractId() == null) {
                    exist.setContractId(contract.getId());
                    exist.setBindSource(BIND_SOURCE_CONTRACT);
                    exist.setEditDate(now);
                    exist.setEditor(user != null ? user.getId() : null);
                    ywCustomerElectricalMapper.updateById(exist);
                }
                continue;
            }
            YwCustomerElectrical rel = new YwCustomerElectrical();
            rel.setCreator(user != null ? user.getId() : null);
            rel.setCreateDate(now);
            rel.setEditor(user != null ? user.getId() : null);
            rel.setEditDate(now);
            rel.setIsdeleted(Constants.ZERO);
            rel.setCustomerId(contract.getRenterId());
            rel.setElectricalId(eid);
            rel.setBindSource(BIND_SOURCE_CONTRACT);
            rel.setContractId(contract.getId());
            ywCustomerElectricalMapper.insert(rel);
        }
    }

    private void bindConditioners(YwContract contract, List<Integer> roomIds, LoginUserInfo user) {
        Set<Integer> conditionerIds = new LinkedHashSet<>();
        List<YwElectricalRoom> acRooms = ywElectricalRoomMapper.selectList(new QueryWrapper<YwElectricalRoom>().lambda()
                .in(YwElectricalRoom::getRoomId, roomIds)
                .eq(YwElectricalRoom::getType, Constants.ONE)
                .eq(YwElectricalRoom::getIsdeleted, Constants.ZERO));
        acRooms.stream().map(YwElectricalRoom::getObjId).filter(Objects::nonNull).forEach(conditionerIds::add);
        if (conditionerIds.isEmpty()) {
            List<YwConditioner> byRoom = ywConditionerMapper.selectList(new QueryWrapper<YwConditioner>().lambda()
                    .in(YwConditioner::getRoomId, roomIds)
                    .eq(YwConditioner::getIsdeleted, Constants.ZERO));
            byRoom.stream().map(YwConditioner::getId).forEach(conditionerIds::add);
        }
        if (conditionerIds.isEmpty()) {
            return;
        }
        YwCustomerGsConfigDTO dto = new YwCustomerGsConfigDTO();
        dto.setCustomerId(contract.getRenterId());
        dto.setIsPwr(Constants.ONE);
        dto.setIsRestStop(Constants.ZERO);
        dto.setGsBz("合同自动关联");
        dto.setStopMoney(BigDecimal.ZERO);
        List<YwCustomerGsConfigDTO.ConditionerItem> items = new ArrayList<>();
        for (Integer cid : conditionerIds) {
            YwCustomerGsConfigDTO.ConditionerItem item = new YwCustomerGsConfigDTO.ConditionerItem();
            item.setConditionerId(cid);
            item.setDevRatio(100);
            items.add(item);
        }
        dto.setConditioners(items);
        try {
            ywCustomerRechargeBizService.saveCustomerGsConfig(dto, user != null ? user : systemUser());
        } catch (BusinessException e) {
            log.warn("auto bind conditioner GS failed contractId={}: {}", contract.getId(), e.getMessage());
        }
    }

    private Set<Integer> listBoundElectricalIdsExcept(Integer customerId) {
        List<YwCustomerElectrical> list = ywCustomerElectricalMapper.selectList(new QueryWrapper<YwCustomerElectrical>().lambda()
                .eq(YwCustomerElectrical::getIsdeleted, Constants.ZERO)
                .ne(customerId != null, YwCustomerElectrical::getCustomerId, customerId));
        return list.stream().map(YwCustomerElectrical::getElectricalId).collect(Collectors.toSet());
    }

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