package cn.fw.valhalla.service.bus.follow;

import cn.fw.common.cache.locker.DistributedLocker;
import cn.fw.common.page.AppPage;
import cn.fw.common.web.auth.LoginAuthBean;
import cn.fw.valhalla.common.utils.DateUtil;
import cn.fw.valhalla.domain.db.ApproveRecord;
import cn.fw.valhalla.domain.db.OriginalData;
import cn.fw.valhalla.domain.db.SecretReportHistory;
import cn.fw.valhalla.domain.db.follow.FollowRecord;
import cn.fw.valhalla.domain.db.follow.FollowRecordLog;
import cn.fw.valhalla.domain.db.follow.FollowTask;
import cn.fw.valhalla.domain.db.pool.CustomerCluePool;
import cn.fw.valhalla.domain.dto.CallReportDTO;
import cn.fw.valhalla.domain.dto.FollowAttachmentDTO;
import cn.fw.valhalla.domain.enums.*;
import cn.fw.valhalla.domain.query.FollowQueryVO;
import cn.fw.valhalla.domain.vo.follow.FollowDetailVO;
import cn.fw.valhalla.domain.vo.follow.FollowRecordVO;
import cn.fw.valhalla.domain.vo.follow.FollowTodoListVO;
import cn.fw.valhalla.domain.vo.setting.SettingVO;
import cn.fw.valhalla.rpc.erp.UserService;
import cn.fw.valhalla.rpc.erp.dto.UserInfoDTO;
import cn.fw.valhalla.rpc.flow.FlowApproveRpc;
import cn.fw.valhalla.rpc.flow.dto.FlowDto;
import cn.fw.valhalla.sdk.enums.DataTypeEnum;
import cn.fw.valhalla.service.bus.follow.strategy.FollowStrategy;
import cn.fw.valhalla.service.data.*;
import cn.fw.valhalla.service.event.TaskCancelEvent;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.tuple.Pair;
import org.redisson.api.RLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;

import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import static cn.fw.common.businessvalidator.Validator.BV;

/**
 * @author : kurisu
 * @className : FollowBizService
 * @description : 跟进业务服务
 * @date: 2020-08-14 17:27
 */
@Slf4j
@Service
public class FollowBizService {
    /**
     * 跟进处理器map
     */
    private final Map<FollowTypeEnum, FollowStrategy> followMap;
    private final FlowApproveRpc flowApproveRpc;
    private final ApproveRecordService approveRecordService;
    private final FollowTaskService followTaskService;
    private final FollowRecordService followRecordService;
    private final UserService userService;
    private final DistributedLocker distributedLocker;
    private final CustomerCluePoolService customerCluePoolService;
    private final SecretReportHistoryService secretReportHistoryService;
    private final FollowRecordLogService followRecordLogService;

    @Value("${follow.flowNo}")
    @Getter
    private String flowNo;

    @Value("${spring.cache.custom.global-prefix}:defeat")
    @Getter
    private String keyPrefix;

    @Autowired
    public FollowBizService(final List<FollowStrategy> followStrategyList,
                            final FlowApproveRpc flowApproveRpc,
                            final ApproveRecordService approveRecordService,
                            final FollowTaskService followTaskService,
                            final FollowRecordService followRecordService,
                            final UserService userService,
                            final DistributedLocker distributedLocker,
                            final CustomerCluePoolService customerCluePoolService,
                            final SecretReportHistoryService secretReportHistoryService,
                            final FollowRecordLogService followRecordLogService) {
        this.followMap = followStrategyList.stream().collect(Collectors.toMap(FollowStrategy::getFollowType, v -> v));
        this.flowApproveRpc = flowApproveRpc;
        this.approveRecordService = approveRecordService;
        this.followTaskService = followTaskService;
        this.followRecordService = followRecordService;
        this.userService = userService;
        this.distributedLocker = distributedLocker;
        this.customerCluePoolService = customerCluePoolService;
        this.secretReportHistoryService = secretReportHistoryService;
        this.followRecordLogService = followRecordLogService;
    }

