/*
 *      Copyright (c) 2018-2028, Chill Zhuang All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
 *  Neither the name of the dreamlu.net developer nor the names of its
 *  contributors may be used to endorse or promote products derived from
 *  this software without specific prior written permission.
 *  Author: Chill 庄骞 (smallchill@163.com)
 */
package org.springblade.modules.house.service.impl;

import cn.hutool.core.util.IdcardUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import liquibase.repackaged.org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.util.Strings;
import org.springblade.common.constant.CommonConstant;
import org.springblade.common.node.TreeIntegerNode;
import org.springblade.common.node.TreeStringNode;
import org.springblade.common.param.CommonParamSet;
import org.springblade.common.utils.NodeTreeUtil;
import org.springblade.common.utils.SpringUtils;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.core.tool.utils.Func;
import org.springblade.modules.house.entity.HouseRentalEntity;
import org.springblade.modules.house.entity.HouseholdEntity;
import org.springblade.modules.house.entity.UserHouseLabelEntity;
import org.springblade.modules.house.excel.ExportHouseholdExcel;
import org.springblade.modules.house.excel.ImportHouseholdExcel;
import org.springblade.modules.house.mapper.HouseholdMapper;
import org.springblade.modules.house.service.IHouseRentalService;
import org.springblade.modules.house.service.IHouseService;
import org.springblade.modules.house.service.IHouseholdService;
import org.springblade.modules.house.service.IUserHouseLabelService;
import org.springblade.modules.house.vo.HouseholdLabelVO;
import org.springblade.modules.house.vo.HouseholdOtherVO;
import org.springblade.modules.house.vo.HouseholdVO;
import org.springblade.modules.label.entity.LabelEntity;
import org.springblade.modules.label.service.ILabelService;
import org.springblade.modules.place.entity.PlaceEntity;
import org.springblade.modules.place.service.IPlaceService;
import org.springblade.modules.system.entity.DictBiz;
import org.springblade.modules.system.entity.User;
import org.springblade.modules.system.service.IDictBizService;
import org.springblade.modules.system.service.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StopWatch;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 住户 服务实现类
 *
 * @author BladeX
 * @since 2023-10-28
 */
@Service
public class HouseholdServiceImpl extends ServiceImpl<HouseholdMapper, HouseholdEntity> implements IHouseholdService {

	@Autowired
	private IUserHouseLabelService userHouseLabelService;

	@Autowired
	private IDictBizService dictBizService;

	@Autowired
	private IUserService userService;

	@Autowired
	private IPlaceService placeService;

	@Autowired
	private IHouseRentalService iHouseRentalService;


	@Override
	public IPage<HouseholdVO> selectHouseholdPage(IPage<HouseholdVO> page, HouseholdVO household) {
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		CommonParamSet commonParamSet = new CommonParamSet().invoke(HouseholdVO.class, household);

//		List<String> regionChildCodesList = SysCache.getRegionChildCodesByDeptId(AuthUtil.getDeptId());
//		Integer isAdministrator = AuthUtil.isAdministrator()==true?1:2;
		// 重点人员与关注人员
		if (Objects.nonNull(household.getLabelType())) {
			extracted(household);
		}
		List<HouseholdVO> householdVOS = baseMapper.selectHouseholdPage(page, household, commonParamSet.getIsAdministrator(),
			commonParamSet.getRegionChildCodesList(), commonParamSet.getGridCodeList());
		stopWatch.stop();
//		System.out.println("selectHouseholdPage:" + stopWatch.getTotalTimeMillis());
		return page.setRecords(householdVOS);
	}

