package com.xiaopeng.vehicleConvoy.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xiaopeng.api.feignClient.account.SysUserClient;
import com.xiaopeng.api.feignClient.account.XpOperationUserClient;
import com.xiaopeng.api.feignClient.vehicleConvoy.XpVehicleClient;
import com.xiaopeng.api.model.account.SysUser;
import com.xiaopeng.api.model.account.XpOperationsUser;
import com.xiaopeng.api.model.vehicleConvoy.XpPolicyApplication;
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
import com.xiaopeng.common.core.domain.R;
import com.xiaopeng.common.core.enums.AuditStateEnum;
import com.xiaopeng.common.core.enums.PolicyApplicationAuditStateEnum;
import com.xiaopeng.common.core.web.page.PageInfo;
import com.xiaopeng.common.security.utils.SecurityUtils;
import com.xiaopeng.vehicleConvoy.mapper.XpPolicyApplicationMapper;
import com.xiaopeng.vehicleConvoy.mapper.XpVehicleMapper;
import com.xiaopeng.vehicleConvoy.model.dto.XpPolicyApplicationAuditDTO;
import com.xiaopeng.vehicleConvoy.model.query.XpPolicyApplicationQuery;
import com.xiaopeng.vehicleConvoy.model.vo.QueryPolicyInfoVO;
import com.xiaopeng.vehicleConvoy.model.vo.XpPolicyApplicationVO;
import com.xiaopeng.vehicleConvoy.service.IXpPolicyApplicationService;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * <p>
 * 保单申请 服务实现类
 * </p>
 *
 * @author mitao
 * @since 2026-02-03
 */
@Service
@RequiredArgsConstructor(onConstructor_ = @Lazy)
public class XpPolicyApplicationServiceImpl extends ServiceImpl<XpPolicyApplicationMapper, XpPolicyApplication> implements IXpPolicyApplicationService {

    private final XpOperationUserClient xpOperationUserClient;
    private final XpVehicleClient xpVehicleClient;
    private final SysUserClient sysUserClient;
    private final XpVehicleMapper xpVehicleMapper;

    @Override
    public PageInfo<XpPolicyApplicationVO> pageList(XpPolicyApplicationQuery query) {
        PageInfo<XpPolicyApplicationVO> resultPage = new PageInfo<>(query.getPageNum(), query.getPageSize());
        // 1. 根据运维人员名称查询运维人员ID列表
        List<Long> operationUserIds = null;
        List<Long> vehicleIds = null;
        if (StringUtils.isNotBlank(query.getNickName())) {
            R<List<XpOperationsUser>> userData = xpOperationUserClient.listByName(query.getNickName());
            if (R.isSuccess(userData)) {
                if (CollUtil.isEmpty(userData.getData())) {
                    return resultPage;
                }
                operationUserIds = userData.getData().stream().map(XpOperationsUser::getId).collect(Collectors.toList());
            }
        }

        // 2.根据车牌号获取车辆ID列表
        if (StringUtils.isNotBlank(query.getPlateNumber())) {
            R<List<XpVehicle>> vehicleData = xpVehicleClient.listByPlateNumber(query.getPlateNumber());
            if (R.isSuccess(vehicleData)) {
                vehicleIds = vehicleData.getData().stream().map(XpVehicle::getId).collect(Collectors.toList());
            }
        }

        // 3.分页查询保单申请列表
        LambdaQueryWrapper<XpPolicyApplication> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        if (Objects.nonNull(query.getStartTime())) {
            lambdaQueryWrapper.ge(XpPolicyApplication::getCreateTime, LocalDateTime.of(query.getStartTime(), LocalTime.MIN));
        }
        if (Objects.nonNull(query.getStartTime())) {
            lambdaQueryWrapper.le(XpPolicyApplication::getCreateTime, LocalDateTime.of(query.getEndTime(), LocalTime.MAX));
        }
        lambdaQueryWrapper.in(CollUtil.isNotEmpty(operationUserIds), XpPolicyApplication::getApplicantId, operationUserIds)
                .in(CollUtil.isNotEmpty(vehicleIds), XpPolicyApplication::getVehicleId, vehicleIds)
                .eq(Objects.nonNull(query.getAuditStatus()), XpPolicyApplication::getAuditStatus, query.getAuditStatus())
                .orderByDesc(XpPolicyApplication::getCreateTime);
        Page<XpPolicyApplication> page = page(new Page<>(query.getPageNum(), query.getPageSize()), lambdaQueryWrapper);
        //4.批量获取相关用户和车辆信息
        Set<Long> operationsUserIdSet = page.getRecords().stream().map(XpPolicyApplication::getApplicantId).filter(Objects::nonNull).collect(Collectors.toSet());
        Set<Long> vehicleIdSet = page.getRecords().stream().map(XpPolicyApplication::getVehicleId).filter(Objects::nonNull).collect(Collectors.toSet());
        Set<Long> auditUserIds = page.getRecords().stream().map(XpPolicyApplication::getAuditUserId).filter(Objects::nonNull).collect(Collectors.toSet());
        Map<Long, XpVehicle> longXpVehicleMap = batchGetVehicles(vehicleIdSet);
        Map<Long, XpOperationsUser> longXpOperationsUserMap = batchGetOperationsUsers(operationsUserIdSet);
        Map<Long, SysUser> auditUserMap = batchGetUsers(auditUserIds);

        // 5. 组装 VO
        List<XpPolicyApplicationVO> voList = page.getRecords().stream()
                .map(item -> convertToPageVO(item, longXpVehicleMap, longXpOperationsUserMap, auditUserMap))
                .collect(Collectors.toList());
        // 6. 返回分页结果
        resultPage.setTotal(page.getTotal());
        resultPage.setRecords(voList);
        return resultPage;
    }

