package cn.iocoder.yudao.module.system.service.tenant;


import cn.hutool.core.collection.CollectionUtil;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils;
import cn.iocoder.yudao.module.system.controller.admin.tenant.vo.tenant.GroupTenantTreeRespVO;
import cn.iocoder.yudao.module.system.controller.admin.tenant.vo.tenant.UserGroupTenantRespVO;
import cn.iocoder.yudao.module.system.controller.admin.tenant.vo.tenant.UserGroupTenantSaveReqVO;
import cn.iocoder.yudao.module.system.dal.dataobject.tenant.EnterpriseInfoDO;
import cn.iocoder.yudao.module.system.dal.dataobject.tenant.TenantDO;
import cn.iocoder.yudao.module.system.dal.dataobject.tenant.UserGroupTenantDO;
import cn.iocoder.yudao.module.system.dal.mysql.tenant.EnterpriseInfoMapper;
import cn.iocoder.yudao.module.system.dal.mysql.tenant.TenantMapper;
import cn.iocoder.yudao.module.system.dal.mysql.tenant.UserGroupTenantMapper;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

import org.springframework.validation.annotation.Validated;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


/**
 * 集团租户和用户关联 Service 实现类
 *
 * @author 系统管理员
 */
@Service
@Validated
public class UserGroupTenantServiceImpl implements UserGroupTenantService {

    @Resource
    private UserGroupTenantMapper userGroupTenantMapper;
    @Resource
    private TenantMapper tenantMapper;
    @Resource
    private EnterpriseInfoMapper enterpriseInfoMapper;


    @Override
    public void createUserGroupTenant(List<UserGroupTenantSaveReqVO> createReqVO) {
        //先删除旧数据
        UserGroupTenantSaveReqVO userGroupTenantSaveReq = createReqVO.stream().findFirst().get();
        Long userId = userGroupTenantSaveReq.getUserId();
        userGroupTenantMapper.delete(new LambdaQueryWrapperX<UserGroupTenantDO>().eq(UserGroupTenantDO::getUserId, userId));
        //在重新生成关联关系
        for (UserGroupTenantSaveReqVO userGroupTenantSaveReqVO : createReqVO) {
            //生成与用户关联关系
            UserGroupTenantDO userGroupTenantDO = new UserGroupTenantDO();
            BeanUtils.copyProperties(userGroupTenantSaveReqVO, userGroupTenantDO);
            userGroupTenantMapper.insert(userGroupTenantDO);
        }
    }

    @Override
    public List<UserGroupTenantRespVO> getUserGroupTenant(Long userId, String province, Long groupTenantId) {
        // 1. 查询原始数据
        List<UserGroupTenantDO> userGroupTenants = userGroupTenantMapper.selectListByUserIdAndProvince(userId, province, groupTenantId);

        // 2. 按租户ID分组
        Map<Long, List<UserGroupTenantDO>> groupedMap = userGroupTenants.stream()
                .collect(Collectors.groupingBy(UserGroupTenantDO::getOrgTenantId));

        List<UserGroupTenantRespVO> result = new ArrayList<>();

        // 3. 遍历每个租户分组
        groupedMap.forEach((orgTenantId, doList) -> {
            // 3.1 取该租户下的第一条记录（可根据业务需要调整，例如按某个字段排序后取第一条）
            UserGroupTenantDO first = doList.get(0);

            // 3.2 查询租户信息（每个租户只查一次）
            TenantDO tenantDO = tenantMapper.selectById(orgTenantId);
            String orgTenantName = tenantDO != null ? tenantDO.getName() : null;

            // 3.3 查询企业信息（每个租户只查一次）
            EnterpriseInfoDO enterpriseInfoDO = enterpriseInfoMapper.selectOne(
                    new LambdaQueryWrapperX<EnterpriseInfoDO>()
                            .eq(EnterpriseInfoDO::getTenantId, orgTenantId));

            // 3.4 组装 VO
            UserGroupTenantRespVO respVO = new UserGroupTenantRespVO();
            BeanUtils.copyProperties(first, respVO);
            respVO.setOrgTenantName(orgTenantName);
            respVO.setEnterpriseInfo(enterpriseInfoDO);

            result.add(respVO);
        });

        return result;
    }

    @Override
    public List<TenantDO> getGroupTenantByUser() {
        Long loginUserId = SecurityFrameworkUtils.getLoginUserId();

        List<UserGroupTenantDO> userGroupTenantList = userGroupTenantMapper.selectList(new LambdaQueryWrapperX<UserGroupTenantDO>()
                .eq(UserGroupTenantDO::getUserId, loginUserId)
                .eq(UserGroupTenantDO::getDeleted, 0));

        List<Long> groupTenantIds = userGroupTenantList.stream()
                .map(UserGroupTenantDO::getGroupTenantId)
                .distinct().collect(Collectors.toList());

        if (CollectionUtil.isNotEmpty(groupTenantIds)){
            return groupTenantIds.stream().map(e -> {
                TenantDO tenantDO = tenantMapper.selectById(e);
                return tenantDO;
            }).collect(Collectors.toList());
        }
        return null;
    }

    @Override
    public List<GroupTenantTreeRespVO> findGroupTenantTree() {
        Long loginUserId = SecurityFrameworkUtils.getLoginUserId();
        List<UserGroupTenantDO> userGroupTenantList = userGroupTenantMapper.selectList(new LambdaQueryWrapperX<UserGroupTenantDO>()
                .eq(UserGroupTenantDO::getUserId, loginUserId)
                .eq(UserGroupTenantDO::getDeleted, 0));

        //按照树形结构组装数据
        Map<Long, List<UserGroupTenantDO>> map = userGroupTenantList.stream().collect(Collectors.groupingBy(UserGroupTenantDO::getGroupTenantId));
        List<GroupTenantTreeRespVO> dataList = new ArrayList<>();
        map.forEach((groupTenantId,items) -> {
            GroupTenantTreeRespVO respVO = new GroupTenantTreeRespVO();
            TenantDO tenantDO = tenantMapper.selectById(groupTenantId);
            respVO.setGroupTenantId(groupTenantId);
            respVO.setGroupTenantName(tenantDO.getName());

            List<TenantDO> tenantList = items.stream().map(e -> tenantMapper.selectById(e.getOrgTenantId())).collect(Collectors.toList());
            respVO.setTenantList(tenantList);
            dataList.add(respVO);
        });
        return dataList;
    }
}