	/**
	 * 重点人员与关注人员
	 * @param household
	 */
	private void extracted(HouseholdVO household) {
		ILabelService iLabelService = SpringUtils.getBean(ILabelService.class);
		if (CommonConstant.NUMBER_ONE.equals(household.getLabelType())) {
			List<LabelEntity> list = iLabelService.list(Wrappers.<LabelEntity>lambdaQuery().eq(LabelEntity::getParentId, 103));
			List<Integer> collect = list.stream().map(item ->
				item.getId()
			).collect(Collectors.toList());
			household.setLabelIdList(collect);
		} else if (CommonConstant.NUMBER_TWO.equals(household.getLabelType())) {
			List<LabelEntity> list = iLabelService.list(Wrappers.<LabelEntity>lambdaQuery().eq(LabelEntity::getParentId, 1032));
			List<Integer> collect = list.stream().map(item ->
				item.getId()
			).collect(Collectors.toList());
			household.setLabelIdList(collect);
		}
	}

	/**
	 * 查询房屋集合信息
	 *
	 * @param userId
	 * @return
	 */
	@Override
	public List<TreeStringNode> selectHouseNodeList(Long userId) {
		return baseMapper.selectHouseNodeList(userId);
	}

	/**
	 * 查询房屋人员情况
	 *
	 * @param code
	 * @return
	 */
	@Override
	public List<HouseholdVO> getHouseholdListByCode(String code) {
		// 查询
		List<HouseholdVO> householdList = baseMapper.getHouseholdListByCode(code);
		// 处理字典
		handleDictBiz(householdList);
		// 返回
		return householdList;
	}

	/**
	 * 处理字典
	 *
	 * @param householdList
	 */
	private void handleDictBiz(List<HouseholdVO> householdList) {
		if (householdList.size() > 0) {
			// 查询角色关系字典
			List<DictBiz> dictBizList = dictBizService.getList("roleRelation", null);
			if (dictBizList.size() > 0) {
				// 遍历
				for (HouseholdVO householdVO : householdList) {
					if (null != householdVO.getRelationship()) {
						for (DictBiz dictBiz : dictBizList) {
							if (householdVO.getRelationship().toString().equals(dictBiz.getDictKey())) {
								householdVO.setRoleRelationName(dictBiz.getDictValue());
							}
						}
					}
				}
			}
		}
	}

	/**
	 * 住户 自定义新增或修改
	 *
	 * @param household
	 * @return
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public boolean saveOrUpdateHousehold(HouseholdVO household) {
		boolean flag = false;
		household.setUpdateTime(new Date());
		household.setUpdateUser(AuthUtil.getUserId());
		if (!Strings.isBlank(household.getRoleName()) && household.getRoleName().equals("居民")) {
			// 待审核
			household.setConfirmFlag(0);
		}
		if (null != household.getId()) {
			// 更新
			flag = updateById(household);
			// 更新用户信息
			updateUserInfo(household);
			// 更新标签信息
			updateUserLabelInfo(household);
		} else {
			// 新增
			household.setCreateTime(new Date());
			household.setCreateUser(AuthUtil.getUserId());
			flag = save(household);
			// 更新用户信息
			updateUserInfo(household);
			// 更新标签信息
			updateUserLabelInfo(household);
		}
		return flag;
	}

	/**
	 * 更新用户标签信息
	 *
	 * @param household
	 */
	public void updateUserLabelInfo(HouseholdVO household) {
		if (household.getHouseholdLabelList().size() > 0) {
			List<HouseholdLabelVO> householdLabelList = household.getHouseholdLabelList();
			for (HouseholdLabelVO householdLabelVO : householdLabelList) {
				if (!Strings.isBlank(household.getHouseCode())) {
					householdLabelVO.setHouseCode(household.getHouseCode());
				}
				householdLabelVO.setHouseholdId(household.getId());
				// 先删除对应绑定的信息
				userHouseLabelService.saveOrUpdateHouseholdLabel(householdLabelVO);
			}
		}
	}

	/**
	 * 更新用户信息
	 *
	 * @param household
	 */
	public void updateUserInfo(HouseholdEntity household) {
		// 判断用户是否为业主，如果是业主，则新增
		if (null != household.getRelationship() && household.getRelationship() == 1) {
			// 如果为业主
			// 新增用户
			bindUserHandle(household);
		}
	}