    /**
     * 转换为页面 VO
     * @param item
     * @param longXpVehicleMap
     * @param longXpOperationsUserMap
     * @param auditUserMap
     * @return
     */
    private XpPolicyApplicationVO convertToPageVO(XpPolicyApplication item, Map<Long, XpVehicle> longXpVehicleMap,
                                 Map<Long, XpOperationsUser> longXpOperationsUserMap, Map<Long, SysUser> auditUserMap) {
        XpPolicyApplicationVO xpPolicyApplicationVO = BeanUtil.copyProperties(item, XpPolicyApplicationVO.class);
        xpPolicyApplicationVO.setAuditStatusDesc(AuditStateEnum.getDescByCode(item.getAuditStatus()));
        // 车辆信息
        if (Objects.nonNull(item.getVehicleId())) {
            XpVehicle xpVehicle = longXpVehicleMap.get(item.getVehicleId());
            if (Objects.nonNull(xpVehicle)) {
                xpPolicyApplicationVO.setPlateNumber(xpVehicle.getPlateNumber());
                xpPolicyApplicationVO.setVehicleCode(xpVehicle.getVehicleCode());
            }
        }
        // 申请人信息
        if (Objects.nonNull(item.getApplicantId())) {
            XpOperationsUser operationsUser = longXpOperationsUserMap.get(item.getApplicantId());
            if (Objects.nonNull(operationsUser)) {
                xpPolicyApplicationVO.setNickName(operationsUser.getNickName());
                xpPolicyApplicationVO.setPhoneNumber(operationsUser.getPhoneNumber());
            }
        }
        // 审核人信息
        if (Objects.nonNull(item.getAuditUserId())) {
            SysUser sysUser = auditUserMap.get(item.getAuditUserId());
            if (Objects.nonNull(sysUser)) {
                xpPolicyApplicationVO.setAuditUserName(sysUser.getNickName());
            }
        }
        return xpPolicyApplicationVO;
    }

    /**
     * 批量获取系统用户信息
     */
    private Map<Long, SysUser> batchGetUsers(Set<Long> auditUserIds) {
        if (CollectionUtils.isEmpty(auditUserIds)) {
            return new HashMap<>();
        }
        try {
            R<List<SysUser>> result = sysUserClient.listByIds(new ArrayList<>(auditUserIds));
            if (Objects.nonNull(result) && Objects.nonNull(result.getData())) {
                return result.getData().stream()
                        .collect(Collectors.toMap(SysUser::getId, Function.identity(), (a, b) -> a));
            }
        } catch (Exception e) {
            log.error("批量获取管理员用户信息失败", e);
        }
        return new HashMap<>();
    }

