/*
 *      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 com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
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.node.TreeStringNode;
import org.springblade.core.mp.support.Condition;
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.grid.service.IGridService;
import org.springblade.modules.house.entity.HouseholdEntity;
import org.springblade.modules.house.entity.UserHouseLabelEntity;
import org.springblade.modules.house.excel.HouseHoldExcel;
import org.springblade.modules.house.mapper.HouseholdMapper;
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.place.entity.PlaceEntity;
import org.springblade.modules.place.service.IPlaceService;
import org.springblade.modules.system.entity.Dept;
import org.springblade.modules.system.entity.DictBiz;
import org.springblade.modules.system.entity.User;
import org.springblade.modules.system.service.IDeptService;
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.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 IDeptService deptService;

	@Autowired
	private IPlaceService placeService;

	@Override
	public IPage<HouseholdVO> selectHouseholdPage(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.selectHouseholdPage(page, household);
		stopWatch.stop();
		System.out.println("selectHouseholdPage:" + stopWatch.getTotalTimeMillis());
		return page.setRecords(householdVOS);
	}

	/**
	 * 查询房屋集合信息
	 * @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");
			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 (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("")) {
			//根据手机号查询库里的数据
			User userParams = new User();
			userParams.setPhone(householdEntity.getPhoneNumber());
			User user = userService.getOne(Condition.getQueryWrapper(userParams));
			if (null==user) {
				User userParams1 = new User();
				userParams1.setAccount(householdEntity.getPhoneNumber());
				userParams1.setIsDeleted(0);
				user = userService.getOne(Condition.getQueryWrapper(userParams1));
			}
			if (null!=user) {
				//如果用户存在，则该用户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);
	}

	@Override
	public List<HouseHoldExcel> export(HouseholdVO household) {
		List<HouseHoldExcel> userHouseHoldExcels = baseMapper.export(household);
		return userHouseHoldExcels;
	}


	@Override
	@Transactional(rollbackFor = Exception.class)
	public void importUserHouseHold(List<HouseHoldExcel> data, Boolean isCovered) {
		data.forEach(houseHoldExcel -> {
			HouseholdEntity houseHoldEntity = Objects.requireNonNull(BeanUtil.copy(houseHoldExcel, HouseholdEntity.class));
			this.save(houseHoldEntity);
		});
	}

	/**
	 * 住户审核统计
	 * @param userId
	 * @return
	 */
	@Override
	public Integer statistics(Long userId,String neiCode) {
		return baseMapper.statistics(userId,neiCode);
	}

	/**
	 * 住户对应物业，网格，公安负责人查询
	 * @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 (householdEntity.getRelationship()==1){
				// 查询对应的用户
				User user = userService.getById(householdEntity.getAssociatedUserId());
				// 判断角色
				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 (stringList.size()>1){
						// 查询是否对应有场所负责人，如果有则不删除，如果没有则删除对应的角色
						List<String> arrayList = new ArrayList<>();
						if (placeEntityList.size()==0){
							for (String roleId : stringList) {
								if (!roleId.equals("1717429059648606209")){
									arrayList.add(roleId);
								}
							}
						}
						user.setRoleId(StringUtils.join(arrayList, ","));
						// 更新用户
						userService.updateById(user);
					}else {
						// 查询是否对应有场所负责人，如果有则不删除，如果没有则删除对应的用户
						if (placeEntityList.size()==0){
							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;
	}
}