	/**
	 * 业主和用户绑定
	 *
	 * @param
	 */
	public User bindUserHandle(HouseholdEntity householdEntity) {
		User newUser = new User();
		if (null != householdEntity.getPhoneNumber() && !householdEntity.getPhoneNumber().equals("")) {
			//根据手机号查询库里的数据
			List<User> list = userService.getUserListByPhoneOrAccount(householdEntity.getPhoneNumber());
			if (list.size()>0) {
				User user = list.get(0);
				//如果用户存在，则该用户id绑定场所
				householdEntity.setAssociatedUserId(user.getId());
				//更新住户信息
				updateById(householdEntity);
				newUser = user;
				// 判断用户是否包含了居民角色,不包含则需更新
				if (!user.getRoleId().contains("1717429059648606209")) {
					user.setRoleId(user.getRoleId() + ",1717429059648606209");
					//更新
					userService.updateById(user);
				}
			} else {
				//如果用户不存在，则新增一个用户
				newUser.setAccount(householdEntity.getPhoneNumber());
				newUser.setPhone(householdEntity.getPhoneNumber());
				newUser.setName(householdEntity.getName());
				newUser.setRealName(householdEntity.getName());
				// 社区群众部门
				newUser.setDeptId("1727979636479037441");
				// 目前暂定居民角色，
				newUser.setRoleId("1717429059648606209");
				//默认密码为 123456
				newUser.setPassword("123456");
				// 设置机构
				// 用户新增
				boolean submit = userService.submit(newUser);
				//绑定id
				householdEntity.setAssociatedUserId(newUser.getId());
				//更新住户信息
				updateById(householdEntity);
			}
		}
		return newUser;
	}

	/**
	 * 住户 自定义查询详情
	 *
	 * @param household
	 * @return
	 */
	@Override
	public Object getDetail(HouseholdEntity household) {
		return baseMapper.getHouseholdListById(household);
	}

	/**
	 * 导出住户信息
	 * @param household
	 * @return
	 */
	@Override
	public List<ExportHouseholdExcel> export(HouseholdVO household) {
		CommonParamSet commonParamSet = new CommonParamSet().invoke(HouseholdVO.class, household);
		// 重点人员与关注人员
		if (Objects.nonNull(household.getLabelType())) {
			extracted(household);
		}
		List<ExportHouseholdExcel> userHouseHoldExcels = baseMapper.export(household,
			commonParamSet.getIsAdministrator(),
			commonParamSet.getRegionChildCodesList(),
			commonParamSet.getGridCodeList()
		);
		return userHouseHoldExcels;
	}