    /**
     * 批量获取车辆信息
     */
    private Map<Long, XpVehicle> batchGetVehicles(Set<Long> vehicleIds) {
        if (CollectionUtils.isEmpty(vehicleIds)) {
            return new HashMap<>();
        }
        try {
            R<List<XpVehicle>> result = xpVehicleClient.listByIds(new ArrayList<>(vehicleIds));
            if (Objects.nonNull(result) && Objects.nonNull(result.getData())) {
                return result.getData().stream()
                        .collect(Collectors.toMap(XpVehicle::getId, Function.identity(), (a, b) -> a));
            }
        } catch (Exception e) {
            log.error("批量获取车辆信息失败", e);
        }
        return new HashMap<>();
    }

    /**
     * 批量获取用户信息
     */
    private Map<Long, XpOperationsUser> batchGetOperationsUsers(Set<Long> operationsUserIds) {
        if (CollectionUtils.isEmpty(operationsUserIds)) {
            return new HashMap<>();
        }
        try {
            R<List<XpOperationsUser>> result = xpOperationUserClient.listByIds(new ArrayList<>(operationsUserIds));
            if (Objects.nonNull(result) && Objects.nonNull(result.getData())) {
                return result.getData().stream()
                        .collect(Collectors.toMap(XpOperationsUser::getId, Function.identity(), (a, b) -> a));
            }
        } catch (Exception e) {
            log.error("批量获取运维用户信息失败", e);
        }
        return new HashMap<>();
    }

    @Override
    public void batchAudit(XpPolicyApplicationAuditDTO dto) {
        // 1.查询待审核的保单申请记录
        List<XpPolicyApplication> applications = lambdaQuery().in(XpPolicyApplication::getId, dto.getIds())
                .eq(XpPolicyApplication::getAuditStatus, AuditStateEnum.PENDING_APPROVAL.getCode()).list();
        if (CollectionUtils.isEmpty(applications)) {
            return;
        }
        // 2.批量更新审核状态和审核信息
        LocalDateTime now = LocalDateTime.now();
        Long userId = SecurityUtils.getLoginUser().getUserid();
        applications.forEach(app -> {
            app.setAuditStatus(dto.getAuditStatus());
            app.setAuditRemarks(dto.getAuditRemarks());
            app.setAuditUserId(userId);
            app.setAuditTime(now);
        });
        updateBatchById(applications);
    }

    @Override
    public void applyPolicyInformation(Long vehicleId, Long userId) {
        XpPolicyApplication xpPolicyApplication = new XpPolicyApplication();
        xpPolicyApplication.setVehicleId(vehicleId);
        xpPolicyApplication.setApplicantId(userId);
        xpPolicyApplication.setApplyTime(LocalDateTime.now());
        xpPolicyApplication.setAuditStatus(PolicyApplicationAuditStateEnum.PENDING_APPROVAL.getCode());
        this.save(xpPolicyApplication);
    }

    @Override
    public QueryPolicyInfoVO queryPolicyInfoByVid(Long vehicleId, Long id) {

        XpPolicyApplication xpPolicyApplication = this.getOne(Wrappers.lambdaQuery(XpPolicyApplication.class)
                .eq(XpPolicyApplication::getVehicleId, vehicleId)
                .eq(XpPolicyApplication::getApplicantId, id)
                .orderByDesc(XpPolicyApplication::getCreateTime)
                .last("limit 1"));
        QueryPolicyInfoVO queryPolicyInfoVO = new QueryPolicyInfoVO();
        if (Objects.nonNull(xpPolicyApplication)) {
            XpPolicyApplicationVO xpPolicyApplicationVO = new XpPolicyApplicationVO();
            BeanUtils.copyProperties(xpPolicyApplication, xpPolicyApplicationVO);
            // 查询车辆
            if (Objects.nonNull(xpPolicyApplication.getVehicleId())) {
                XpVehicle xpVehicle = xpVehicleMapper.selectById(xpPolicyApplication.getVehicleId());
                xpPolicyApplicationVO.setPlateNumber(xpVehicle.getPlateNumber());
                xpPolicyApplicationVO.setVehicleCode(xpVehicle.getVehicleCode());
                if(xpPolicyApplicationVO.getAuditStatus() == 2){
                    xpPolicyApplicationVO.setPolicyInformation(xpVehicle.getPolicyInformation());
                }
            }
            queryPolicyInfoVO.setStatus(xpPolicyApplication.getAuditStatus());
        }else {
            queryPolicyInfoVO.setStatus(0);
        }
        return queryPolicyInfoVO;
    }

}