    /**
     * 查询待办列表
     *
     * @param queryVO
     * @param currentUser
     * @return
     */
    public AppPage<FollowTodoListVO> todoList(FollowQueryVO queryVO, LoginAuthBean currentUser) {
        Integer pageSize = queryVO.getPageSize();
        Integer current = queryVO.getCurrent();
        Integer startIndex = (current - 1) * pageSize;
        FollowStrategy strategy = followMap.get(queryVO.getType());
        Assert.notNull(strategy, "strategy cannot be null");
        List<FollowTodoListVO> list = strategy.getList(startIndex, pageSize, currentUser.getUserId());
        AppPage<FollowTodoListVO> appPage = AppPage.empty(queryVO);
        appPage.setData(list);
        return appPage;
    }

    /**
     * 查询待办详情
     *
     * @param id
     * @param type
     * @return
     */
    public FollowDetailVO todoDetail(Long id, FollowTypeEnum type) {
        FollowStrategy strategy = followMap.get(type);
        Assert.notNull(strategy, "strategy cannot be null");
        return strategy.getDetail(id);
    }

    /**
     * 查询跟进历史
     *
     * @param taskId
     * @param type
     * @return
     */
    public List<FollowRecordVO> todoRecord(Long taskId, Integer type) {
        FollowTypeEnum typeEnum = FollowTypeEnum.ofValue(type);
        if (Objects.isNull(typeEnum)) {
            FollowTask task = followTaskService.getById(taskId);
            BV.notNull(task, () -> "跟进任务不存在");
            typeEnum = task.getType();
        }
        FollowStrategy strategy = followMap.get(typeEnum);
        BV.notNull(strategy, () -> "跟进类型不正确");
        return strategy.getRecordList(taskId);
    }

    /**
     * 查询跟进池详情
     *
     * @param taskId
     * @return
     */
    public FollowDetailVO followPoolDetail(Long taskId) {
        FollowTask task = followTaskService.getById(taskId);
        BV.notNull(task, () -> "跟进线索不存在，请刷新列表");
        FollowStrategy strategy = followMap.get(task.getType());
        Assert.notNull(strategy, "strategy cannot be null");
        return strategy.followPoolDetail(task);
    }

    /**
     * 完成跟进
     *
     * @param id
     * @param currentUser
     */
    @Transactional(rollbackFor = Exception.class)
    public void completeRecord(Long id, FollowTypeEnum type, LoginAuthBean currentUser) {
        FollowStrategy strategy = followMap.get(type);
        Assert.notNull(strategy, "strategy cannot be null");
        strategy.completeRecord(id, currentUser);
    }

    /**
     * 完成跟进
     *
     * @param record
     */
    @Transactional(rollbackFor = Exception.class)
    public void completeRecordAndEnd(FollowRecord record) {
        FollowStrategy strategy = followMap.get(record.getType());
        Assert.notNull(strategy, "strategy cannot be null");
        strategy.completeRecordAndEnd(record);
    }

    /**
     * 首保流失客户二次分配后更新跟进任务
     *
     * @param customerId
     * @param type
     */
    @Transactional(rollbackFor = Exception.class)
    public void updateTask(Long customerId, FollowTypeEnum type) {
        FollowStrategy strategy = followMap.get(type);
        Assert.notNull(strategy, "strategy cannot be null");
        strategy.updateTask(customerId);
    }

    /**
     * 开始任务
     *
     * @param task
     */
    @Transactional(rollbackFor = Exception.class)
    public void startTask(FollowTask task) {
        FollowStrategy strategy = followMap.get(task.getType());
        Assert.notNull(strategy, "strategy cannot be null");
        strategy.startTask(task, true);
    }