	/**
	 * 导入住户数据
	 *
	 * @param data
	 * @param isCovered
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public String importUserHouseHold(List<ImportHouseholdExcel> data, Boolean isCovered, String isTenant) {
		IHouseService houseService = SpringUtils.getBean(IHouseService.class);
		int totalNum = data.size();
		int importNum = 0;
		int updateNum = 0;
		int errorNum = 0;
		for (ImportHouseholdExcel houseHoldExcel : data) {
			HouseholdEntity householdEntity = Objects.requireNonNull(BeanUtil.copy(houseHoldExcel, HouseholdEntity.class));
			// 判断姓名，手机号
			if (Strings.isBlank(householdEntity.getName())
				|| Strings.isBlank(householdEntity.getPhoneNumber())
				|| Strings.isBlank(householdEntity.getHouseCode())
			) {
				errorNum++;
				continue;
			}
			// 查询库中是否已存在
			QueryWrapper<HouseholdEntity> wrapper = new QueryWrapper<>();
			wrapper.eq("house_code", householdEntity.getHouseCode())
				.eq("is_deleted", 0)
				.eq("phone_number", householdEntity.getPhoneNumber())
				.eq("name", householdEntity.getName());
			HouseholdEntity one = this.getOne(wrapper);
			// 与角色关系
			if (!Strings.isBlank(houseHoldExcel.getRelationship())) {
				householdEntity.setRelationship(Integer.parseInt(houseHoldExcel.getRelationship()));
				// 如果是业主，则需要往用户表插入用户
				if (householdEntity.getRelationship() == 1) {
					houseService.saveOrUpdateUser(householdEntity);
				}
			}
			// 判断是否租户导入
			if (StringUtils.isNotBlank(isTenant)) {
				householdEntity.setRelationship(18);
				HouseRentalEntity houseRentalEntity = iHouseRentalService.getOne(Wrappers.<HouseRentalEntity>lambdaQuery()
					.eq(HouseRentalEntity::getHouseCode, householdEntity.getHouseCode()));
				if (houseRentalEntity != null) {
					householdEntity.setHousingRentalId(houseRentalEntity.getId());
				} else {
					errorNum++;
					continue;
				}
			}
			/// 是否主要联系人
			if (!Strings.isBlank(houseHoldExcel.getIsPrimaryContact())) {
				householdEntity.setIsPrimaryContact(Integer.parseInt(houseHoldExcel.getIsPrimaryContact()));
			}
			// 居住状态
			if (!Strings.isBlank(houseHoldExcel.getResidentialStatus())) {
				householdEntity.setResidentialStatus(Integer.parseInt(houseHoldExcel.getResidentialStatus()));
			}
			// 性别
			if (!Strings.isBlank(houseHoldExcel.getGender())) {
				householdEntity.setGender(Short.parseShort(houseHoldExcel.getGender()));
			}
			// 居民身份证
			if (!Strings.isBlank(houseHoldExcel.getIdCard())) {
				if (IdcardUtil.isValidCard(houseHoldExcel.getIdCard())) {
					// 身份证类型为居民身份证
					householdEntity.setCardType(111);
				}
			}
			// 党员
			if (!Strings.isBlank(houseHoldExcel.getPartyEmber())) {
				householdEntity.setPartyEmber(Integer.parseInt(houseHoldExcel.getPartyEmber()));
			}
			// 民族
			if (!Strings.isBlank(houseHoldExcel.getEthnicity())) {
				householdEntity.setEthnicity(Integer.parseInt(houseHoldExcel.getEthnicity()));
			}
			// 学历
			if (!Strings.isBlank(houseHoldExcel.getEducation())) {
				householdEntity.setEducation(Integer.parseInt(houseHoldExcel.getEducation()));
			}
			// 健康状况
			if (!Strings.isBlank(houseHoldExcel.getHealthStatus())) {
				householdEntity.setHealthStatus(Integer.parseInt(houseHoldExcel.getHealthStatus()));
			}
			// 工作状态
			if (!Strings.isBlank(houseHoldExcel.getWorkStatus())) {
				householdEntity.setWorkStatus(Integer.parseInt(houseHoldExcel.getWorkStatus()));
			}
			// 外出时间
			if (!Strings.isBlank(houseHoldExcel.getGoOutTime())) {
				try {
					Date date = new SimpleDateFormat("yyyy-MM-dd").parse(houseHoldExcel.getGoOutTime());
					householdEntity.setGoOutTime(date);
				} catch (ParseException e) {
					e.printStackTrace();
				}
			}
			// 婚姻状态
			if (!Strings.isBlank(houseHoldExcel.getMaritalStatus())) {
				householdEntity.setMaritalStatus(Integer.parseInt(houseHoldExcel.getMaritalStatus()));
			}

			if (one==null){
				// 新增
				this.save(householdEntity);
				importNum++;
				// 处理标签
				handleLabel(householdEntity,houseHoldExcel);
			}else {
				updateNum++;
				if (isCovered){
					// 覆盖更新
					householdEntity.setId(one.getId());
					// 更新
					updateById(householdEntity);
					importNum++;
					// 处理标签
					handleLabel(householdEntity,houseHoldExcel);
				}
			}
		}
		StringBuilder builder = new StringBuilder("导入完成!");
		builder.append("其中本次表格共有 ").append(totalNum).append(" 条数据，")
			.append("成功导入 ").append(importNum).append(" 条数据。");
		if (updateNum>0) {
			builder.append("其中有 ").append(updateNum).append(" 条数据已存在。");
		}
		if (errorNum>0){
			builder.append("共有 ").append(errorNum).append(" 条数据由于无姓名或手机号或门牌地址编码信息未导入!");
		}
		return builder.toString();
	}

	/**
	 * 标签处理
	 * @param householdEntity
	 * @param houseHoldExcel
	 */
	public void handleLabel(HouseholdEntity householdEntity, ImportHouseholdExcel houseHoldExcel) {
		if (!Strings.isBlank(houseHoldExcel.getLabelName())){
			// 查询对应的label集合信息
			List<UserHouseLabelEntity> userHouseLabelList = userHouseLabelService.getLabelList(houseHoldExcel.getLabelName());
			if (userHouseLabelList.size()>0){
				for (UserHouseLabelEntity userHouseLabelEntity : userHouseLabelList) {
					userHouseLabelEntity.setHouseCode(householdEntity.getHouseCode());
					userHouseLabelEntity.setHouseholdId(householdEntity.getId());
					userHouseLabelEntity.setUserId(householdEntity.getAssociatedUserId());
					userHouseLabelEntity.setLableType(1);
					userHouseLabelEntity.setColor("green");
					userHouseLabelService.saveOrUpdateHouseholdLabel(userHouseLabelEntity);
				}
			}
		}
	}

