package com.ruoyi.chargingPile.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
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.chargingPile.api.model.Partner;
import com.ruoyi.chargingPile.api.model.TPartnerAppUser;
import com.ruoyi.chargingPile.dto.PartnerAppUserBindDTO;
import com.ruoyi.chargingPile.dto.PartnerAppUserVO;
import com.ruoyi.chargingPile.mapper.TPartnerAppUserMapper;
import com.ruoyi.chargingPile.service.IPartnerService;
import com.ruoyi.chargingPile.service.TPartnerAppUserService;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.web.page.PageInfo;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

@Service
public class TPartnerAppUserServiceImpl extends ServiceImpl<TPartnerAppUserMapper, TPartnerAppUser>
        implements TPartnerAppUserService {

    @Resource
    private AppUserClient appUserClient;

    @Resource
    private IPartnerService partnerService;

    @Override
    public PageInfo<PartnerAppUserVO> searchUsers(Integer partnerId, String phone, Integer pageNum, Integer pageSize) {
        assertPartnerExists(partnerId);
        int current = pageNum == null || pageNum < 1 ? 1 : pageNum;
        int size = pageSize == null || pageSize < 1 ? 10 : Math.min(pageSize, 100);
        R<Page<TAppUser>> result = appUserClient.searchPartnerBindUsers(phone, current, size);
        Page<TAppUser> userPage = result == null ? null : result.getData();
        if (userPage == null) {
            throw new ServiceException("小程序用户服务暂不可用");
        }

        List<TAppUser> users = userPage.getRecords();
        Map<Long, TPartnerAppUser> relationMap = getRelationMap(users);
        Map<Integer, Partner> partnerMap = getPartnerMap(relationMap.values());
        List<PartnerAppUserVO> records = users.stream()
                .map(user -> toVO(user, relationMap.get(user.getId()), partnerMap, partnerId))
                .collect(Collectors.toList());

        PageInfo<PartnerAppUserVO> page = new PageInfo<>(userPage.getCurrent(), userPage.getSize());
        page.setTotal(userPage.getTotal());
        page.setRecords(records);
        return page;
    }

    @Override
    public List<PartnerAppUserVO> getBoundUsers(Integer partnerId) {
        assertPartnerExists(partnerId);
        List<TPartnerAppUser> relations = list(new LambdaQueryWrapper<TPartnerAppUser>()
                .eq(TPartnerAppUser::getPartnerId, partnerId)
                .orderByDesc(TPartnerAppUser::getCreateTime));
        if (relations.isEmpty()) {
            return Collections.emptyList();
        }

        List<Long> userIds = relations.stream()
                .map(TPartnerAppUser::getAppUserId)
                .collect(Collectors.toList());
        R<List<TAppUser>> userResult = appUserClient.getUserByIds(userIds);
        List<TAppUser> users = userResult == null ? null : userResult.getData();
        if (users == null) {
            throw new ServiceException("小程序用户服务暂不可用");
        }
        Map<Long, TAppUser> userMap = users.stream()
                .collect(Collectors.toMap(TAppUser::getId, Function.identity(), (left, right) -> left));
        Partner partner = partnerService.getById(partnerId);
        Map<Integer, Partner> partnerMap = Collections.singletonMap(partnerId, partner);

        return relations.stream()
                .map(relation -> {
                    TAppUser user = userMap.get(relation.getAppUserId());
                    return user == null ? null : toVO(user, relation, partnerMap, partnerId);
                })
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
    }

    @Override
    public List<TPartnerAppUser> getRelations(Integer partnerId) {
        assertPartnerExists(partnerId);
        return list(new LambdaQueryWrapper<TPartnerAppUser>()
                .eq(TPartnerAppUser::getPartnerId, partnerId)
                .orderByAsc(TPartnerAppUser::getCreateTime));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveBindings(PartnerAppUserBindDTO bindDTO) {
        Integer partnerId = bindDTO.getPartnerId();
        assertPartnerExists(partnerId);
        Set<Long> selectedIds = bindDTO.getAppUserIds() == null
                ? Collections.emptySet()
                : bindDTO.getAppUserIds().stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toCollection(LinkedHashSet::new));

        if (!selectedIds.isEmpty()) {
            long conflictCount = count(new LambdaQueryWrapper<TPartnerAppUser>()
                    .in(TPartnerAppUser::getAppUserId, selectedIds)
                    .ne(TPartnerAppUser::getPartnerId, partnerId));
            if (conflictCount > 0) {
                throw new ServiceException("所选手机号已绑定其他合作商，请刷新列表后重试");
            }
        }

        List<TPartnerAppUser> existingRelations = list(new LambdaQueryWrapper<TPartnerAppUser>()
                .eq(TPartnerAppUser::getPartnerId, partnerId));
        Set<Long> existingIds = existingRelations.stream()
                .map(TPartnerAppUser::getAppUserId)
                .filter(Objects::nonNull)
                .collect(Collectors.toSet());

        Set<Long> removedIds = existingIds.stream()
                .filter(appUserId -> !selectedIds.contains(appUserId))
                .collect(Collectors.toSet());
        if (!removedIds.isEmpty()) {
            remove(new LambdaQueryWrapper<TPartnerAppUser>()
                    .eq(TPartnerAppUser::getPartnerId, partnerId)
                    .in(TPartnerAppUser::getAppUserId, removedIds));
        }

        List<TPartnerAppUser> relations = new ArrayList<>();
        for (Long appUserId : selectedIds) {
            if (existingIds.contains(appUserId)) {
                continue;
            }
            TPartnerAppUser relation = new TPartnerAppUser();
            relation.setPartnerId(partnerId);
            relation.setAppUserId(appUserId);
            relations.add(relation);
        }
        if (!relations.isEmpty()) {
            saveBatch(relations);
        }
    }

    @Override
    public Partner getPartnerByAppUserId(Long appUserId) {
        if (appUserId == null) {
            return null;
        }
        TPartnerAppUser relation = getOne(new LambdaQueryWrapper<TPartnerAppUser>()
                .eq(TPartnerAppUser::getAppUserId, appUserId)
                .last("limit 1"));
        return relation == null ? null : partnerService.getById(relation.getPartnerId());
    }

    private Map<Long, TPartnerAppUser> getRelationMap(List<TAppUser> users) {
        if (users == null || users.isEmpty()) {
            return Collections.emptyMap();
        }
        List<Long> userIds = users.stream().map(TAppUser::getId).collect(Collectors.toList());
        return list(new LambdaQueryWrapper<TPartnerAppUser>()
                .in(TPartnerAppUser::getAppUserId, userIds)).stream()
                .collect(Collectors.toMap(TPartnerAppUser::getAppUserId, Function.identity(), (left, right) -> left));
    }

    private Map<Integer, Partner> getPartnerMap(java.util.Collection<TPartnerAppUser> relations) {
        Set<Integer> partnerIds = relations.stream()
                .map(TPartnerAppUser::getPartnerId)
                .filter(Objects::nonNull)
                .collect(Collectors.toSet());
        if (partnerIds.isEmpty()) {
            return Collections.emptyMap();
        }
        return partnerService.listByIds(partnerIds).stream()
                .collect(Collectors.toMap(Partner::getId, Function.identity(), (left, right) -> left));
    }

    private PartnerAppUserVO toVO(TAppUser user, TPartnerAppUser relation,
                                  Map<Integer, Partner> partnerMap, Integer currentPartnerId) {
        PartnerAppUserVO vo = new PartnerAppUserVO();
        vo.setAppUserId(user.getId());
        vo.setName(user.getName());
        vo.setPhone(user.getPhone());
        vo.setRemark(user.getRemark());
        vo.setCreateTime(user.getCreateTime());
        if (relation != null) {
            vo.setPartnerId(relation.getPartnerId());
            Partner partner = partnerMap.get(relation.getPartnerId());
            vo.setPartnerName(partner == null ? null : partner.getName());
        }
        boolean selected = relation != null && Objects.equals(relation.getPartnerId(), currentPartnerId);
        vo.setSelected(selected);
        vo.setDisabled(relation != null && !selected);
        return vo;
    }

    private void assertPartnerExists(Integer partnerId) {
        if (partnerId == null || partnerService.getById(partnerId) == null) {
            throw new ServiceException("合作商不存在");
        }
    }
}