    /**
     * 查询待办详情
     *
     * @param id
     * @param type
     * @return
     */
    public FollowDetailVO approveDetail(Long id, Integer type) {
        FollowTypeEnum typeEnum = FollowTypeEnum.ofValue(type);
        if (Objects.isNull(typeEnum)) {
            FollowRecord record = followRecordService.getById(id);
            BV.notNull(record, () -> "跟进记录不存在");
            typeEnum = record.getType();
        }
        FollowStrategy strategy = followMap.get(typeEnum);
        BV.notNull(strategy, () -> "跟进类型不正确");
        FollowDetailVO detail = strategy.getDetail(id);
        detail.setType(typeEnum.getValue());
        ApproveRecord approveRecord = approveRecordService.getOne(Wrappers.<ApproveRecord>lambdaQuery()
                .eq(ApproveRecord::getDataId, detail.getTaskId())
                .last("limit 1")
        );
        if (Objects.nonNull(approveRecord)) {
            UserInfoDTO user = userService.user(approveRecord.getUserId());
            if (Objects.nonNull(user)) {
                detail.setAdviserId(user.getId());
                detail.setAdviserName(user.getUserName());
            }
            detail.setReason(approveRecord.getReason());
        }
        return detail;
    }

    /**
     * 主动战败
     *
     * @param currentUser
     * @param reason
     * @param recordId
     */
    @Transactional(rollbackFor = Exception.class)
    public void defeat(LoginAuthBean currentUser, String reason, Long recordId) {
        final String lockKey = getLockKey(recordId);
        Pair<Boolean, RLock> pair = distributedLocker.tryLock(lockKey, TimeUnit.SECONDS, 0, 15);
        BV.isTrue(Boolean.TRUE.equals(pair.getKey()), () -> "请勿重复提交");
        try {
            FollowRecord record = followRecordService.getById(recordId);
            BV.notNull(record, () -> "跟进记录不存在");
            FollowTask task = followTaskService.getById(record.getTaskId());
            BV.notNull(task, () -> "跟进信息不存在");
            boolean repetition = isRepetition(record.getTaskId().toString());
            BV.isFalse(repetition, () -> "正在审批处理中，请勿重复申请");
            FlowDto flowDto = FlowDto.create(currentUser.getGroupId(), getFlowNo(), currentUser.getUserId(), currentUser.getUserName(), task.getFollowShop());
            HashMap<String, String> param = new HashMap<>(2);
            param.put("recordId", recordId.toString());
            param.put("type", task.getType().getValue().toString());
            flowDto.setParam(param);
            String name = "";
            String plate = "";
            FollowStrategy strategy = followMap.get(task.getType());
            Assert.notNull(strategy, "strategy cannot be null");
            FollowDetailVO vo = strategy.followPoolDetail(task);
            if (Objects.nonNull(vo)) {
                name = vo.getName();
                plate = vo.getPlateNo();
            }
            List<String> list = Arrays.asList(
                    "申请人: " + currentUser.getUserName(),
                    "客户: " + name,
                    "车辆: " + plate,
                    "跟进类型: " + task.getType().getName(),
                    "战败原因: " + reason
            );
            flowDto.setBriefContentList(list);
            String orderNo = flowApproveRpc.initiate(flowDto);
            ApproveRecord approveRecord = new ApproveRecord();
            approveRecord.setDataId(task.getId());
            approveRecord.setUserId(currentUser.getUserId());
            approveRecord.setOrderNo(orderNo);
            approveRecord.setReason(reason);
            approveRecord.setState(ApproveStateEnum.WAIT);
            approveRecord.setType(ApproveTypeEnum.FOLLOW_DEFEAT);
            approveRecord.setPassed(Boolean.FALSE);
            approveRecord.setCreateTime(DateUtil.localDateTime2Date(LocalDateTime.now()));
            approveRecord.setUpdateTime(DateUtil.localDateTime2Date(LocalDateTime.now()));
            approveRecordService.save(approveRecord);
        } catch (Exception e) {
            distributedLocker.unlock(lockKey);
            throw e;
        }
    }

    /**
     * 上传跟进附件
     *
     * @param dto
     */
    @Transactional(rollbackFor = Exception.class)
    public void uploadAtt(FollowAttachmentDTO dto, LoginAuthBean currentUser) {
        FollowStrategy strategy = followMap.get(dto.getFollowTypeEnum());
        Assert.notNull(strategy, "strategy cannot be null");
        strategy.uploadAtt(dto, currentUser.getUserId());
    }