	/**
	 * 住户审核统计
	 *
	 * @param userId
	 * @return
	 */
	@Override
	public Integer statistics(Long userId, String neiCode, Integer confirmFlag) {
		HouseholdVO householdVO = new HouseholdVO();
		householdVO.setConfirmFlag(confirmFlag);
		householdVO.setCommunityCode(neiCode);
		CommonParamSet commonParamSet = new CommonParamSet().invoke(HouseholdVO.class, householdVO);

		return baseMapper.statistics(householdVO, commonParamSet.getIsAdministrator(),
			commonParamSet.getRegionChildCodesList(), commonParamSet.getGridCodeList());
	}

	/**
	 * 住户对应物业，网格，公安负责人查询
	 *
	 * @param household
	 * @return
	 */
	@Override
	public Object getHouseholdOtherInfo(HouseholdVO household) {
		Map<String, Object> map = new HashMap<>(3);
		// 查询物业
		HouseholdOtherVO propertyOtherVO = baseMapper.getProperty(household);
		map.put("wy", propertyOtherVO);
		// 查询网格
		HouseholdOtherVO gridOtherVO = baseMapper.getGrid(household);
		map.put("wg", gridOtherVO);
		// 查询公安信息
		HouseholdOtherVO securityOtherVO = baseMapper.getSecurity(household);
		map.put("ga", securityOtherVO);
		// 返回
		return map;
	}

	@Override
	public Object getHouseHoldStatistics(String code, String roleType) {
		Map<String, Object> objectObjectHashMap = new HashMap<>();
		if (roleType.equals("2")) {
			List<Map<String, Object>> result = baseMapper.getHouseHoldStatistics(code, null, roleType);
			List<Map<String, Object>> result1 = baseMapper.getHouseHoldStatisticsAge(code, null, roleType);
			objectObjectHashMap.put("gender", result);
			objectObjectHashMap.put("age", result1);
			return objectObjectHashMap;
		} else {
			List<Map<String, Object>> result = baseMapper.getHouseHoldStatistics(code, AuthUtil.getUserId(), roleType);
			List<Map<String, Object>> result1 = baseMapper.getHouseHoldStatisticsAge(code, AuthUtil.getUserId(), roleType);
			objectObjectHashMap.put("gender", result);
			objectObjectHashMap.put("age", result1);
			return objectObjectHashMap;
		}

	}

