/*
 *      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 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.modules.grid.service.IGridService;
import org.springblade.modules.house.entity.HouseholdEntity;
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.vo.HouseholdOtherVO;
import org.springblade.modules.house.vo.HouseholdVO;
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.*;

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

	@Autowired
	private IGridService gridService;

	@Autowired
	private IDictBizService dictBizService;

	@Autowired
	private IUserService userService;

	@Autowired
	private IDeptService deptService;

	@Override
	public IPage<HouseholdVO> selectHouseholdPage(IPage<HouseholdVO> page, HouseholdVO household) {
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
// doInsert();
// 执行业务等
		Dept dept = deptService.getById(AuthUtil.getDeptId());
		if (null!=dept){
			household.setRegionCode(dept.getRegionCode());
		}
		List<HouseholdVO> householdVOS = baseMapper.selectHouseholdPage(page, household);
		// 遍历
		// for (HouseholdVO householdVO : householdVOS) {
		// 	// 设置对应的网格名称
		// 	GridVO gridVO = gridService.getGridDetailByHouseCode(householdVO.getHouseCode());
		// 	if (null!= gridVO){
		// 		householdVO.setGridName(gridVO.getGridName());
		// 	}
		// }
		// 返回
		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
	public boolean saveOrUpdateHousehold(HouseholdEntity household) {
		// 判断添加人是否房屋业主
//		Long count = count(Wrappers.<HouseholdEntity>lambdaQuery()
//			.eq(HouseholdEntity::getHouseCode, household.getHouseCode())
//			.eq(HouseholdEntity::getAssociatedUserId, AuthUtil.getUserId())
//			.eq(HouseholdEntity::getRelationship, 1));
//		if (count == 0) {
//			return false;
//		}
		boolean flag = false;
		household.setUpdateTime(new Date());
		household.setUpdateUser(AuthUtil.getUserId());
		if (null != household.getId()) {
			// 更新
			flag = updateById(household);
			// 更新用户信息
			updateUserInfo(household);
		} else {
			// 新增
			household.setCreateTime(new Date());
			household.setCreateUser(AuthUtil.getUserId());
			flag = save(household);
			// 更新用户信息
			updateUserInfo(household);
		}
		return flag;
	}

	/**
	 * 更新用户信息
	 * @param household
	 */
	public void updateUserInfo(HouseholdEntity household) {
		// 判断用户是否为业主，如果是业主，判断该房屋是否已有业主，如果有则提示已有业主，无法设置为业主，不是业主则不操作
		if (null!=household.getRelationship() && household.getRelationship()==1){
			// 如果为业主
			// 查询当前房屋是否已有业主
			QueryWrapper<HouseholdEntity> queryWrapper = new QueryWrapper<>();
			queryWrapper.eq("is_deleted",0)
				.eq("house_code",household.getHouseCode())
				.eq("relationship",1);
			List<HouseholdEntity> list = list(queryWrapper);
			if (list.size()==0){
				// 新增用户
				bindUserHandle(household);
			}else {
				HouseholdEntity householdEntity = list.get(0);
				if (null == householdEntity.getAssociatedUserId()){
					// 新增用户
					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) {
				//如果用户存在，则该用户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;
		}

	}
}