    /**
     * 更新跟进任务
     *
     * @param setting
     * @param type
     * @param groupId
     */
    public void synFollowTask(List<SettingVO> setting, FollowTypeEnum type, Long groupId) {
        FollowStrategy strategy = followMap.get(type);
        Assert.notNull(strategy, "strategy cannot be null");
        strategy.settingChanged(setting, groupId);
    }

    /**
     * 当业务数据取消的时候
     *
     * @param event
     */
    public void onDataCancel(TaskCancelEvent event) {
        FollowTypeEnum typeEnum = conv(event.getDataTypeEnum());
        if (Objects.isNull(typeEnum) || FollowTypeEnum.AC.equals(typeEnum)) {
            return;
        }
        FollowStrategy strategy = followMap.get(typeEnum);
        Assert.notNull(strategy, "strategy cannot be null");
        strategy.cancelFollowTask(event.getCustomerId(), event.getGenerateTime(), event.getGroupId());
    }

    /**
     * 元数据生成任务
     *
     * @param originalData
     * @param typeEnum
     */
    public boolean origin2task(OriginalData originalData, DataTypeEnum typeEnum) {
        if (Objects.isNull(originalData)) {
            return true;
        }
        FollowTypeEnum type = conv(typeEnum);
        FollowStrategy strategy = followMap.get(type);
        Assert.notNull(strategy, "strategy cannot be null");
        try {
            return strategy.origin2task(originalData);
        } catch (Exception exception) {
            log.error("处理元数据失败 data: [{}]", originalData.toString(), exception);
            return false;
        }
    }

    /**
     * 创建跟进待办
     *
     * @param cluePool
     */
    public void startClue(CustomerCluePool cluePool) {
        FollowStrategy strategy = followMap.get(cluePool.getClueType());
        Assert.notNull(strategy, "strategy cannot be null");

        strategy.startClue(cluePool);
    }

    /**
     * 创建跟进待办
     *
     * @param task
     */
    @Transactional(rollbackFor = Exception.class)
    public void endTask(FollowTask task) {
        FollowStrategy strategy = followMap.get(task.getType());
        Assert.notNull(strategy, "strategy cannot be null");
        try {
            strategy.closeTask(task);
        } catch (Exception ex) {
            log.error("结束任务失败 taskId: [{}]", task.getId(), ex);
        }
    }


    /**
     * 逾期处理
     *
     * @param record
     */
    public void overdueProcessing(FollowRecord record) {
        FollowStrategy strategy = followMap.get(record.getType());
        Assert.notNull(strategy, "strategy cannot be null");

        strategy.overdueProcessing(record);
    }