	/**
	 * 住户业主信息处理，将业主人员插入到用户表
	 *
	 * @return
	 */
	@Override
	public Object userHandle() {
		// 查询所有未入库的业主信息
		List<HouseholdEntity> householdEntityList = baseMapper.getNotInsertUserHousehold();
		// 批量入用户库
		for (HouseholdEntity householdEntity : householdEntityList) {
			// 根据手机号查询对应账号和手机号的用户信息
			List<User> userList = userService.getUserListByPhoneOrAccount(householdEntity.getPhoneNumber());
			if (userList.size() > 0) {
				User user = userList.get(0);
				householdEntity.setAssociatedUserId(user.getId());
				// 更新
				updateById(householdEntity);
				// 判断用户是否包含了居民角色,不包含则需更新
				if (!user.getRoleId().contains("1717429059648606209")) {
					user.setRoleId(user.getRoleId() + ",1717429059648606209");
					//更新
					userService.updateById(user);
				}
			} else {
				// 插入用户信息
				//如果用户不存在，则新增一个用户
				User newUser = new User();
				newUser.setAccount(householdEntity.getPhoneNumber());
				newUser.setPhone(householdEntity.getPhoneNumber());
				newUser.setName(householdEntity.getName());
				newUser.setRealName(householdEntity.getName());
				// 社区群众部门
				newUser.setDeptId("1727979636479037441");
				// 目前暂定居民角色，
				newUser.setRoleId("1717429059648606209");
				//默认密码为 123456
				newUser.setPassword("123456");
				// 用户新增
				boolean submit = userService.submit(newUser);
				// 更新绑定用户信息
				householdEntity.setAssociatedUserId(newUser.getId());
				// 更新
				updateById(householdEntity);
			}
		}
		return null;
	}

	/**
	 * 住户 删除
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public boolean removeHousehold(String ids) {
		List<Long> idList = Func.toLongList(ids);
		// 同时删除当前住户对应的标签
		removeHouseholdLabel(idList);
		// 同时删除对应的用户信息
		removeHouseholdUser(idList);
		// 删除住户信息
		boolean removeByIds = removeByIds(idList);
		// 返回
		return removeByIds;
	}


	/**
	 * 同时删除对应的用户信息
	 *
	 * @param idList
	 */
	public void removeHouseholdUser(List<Long> idList) {
		for (Long id : idList) {
			HouseholdEntity householdEntity = getById(id);
			// 如果是业主
			if (null!= householdEntity.getRelationship() && householdEntity.getRelationship() == 1) {
				// 查询对应的用户
				User user = userService.getById(householdEntity.getAssociatedUserId());
				// 判断是否还绑定其他的房屋，如果有，则不操作用户
				QueryWrapper<HouseholdEntity> wrapper = new QueryWrapper<>();
				wrapper.eq("is_deleted", 0).eq("associated_user_id", user.getId());
				List<HouseholdEntity> householdEntityList = list(wrapper);
				if (householdEntityList.size() == 1) {
					// 判断角色
					if (!Strings.isBlank(user.getRoleId())) {
						List<String> stringList = Arrays.asList(user.getRoleId().split(","));
						// 查询场所
						QueryWrapper<PlaceEntity> queryWrapper = new QueryWrapper<>();
						queryWrapper.eq("is_deleted", 0).eq("principal_user_id", user.getId());
						List<PlaceEntity> placeEntityList = placeService.list(queryWrapper);
						// 即没有房屋和场所了就删除对应的居民角色
						if (placeEntityList.size() == 0) {
							// 查看当前用户的角色是否只有一个
							if (stringList.size() > 1) {
								// 查询是否对应有场所负责人，如果有则不删除，如果没有则删除对应的角色
								List<String> arrayList = new ArrayList<>();
								for (String roleId : stringList) {
									if (!roleId.equals("1717429059648606209")) {
										arrayList.add(roleId);
									}
								}
								user.setRoleId(StringUtils.join(arrayList, ","));
								// 更新用户
								userService.updateById(user);
							} else {
								// 删除当前用户
								userService.removeById(user.getId());
							}
						}
					}
				}
			}
		}
	}

	/**
	 * 删除住户标签信息
	 *
	 * @param idList
	 */
	public void removeHouseholdLabel(List<Long> idList) {
		for (Long id : idList) {
			QueryWrapper<UserHouseLabelEntity> wrapper = new QueryWrapper<>();
			wrapper.eq("household_id", id);
			userHouseLabelService.remove(wrapper);
		}
	}

