package com.ruoyi.basic.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.basic.dto.CustomerRegionsTreeDto;
import com.ruoyi.basic.mapper.CustomerMapper;
import com.ruoyi.basic.mapper.CustomerRegionsMapper;
import com.ruoyi.basic.pojo.Customer;
import com.ruoyi.basic.pojo.CustomerRegions;
import com.ruoyi.basic.service.ICustomerRegionsService;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * 客户地区表 服务实现类
 * </p>
 *
 * @author deslrey
 * @since 2026-03-27
 */
@Service
public class CustomerRegionsServiceImpl extends ServiceImpl<CustomerRegionsMapper, CustomerRegions> implements ICustomerRegionsService {

    @Autowired
    private CustomerMapper customerMapper;

    /**
     * 查询树形地区列表
     */
    @Override
    public List<CustomerRegionsTreeDto> customerRegionsList(CustomerRegions customerRegions) {
        List<CustomerRegions> allRegions = baseMapper.selectList(null);
        if (allRegions == null || allRegions.isEmpty()) {
            return new ArrayList<>();
        }

        Map<Long, CustomerRegionsTreeDto> nodeMap = new HashMap<>();
        List<CustomerRegionsTreeDto> allDtoList = new ArrayList<>();

        for (CustomerRegions region : allRegions) {
            CustomerRegionsTreeDto dto = new CustomerRegionsTreeDto();
            dto.setId(region.getId());
            dto.setParentId(region.getParentId());
            dto.setRegionsName(region.getRegionsName());
            dto.setLabel(region.getRegionsName()); // 统一 label 字段
            dto.setChildren(new ArrayList<>());
            nodeMap.put(dto.getId(), dto);
            allDtoList.add(dto);
        }

        List<CustomerRegionsTreeDto> treeList = new ArrayList<>();
        for (CustomerRegionsTreeDto node : allDtoList) {
            Long parentId = node.getParentId();
            // 如果是根节点 (parentId 为 0 或 null) 或 找不到父节点，则作为顶级节点
            if (parentId == null || parentId == 0 || !nodeMap.containsKey(parentId)) {
                treeList.add(node);
            } else {
                // 否则将其添加到父节点的 children 中
                nodeMap.get(parentId).getChildren().add(node);
            }
        }

        String keyword = customerRegions != null ? customerRegions.getRegionsName() : null;
        if (StringUtils.isNotEmpty(keyword)) {
            return filterTree(treeList, keyword);
        }

        return treeList;
    }

    /**
     * 递归过滤树节点
     */
    private List<CustomerRegionsTreeDto> filterTree(List<CustomerRegionsTreeDto> list, String keyword) {
        List<CustomerRegionsTreeDto> filteredList = new ArrayList<>();
        for (CustomerRegionsTreeDto node : list) {
            // 递归处理子节点
            List<CustomerRegionsTreeDto> filteredChildren = filterTree(node.getChildren(), keyword);
            node.setChildren(filteredChildren);

            // 如果当前节点名称包含关键字，或者子节点过滤后不为空，则保留该节点
            if (node.getRegionsName().contains(keyword) || !filteredChildren.isEmpty()) {
                filteredList.add(node);
            }
        }
        return filteredList;
    }

    /**
     * 添加地区
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void addCustomerRegions(CustomerRegions customerRegions) {
        validateRegion(customerRegions);
        checkUnique(customerRegions);
        if (baseMapper.insert(customerRegions) <= 0) {
            throw new ServiceException("添加失败");
        }
    }

    /**
     * 修改地区
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateCustomerRegions(CustomerRegions customerRegions) {
        if (customerRegions.getId() == null) {
            throw new ServiceException("修改失败, ID不能为空");
        }
        validateRegion(customerRegions);
        if (customerRegions.getId().equals(customerRegions.getParentId())) {
            throw new ServiceException("修改失败, 上级地区不能是自己");
        }
        checkUnique(customerRegions);
        if (baseMapper.updateById(customerRegions) <= 0) {
            throw new ServiceException("修改失败");
        }
    }

    /**
     * 删除地区
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delCustomerRegions(Long id) {
        if (id == null) {
            throw new ServiceException("删除失败, ID不能为空");
        }
        boolean hasChildren = baseMapper.selectCount(new LambdaQueryWrapper<CustomerRegions>()
                .eq(CustomerRegions::getParentId, id)) > 0;
        if (hasChildren) {
            throw new ServiceException("删除失败, 该地区下存在子地区");
        }

        boolean isUsedByCustomer = customerMapper.selectCount(new LambdaQueryWrapper<Customer>()
                .eq(Customer::getRegionsId, id)) > 0;
        if (isUsedByCustomer) {
            throw new ServiceException("删除失败, 该地区已被客户档案引用");
        }

        if (baseMapper.deleteById(id) <= 0) {
            throw new ServiceException("删除失败, 数据不存在");
        }
    }

    /**
     * 查询当前地区及其所有子集的 ID 集合
     */
    @Override
    public List<Long> regionsChildrenIds(Long regionsId) {
        List<Long> childIds = new ArrayList<>();
        if (regionsId == null) {
            return childIds;
        }

        List<CustomerRegions> allRegions = baseMapper.selectList(null);
        if (allRegions == null || allRegions.isEmpty()) {
            return childIds;
        }
        childIds.add(regionsId);
        findAllChildren(allRegions, regionsId, childIds);

        return childIds;
    }

    /**
     * 递归地区方法
     *
     * @param allRegions 所有地区列表
     * @param parentId   当前父级 ID
     * @param result     存放结果的集合
     */
    private void findAllChildren(List<CustomerRegions> allRegions, Long parentId, List<Long> result) {
        for (CustomerRegions region : allRegions) {
            // 判断 parentId 是否匹配
            if (parentId.equals(region.getParentId())) {
                result.add(region.getId());
                // 继续递归查找该节点的子节点
                findAllChildren(allRegions, region.getId(), result);
            }
        }
    }

    private void validateRegion(CustomerRegions region) {
        if (region == null) {
            throw new ServiceException("操作失败, 数据不能为空");
        }
        if (StringUtils.isEmpty(region.getRegionsName())) {
            throw new ServiceException("操作失败, 地区名称不能为空");
        }
        if (region.getParentId() == null) {
            region.setParentId(0L);
        }
    }

    private void checkUnique(CustomerRegions region) {
        CustomerRegions existing = baseMapper.selectOne(new LambdaQueryWrapper<CustomerRegions>()
                .eq(CustomerRegions::getRegionsName, region.getRegionsName())
                .eq(CustomerRegions::getParentId, region.getParentId())
                .ne(region.getId() != null, CustomerRegions::getId, region.getId()));

        if (existing != null) {
            throw new ServiceException("该层级下已存在名为 [" + region.getRegionsName() + "] 的地区");
        }
    }
}