    /**
     * 终止任务
     *
     * @param customerId
     * @param groupId
     */
    @Transactional(rollbackFor = Exception.class)
    public void stopTask(Long customerId, Long groupId) {
        List<FollowTypeEnum> typeList = Arrays.asList(FollowTypeEnum.FM, FollowTypeEnum.RM);
        List<CustomerCluePool> cluePoolList = customerCluePoolService.list(Wrappers.<CustomerCluePool>lambdaQuery()
                .eq(CustomerCluePool::getClueStatus, ClueStatusEnum.ONGOING)
                .in(CustomerCluePool::getClueType, typeList)
                .eq(CustomerCluePool::getRefererId, customerId)
                .eq(CustomerCluePool::getGroupId, groupId)
        );
        if (!CollectionUtils.isEmpty(cluePoolList)) {
            for (CustomerCluePool clue : cluePoolList) {
                FollowStrategy strategy = followMap.get(clue.getClueType());
                if (Objects.nonNull(strategy)) {
                    strategy.forceStopClue(clue);
                }
            }
        }
        List<CustomerCluePool> cluePoolWaitList = customerCluePoolService.list(Wrappers.<CustomerCluePool>lambdaQuery()
                .eq(CustomerCluePool::getClueStatus, ClueStatusEnum.WAITING)
                .in(CustomerCluePool::getClueType, typeList)
                .eq(CustomerCluePool::getRefererId, customerId)
                .eq(CustomerCluePool::getGroupId, groupId)
        );

        if (CollectionUtils.isEmpty(cluePoolWaitList)) {
            return;
        }
        List<Long> ids = cluePoolWaitList.stream().map(CustomerCluePool::getId).filter(Objects::nonNull).collect(Collectors.toList());
        if (!CollectionUtils.isEmpty(ids)) {
            customerCluePoolService.removeByIds(ids);
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void onForbidden(Long customerId, Long groupId) {
        List<FollowTypeEnum> typeList = Arrays.asList(FollowTypeEnum.FM, FollowTypeEnum.RM, FollowTypeEnum.IR);
        List<CustomerCluePool> cluePoolList = customerCluePoolService.list(Wrappers.<CustomerCluePool>lambdaQuery()
                .eq(CustomerCluePool::getClueStatus, ClueStatusEnum.ONGOING)
                .in(CustomerCluePool::getClueType, typeList)
                .eq(CustomerCluePool::getRefererId, customerId)
                .eq(CustomerCluePool::getGroupId, groupId)
        );
        if (!CollectionUtils.isEmpty(cluePoolList)) {
            for (CustomerCluePool clue : cluePoolList) {
                FollowStrategy strategy = followMap.get(clue.getClueType());
                if (Objects.nonNull(strategy)) {
                    strategy.onForbiddenStopClue(clue);
                }
            }
        }
        List<CustomerCluePool> cluePoolWaitList = customerCluePoolService.list(Wrappers.<CustomerCluePool>lambdaQuery()
                .eq(CustomerCluePool::getClueStatus, ClueStatusEnum.WAITING)
                .in(CustomerCluePool::getClueType, typeList)
                .eq(CustomerCluePool::getRefererId, customerId)
                .eq(CustomerCluePool::getGroupId, groupId)
        );

        if (!CollectionUtils.isEmpty(cluePoolWaitList)) {
            customerCluePoolService.removeByIds(cluePoolWaitList);
        }
    }

    /**
     * 终止任务
     *
     * @param task
     */
    @Transactional(rollbackFor = Exception.class)
    public void stopTask(FollowTask task) {
        CustomerCluePool cluePool = customerCluePoolService.getById(task.getClueId());
        FollowStrategy strategy = followMap.get(task.getType());
        if (Objects.nonNull(strategy)) {
            strategy.forceStopClue(cluePool);
        }
    }

    public void readCallReport(CallReportDTO dto, boolean accidentCar, Long... idArr) {
        if (Objects.isNull(dto) || idArr == null || idArr.length <= 0) {
            return;
        }
        final Long groupId = dto.getGroupId();
        final Long staffId = dto.getStaffId();
        final Long talkTime = dto.getTalkTime();
        if (Objects.isNull(talkTime) || talkTime <= 0) {
            return;
        }
        if (accidentCar) {
            CustomerCluePool cluePool = customerCluePoolService.getOne(Wrappers.<CustomerCluePool>lambdaQuery()
                    .eq(CustomerCluePool::getRefererId, idArr[0])
                    .eq(CustomerCluePool::getGroupId, groupId)
                    .eq(CustomerCluePool::getClueType, FollowTypeEnum.AC)
                    .eq(CustomerCluePool::getClueStatus, ClueStatusEnum.ONGOING)
                    .orderByDesc(CustomerCluePool::getId)
                    .last(" limit 1")
            );
            if (Objects.nonNull(cluePool)) {
                completeRecord(dto, cluePool.getId(), staffId, dto.getCallId());
            }
        } else {
            List<CustomerCluePool> list = customerCluePoolService.list(Wrappers.<CustomerCluePool>lambdaQuery()
                    .eq(CustomerCluePool::getGroupId, groupId)
                    .eq(CustomerCluePool::getClueStatus, ClueStatusEnum.ONGOING)
                    .in(CustomerCluePool::getRefererId, Arrays.asList(idArr))
            );
            if (!CollectionUtils.isEmpty(list)) {
                list.forEach(cluePool -> completeRecord(dto, cluePool.getId(), staffId, dto.getCallId()));
            }
        }
    }


    private FollowTypeEnum conv(DataTypeEnum type) {
        switch (type) {
            case AS:
                return FollowTypeEnum.AC;
            case OD:
            case FM:
                return FollowTypeEnum.FM;
            case BI:
                return FollowTypeEnum.IR;
            case FS:
                return FollowTypeEnum.RM;
            default:
                return null;
        }
    }

    private String getLockKey(Long recordId) {
        BV.notNull(recordId, "recordId cannot be null");

        return String.format("%s:lock:%s", getKeyPrefix(), recordId);
    }

    /**
     * 审批防重
     *
     * @param taskId
     * @return
     */
    private boolean isRepetition(String taskId) {
        return approveRecordService.count(Wrappers.<ApproveRecord>lambdaQuery()
                .eq(ApproveRecord::getDataId, taskId)
                .eq(ApproveRecord::getType, ApproveTypeEnum.FOLLOW_DEFEAT)
                .eq(ApproveRecord::getState, ApproveStateEnum.WAIT)
        ) > 0;
    }

    private void completeRecord(CallReportDTO reportDTO, final Long clueId, final Long staffId, final String callId) {
        FollowTask followTask = followTaskService.queryOngoingTaskByClueId(clueId);
        if (Objects.isNull(followTask)) {
            return;
        }
        FollowTypeEnum followType = followTask.getType();
        List<FollowRecord> list = followRecordService.list(Wrappers.<FollowRecord>lambdaQuery()
                .eq(FollowRecord::getTaskId, followTask.getId())
                .eq(FollowRecord::getUserId, staffId)
                .eq(FollowRecord::getType, followType)
                .eq(FollowRecord::getAddTodo, Boolean.TRUE)
                .eq(FollowRecord::getOutTime, Boolean.FALSE)
                .isNull(FollowRecord::getFollowTime)
        );
        if (CollectionUtils.isEmpty(list)) {
            return;
        }

        FollowStrategy strategy = followMap.get(followType);
        Assert.notNull(strategy, "strategy cannot be null");
        List<SecretReportHistory> reportHistoryList = new ArrayList<>();

        for (FollowRecord record : list) {
            FollowAttachmentDTO dto = new FollowAttachmentDTO();
            dto.setAttachments(callId);
            dto.setTaskId(record.getTaskId());
            dto.setFollowType(followType.getValue());
            dto.setRecordId(record.getId());
            dto.setFeedbackType(FollowTypeEnum.AC.equals(followType) ? FeedbackTypeEnum.OTHER.getValue() : null);
            dto.setAttType(AttTypeEnum.SMART_PHONE.getValue());
            strategy.uploadAtt(dto, staffId);
            reportHistoryList.add(createHistory(reportDTO, record, followType));
        }
        secretReportHistoryService.saveBatch(reportHistoryList);
    }


    private SecretReportHistory createHistory(CallReportDTO reportDTO, FollowRecord record, FollowTypeEnum followTypeEnum) {
        SecretReportHistory history = new SecretReportHistory();
        history.setTaskId(record.getTaskId());
        history.setTaskType(followTypeEnum);
        history.setFollowRecordId(record.getId());
        history.setCallId(reportDTO.getCallId());
        history.setStaffId(reportDTO.getStaffId());
        history.setStaffName(reportDTO.getStaffName());
        history.setCustomerId(record.getCustomerId());
        history.setCallType(reportDTO.getDialType());
        history.setCallTime(reportDTO.getCallTime());
        history.setCallDuration(reportDTO.getTalkTime());
        history.setShopId(record.getShopId());
        history.setGroupId(record.getGroupId());
        int count = followRecordLogService.count(Wrappers.<FollowRecordLog>lambdaQuery()
                .eq(FollowRecordLog::getTaskId, record.getTaskId())
                .eq(FollowRecordLog::getAttType, AttTypeEnum.SMART_PHONE)
        );
        history.setFirstCall(count <= 0);
        return history;
    }
}