	@Override
	public List<HouseholdVO> getAllHouseHold(HouseholdVO household) {
		return baseMapper.getAllHouseHold(household);
	}

	/**
	 * 住户列表查询
	 *
	 * @param household
	 * @return
	 */
	@Override
	public List<HouseholdVO> selectHouseholdList(HouseholdVO household) {
		List<HouseholdVO> householdVOS = baseMapper.selectHouseholdList(household);
		// 遍历
		for (HouseholdVO householdVO : householdVOS) {
			if (householdVO.getHouseholdLabelList().size() > 0) {
				List<String> labelNameList = householdVO.getHouseholdLabelList().stream().map(householdLabelVO -> householdLabelVO.getLabelName())
					.collect(Collectors.toList());
				householdVO.setLabelName(String.join(",", labelNameList));
			}
		}
		// 返回
		return householdVOS;
	}

	@Override
	public IPage<HouseholdVO> getKeynotePersonnelPage(IPage<HouseholdVO> page, HouseholdVO household) {
		// StopWatch stopWatch = new StopWatch();
		// stopWatch.start();
		// Dept dept = deptService.getById(AuthUtil.getDeptId());
		// if (null!=dept){
		// 	household.setRegionCode(dept.getRegionCode());
		// }
		List<HouseholdVO> householdVOS = baseMapper.getKeynotePersonnelPage(page, household);
		// stopWatch.stop();
		// System.out.println("selectHouseholdPage:" + stopWatch.getTotalTimeMillis());
		return page.setRecords(householdVOS);
	}

	/**
	 * 根据人员标签编号集合查询对应的住户（按颜色区分近多少天没有发过任务的住户）
	 *
	 * @param list
	 * @return
	 */
	@Override
	public List<HouseholdVO> getHouseholdListByParam(List<Integer> list) {
		return baseMapper.getHouseholdListByParam(list);
	}

	@Override
	public List<TreeIntegerNode> getlabelStatistics(HouseholdVO household) {
		Map<Integer, TreeIntegerNode> labelTreeList = baseMapper.getlabelStatistics(household);
		List<TreeIntegerNode> nodeTree = NodeTreeUtil.getNodeTree(labelTreeList);
		nodeTree.forEach(node -> recursion(node));
		return nodeTree;
	}

	private void recursion(TreeIntegerNode node) {
		if (node.getChildren() != null && node.getChildren().size() > 0) {
			if (node.getId().equals(1030)) {
				int sum = node.getChildren().stream().mapToInt(TreeIntegerNode::getCount).sum();
				node.setCount(sum);
			}
			if (node.getId().equals(1031)) {
				int sum = node.getChildren().stream().mapToInt(TreeIntegerNode::getCount).sum();
				node.setCount(sum);
			}
			node.getChildren().forEach(node2 -> recursion(node2));
		} else {
			node.setChildren(null);
		}
	}

	/**
	 * 通过小区id查询用户
	 * @param householdVO
	 * @param page
	 * @return
	 */
	@Override
	public IPage<HouseholdVO> getUserInfoByDistrictIds(HouseholdVO householdVO, IPage<HouseholdVO> page) {
		List<String> list = Func.toStrList(householdVO.getDistrictIds());
		List<HouseholdVO> userInfoByDistrictIds = baseMapper.getUserInfoByDistrictIds(list, householdVO, page);
		return page.setRecords(userInfoByDistrictIds);
	}

	/**
	 * 查询住户对应的社区编号
	 * @param id
	 * @return
	 */
	@Override
	public String getCommunityCode(Long id) {
		return baseMapper.getCommunityCode(id);
	}

	/**
	 * 查询所有住户总数
	 * @return
	 */
	@Override
	public int getAllListTotal() {
		return baseMapper.getAllListTotal();
	}

	/**
	 * 查询对应的住户集合
	 * @param i
	 * @param size
	 * @return
	 */
	@Override
	public List<HouseholdVO> getAllList(int i, int size) {
		return baseMapper.getAllList(i,size);
	}
}