package com.yeejoin.amos.boot.module.common.biz.service.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Sequence;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.google.common.collect.Lists;
import com.yeejoin.amos.boot.biz.common.bo.ReginParams;
import com.yeejoin.amos.boot.biz.common.dao.mapper.DataDictionaryMapper;
import com.yeejoin.amos.boot.biz.common.entity.BaseEntity;
import com.yeejoin.amos.boot.biz.common.entity.DataDictionary;
import com.yeejoin.amos.boot.biz.common.utils.RedisKey;
import com.yeejoin.amos.boot.biz.common.utils.RedisUtils;
import com.yeejoin.amos.boot.module.common.api.dto.*;
import com.yeejoin.amos.boot.module.common.api.entity.KeySite;
import com.yeejoin.amos.boot.module.common.api.entity.OrgUsr;
import com.yeejoin.amos.boot.module.common.api.entity.SourceFile;
import com.yeejoin.amos.boot.module.common.api.enums.OrgPersonEnum;
import com.yeejoin.amos.boot.module.common.api.feign.EquipFeignClient;
import com.yeejoin.amos.boot.module.common.api.mapper.KeySiteMapper;
import com.yeejoin.amos.boot.module.common.api.mapper.OrgUsrMapper;
import com.yeejoin.amos.boot.module.common.api.service.IKeySiteService;
import com.yeejoin.amos.boot.module.common.api.service.IOrgUsrService;
import com.yeejoin.amos.feign.privilege.model.AgencyUserModel;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.typroject.tyboot.core.foundation.context.RequestContext;
import org.typroject.tyboot.core.foundation.utils.Bean;
import org.typroject.tyboot.core.foundation.utils.ValidationUtil;
import org.typroject.tyboot.core.rdbms.service.BaseService;
import org.typroject.tyboot.core.restful.exception.instance.BadRequest;
import org.typroject.tyboot.core.restful.utils.ResponseModel;

import javax.annotation.Resource;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 重点部位服务实现类
 *
 * @author system_generator
 * @date 2021-07-26
 */
@Service
public class KeySiteServiceImpl extends BaseService<KeySiteDto, KeySite, KeySiteMapper> implements IKeySiteService {

	@Autowired
	KeySiteMapper keySiteMapper;

	@Autowired
	SourceFileServiceImpl sourceFileService;

	@Autowired
	OrgUsrMapper orgUsrMapper;

	@Autowired
	IOrgUsrService iOrgUsrService;

	@Autowired
	EquipFeignClient equipFeignClient;

	@Autowired
	private Sequence sequence;

	@Value("${auth-key-key-site:key_site_info}")
	private String authKey;

	@Autowired
	private RedisUtils redisUtils;
    private static final  String BIZORGCODE= "bizOrgCode";
	private static final  String CHILDREN= "children";
	private static final  String PARENTID ="parentId";
	@Resource
	DataDictionaryMapper dataDictionaryMapper;

	/**
	 * 分页查询
	 */
	public IPage<KeySiteDto> getPageList(Page<KeySiteDto> page, String name, Long buildingId, String fireEnduranceRate,
			String useNature, String fireFacilitiesInfo, String bizOrgCode,String belongId) {
		List<Long> ids = null;
		if (buildingId != null&& buildingId!=-1 && buildingId.intValue() != 0) {
			ids = getNodeAllnodeIds(buildingId);
		}
		return keySiteMapper.getPageList(page, name, ids, fireEnduranceRate, useNature, fireFacilitiesInfo, bizOrgCode,belongId);
	}

	@Override
	public List<Object> getBuildTree() {
		List<Object> da=null;
		ResponseModel<Object> response = equipFeignClient.getBuildingTree();
		if (200 == response.getStatus() && ObjectUtils.isNotEmpty(response.getResult())) {
			return JSON.parseArray(JSON.toJSONString(response.getResult()));
		}
		return da;
	}

	/**
	 * 列表查询 示例
	 */
	@Override
	public List<KeySiteDto> queryForKeySiteList(String name, Long buildingId, String fireEnduranceRate,
			String useNature, String fireFacilitiesInfo, String bizOrgCode) {
		return keySiteMapper.getKeySiteList(name, buildingId, fireEnduranceRate, useNature, fireFacilitiesInfo,
				bizOrgCode);
	}

	@Override
	public List<KeySiteExcleDto> exportToExcel(String name, Long buildingId, String fireEnduranceRate, String useNature,
			String fireFacilitiesInfo, String bizOrgCode) {
		// 导出模板增加权限
		ReginParams reginParams = JSON.parseObject(redisUtils
				.get(RedisKey.buildReginKey(RequestContext.getExeUserId(), RequestContext.getToken())).toString(),
				ReginParams.class);
		// 权限处理

		String bizOrgCodeNew = reginParams.getPersonIdentity().getBizOrgCode();

		List<KeySiteDto> list = this.queryForKeySiteList(name, buildingId, fireEnduranceRate, useNature,
				fireFacilitiesInfo, bizOrgCodeNew);
		List<KeySiteExcleDto> excleList = new ArrayList<>();
		list.forEach(i -> {
			KeySiteExcleDto keySiteExcleDto = new KeySiteExcleDto();
			Bean.copyExistPropertis(i, keySiteExcleDto);
			if (i.getFirePreventionFlag()) {
				keySiteExcleDto.setFirePreventionFlagName("有");
			} else {
				keySiteExcleDto.setFirePreventionFlagName("无");
			}
			keySiteExcleDto.setUseNature(i.getUseNatureName());
			keySiteExcleDto.setBelongName(i.getBelongName());
			keySiteExcleDto.setFireEnduranceRate(i.getFireEnduranceRateName());
			excleList.add(keySiteExcleDto);
		});
		return excleList;
	}

	@Override
	public boolean deleteById(List<Long> sequenceNbrList) {
		if (ObjectUtils.isEmpty(sequenceNbrList)) {
			return false;
		}
		try {
			sequenceNbrList.stream().forEach(i -> {
				KeySite keySite = keySiteMapper.selectById(i);
				if (keySite != null) {
					keySite.setIsDelete(true);
					keySiteMapper.updateById(keySite);
				}
			});
		} catch (Exception e) {
			return false;
		}
		return true;
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public KeySiteDto save(KeySiteDto model) {
		long sequenceId = sequence.nextId();
		KeySite keySite = new KeySite();
		Bean.copyExistPropertis(model, keySite);
		keySite.setSequenceNbr(sequenceId);
		model.setSequenceNbr(sequenceId);
		this.save(keySite);
		saveAttachments(model);
		// TODO Auto-generated method stub
		return model;
	}

	public void saveAttachments(KeySiteDto keySiteDto) {
		if (!ValidationUtil.isEmpty(keySiteDto.getAttachments())) {
			List<SourceFile> sourceFiles = Lists.newArrayList();
			Map<String, List<AttachmentDto>> attachmentMap = keySiteDto.getAttachments();
			attachmentMap.entrySet().forEach(entry -> {
				List<AttachmentDto> atts = entry.getValue();
				sourceFiles.addAll(attachment2SourceFile(entry.getKey(), atts));
			});
			sourceFileService.saveSourceFile(keySiteDto.getSequenceNbr(), sourceFiles);
		}
	}

	private List<SourceFile> attachment2SourceFile(String type, List<AttachmentDto> attachmentDtoList) {
		List<SourceFile> sourceFiles = Lists.newArrayList();
		if (!ValidationUtil.isEmpty(attachmentDtoList)) {
			attachmentDtoList.forEach(a -> {
				SourceFile s = new SourceFile();
				s.setFilePath(a.getUrl());
				s.setFileName(a.getName());
				s.setFileCategory(type);
				sourceFiles.add(s);
			});
		}
		return sourceFiles;
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public boolean update(KeySiteDto keySite, AgencyUserModel userInfo) {
		KeySite entity = new KeySite();
		Bean.copyExistPropertis(keySite, entity);
		entity.setIsDelete(false);
		entity.setRecDate(new Date());
		entity.setRecUserId(userInfo.getUserId());
		entity.setRecUserName(userInfo.getRealName());
		List<String> ids = new ArrayList<String>();
		ids.add(entity.getBuildingId().toString());
		Map<String, String> map3 = getNodeAllParentIds(ids);
		entity.setParentBuildingId(map3.get(entity.getBuildingId().toString()));
		int num = keySiteMapper.updateById(entity);
		Map<String, List<AttachmentDto>> map = keySite.getAttachments();
		if (ObjectUtils.isNotEmpty(map)) {
			this.saveAttachments(keySite);
		}
		if (num > 0) {
			return true;
		}
		return false;
	}

	@Override
	public List<OrgMenuDto> getOrgUserTree(ReginParams reginParams) {
		List<OrgUsr> comDeptList = iOrgUsrService.getListByBizOrgTypeCode(
				OrgPersonEnum.公司.getKey() + "," + OrgPersonEnum.部门.getKey(),
				reginParams.getPersonIdentity().getBizOrgCode());
		List<KeySite> keySiteList = this.list(new LambdaQueryWrapper<KeySite>().eq(BaseEntity::getIsDelete, false));
		comDeptList = comDeptList.stream().filter(u->StringUtils.isNotEmpty(u.getBizOrgCode())).map(c -> c.setTotal(keySiteList.stream()
				.filter(k -> StringUtils.isNotBlank(k.getBizOrgCode()) && k.getBizOrgCode().contains(c.getBizOrgCode()))
				.count())).collect(Collectors.toList());
		List<OrgMenuDto> menuList = comDeptList.stream().map(o -> {

			return new OrgMenuDto(o.getSequenceNbr(), o.getBizOrgName(),
					ObjectUtils.isEmpty(o.getParentId()) ? 0L : Long.parseLong(o.getParentId()), o.getBizOrgType(), false,
					o.getBizOrgCode());
		}).collect(Collectors.toList());
		return buildTreeParallel(menuList);
	}

	public static List<OrgMenuDto> buildTreeParallel(List<OrgMenuDto> menuList) {

		List<OrgMenuDto> result = new ArrayList<>();
		Map<Long, OrgMenuDto> map = new HashMap<>(menuList.size());
		menuList.forEach(e -> map.put(e.getKey(), e));
		Set<? extends Map.Entry<Long, ? extends OrgMenuDto>> entries = map.entrySet();
		entries.stream().forEach(entry -> {
			OrgMenuDto value = entry.getValue();
			if (value != null) {
				OrgMenuDto treeDto = map.get(value.getParentId());
				if (treeDto != null) {
					List<OrgMenuDto> children = treeDto.getChildren();
					if (children == null) {
						children = new ArrayList<>();
						treeDto.setChildren(children);
					}
					children.add(value);
				} else {
					result.add(value);
				}
			}
		});
		return result;
	}

	@Override
	public KeySiteDto getSequenceNbr(Long sequenceNbr) {
		return keySiteMapper.getSequenceNbr(sequenceNbr);
	}


	private String[] getDataDictionary(String type) {
		QueryWrapper<DataDictionary> queryWrapper = new QueryWrapper<>();
		queryWrapper.eq("type", type);
		queryWrapper.orderByAsc("sort_num");
		List<DataDictionary> list = dataDictionaryMapper.selectList(queryWrapper);
		List<String> names = list.stream().map(dataDictionary -> {
			return dataDictionary.getName() + "@" + dataDictionary.getCode();
		}).collect(Collectors.toList());
		String[] str = names.toArray(new String[names.size()]);
		return str;
	}

	@Override
	public boolean saveExcel(List<KeySiteExcleDto> excelDtoList) {
		Map<String, String> maps = getAllBuildingIdForParentBuilingIds(excelDtoList);
		List<KeySite> excelList = new ArrayList<KeySite>();

		Map<String, Object> param = new HashMap<>();
		param.put(BIZORGCODE, null);
		param.put("type", null);

		List<OrgUsr> comDeptList = orgUsrMapper.companyTreeByUserAndType(param);
		Map<Long, OrgUsr> comDeptMap = comDeptList.stream()
				.collect(Collectors.toMap(BaseEntity::getSequenceNbr, Function.identity()));
		//耐火等级
		String[] nhdjs = getDataDictionary("NHDJ");
		//使用性质
		String[] jzwsyxzs = getDataDictionary("JZWSYXZ");

		for (KeySiteExcleDto keySiteExcleDto : excelDtoList) {
			KeySite keySiteDto = new KeySite();
			Bean.copyExistPropertis(keySiteExcleDto, keySiteDto);
			keySiteDto.setIsDelete(false);
			if (StringUtils.isNotBlank(keySiteExcleDto.getBelongName())
					&& keySiteExcleDto.getBelongName().contains("@")) {
				keySiteDto.setBelongId(Long.parseLong(keySiteExcleDto.getBelongName().split("@")[1]));
				keySiteDto
						.setBizOrgCode(comDeptMap.getOrDefault(keySiteDto.getBelongId(), new OrgUsr()).getBizOrgCode());
				keySiteDto
						.setBizOrgName(comDeptMap.getOrDefault(keySiteDto.getBelongId(), new OrgUsr()).getBizOrgName());
			}
			if (StringUtils.isNotBlank(keySiteExcleDto.getBuildingName())
					&& keySiteExcleDto.getBuildingName().contains("@")) {
				String[] fireEnduranceRateArray = keySiteExcleDto.getBuildingName().split("@");
				keySiteDto.setBuildingId(Long.parseLong(fireEnduranceRateArray[1]));
				keySiteDto.setBuildingName(fireEnduranceRateArray[0]);
				if (maps.containsKey(fireEnduranceRateArray[1])) {
					keySiteDto.setParentBuildingId(maps.get(fireEnduranceRateArray[1]));
				}

			}
			if (StringUtils.isNotBlank(keySiteExcleDto.getFireEnduranceRate())
					&& keySiteExcleDto.getFireEnduranceRate().contains("@")) {
				if (!ArrayUtils.contains(nhdjs, keySiteExcleDto.getFireEnduranceRate())) {
					throw new BadRequest("请检查耐火等级选择是否正确");
				}
				String[] fireEnduranceRateArray = keySiteExcleDto.getFireEnduranceRate().split("@");
				if (fireEnduranceRateArray.length > 1) {
					keySiteDto.setFireEnduranceRate(fireEnduranceRateArray[1]);
				}
				keySiteDto.setFireEnduranceRateName(fireEnduranceRateArray[0]);
			}
			if (StringUtils.isNotBlank(keySiteExcleDto.getUseNature())
					&& keySiteExcleDto.getUseNature().contains("@")) {
				if (!ArrayUtils.contains(jzwsyxzs, keySiteExcleDto.getUseNature())) {
					throw new BadRequest("请检查使用性质选择是否正确");
				}
				String[] useNatureArray = keySiteExcleDto.getUseNature().split("@");
				if (useNatureArray.length > 1) {
					keySiteDto.setUseNature(useNatureArray[1]);
				}
				keySiteDto.setUseNatureName(useNatureArray[0]);
			}
			if ("有".equals(keySiteExcleDto.getFirePreventionFlagName())) {
				keySiteDto.setFirePreventionFlag(true);
			} else {
				keySiteDto.setFirePreventionFlag(false);
			}
			keySiteDto = Bean.toPo(getCurrentInfo(), keySiteDto);
			excelList.add(keySiteDto);
		}
		return this.saveBatch(excelList);
	}

	public Map<String, String> getAllBuildingIdForParentBuilingIds(List<KeySiteExcleDto> excelDtoList) {
		List<String> list = new ArrayList<String>();
		for (KeySiteExcleDto keySiteExcleDto : excelDtoList) {
			if (StringUtils.isNotBlank(keySiteExcleDto.getBuildingName())
					&& keySiteExcleDto.getBuildingName().contains("@")) {
				String[] fireEnduranceRateArray = keySiteExcleDto.getBuildingName().split("@");
				list.add(fireEnduranceRateArray[1]);
			}
		}
		return getNodeAllParentIds(list);
	}

	public BaseEntity getCurrentInfo() {
		BaseEntity userModel = new BaseEntity();
		userModel.setRecUserId("3141675");
		userModel.setRecUserName("admin_jcs");
		userModel.setRecDate(new Date());
		return userModel;
	}

	@Override
	public List<OrgMenuDto> getBuildAndKeyTree(Long sequenceNbr) {
		List<OrgMenuDto> dal=null;
		LambdaQueryWrapper<KeySite> mapper = new LambdaQueryWrapper<KeySite>();
		mapper.eq(KeySite::getBuildingId, sequenceNbr);
		mapper.eq(KeySite::getIsDelete, false);
		List<KeySite> list = this.baseMapper.selectList(mapper);
		if (list == null || list.size() == 0) {
			return dal;
		}
		String buildNameString = list.get(0).getBuildingName();
		List<OrgMenuDto> menuList = list.stream().map(o -> {
			OrgMenuDto menu = new OrgMenuDto(o.getSequenceNbr(), o.getName(),
					ObjectUtils.isEmpty(o.getBelongId()) ? 0L : Long.valueOf(o.getBelongId()), null, false, null);
			return menu;
		}).collect(Collectors.toList());
		List<OrgMenuDto> list1 = new ArrayList<OrgMenuDto>();
		OrgMenuDto orgMenuDto = new OrgMenuDto();
		orgMenuDto.setKey(sequenceNbr);
		orgMenuDto.setValue(sequenceNbr);
		orgMenuDto.setChildren(buildTreeParallel(menuList));
		orgMenuDto.setName(buildNameString);
		orgMenuDto.setTitle(buildNameString);
		list1.add(orgMenuDto);
		return list1;
	}


	@Override
	public List<KeySiteDateDto> getKeySiteDate(Long id) {
		return keySiteMapper.getKeySiteDate(id);
	}

	public List<String> getAddress() {
		return keySiteMapper.getAddress();
	}

	@Override
	public List<KeySite> getKeySiteDateByNameLike(Long companyId) {
		LambdaQueryWrapper<KeySite> mapper = new LambdaQueryWrapper<KeySite>();
		mapper.eq(KeySite::getIsDelete, false);
		if (companyId != null && companyId.longValue() != 0) {
			mapper.eq(KeySite::getBelongId, companyId);
		}
		return this.baseMapper.selectList(mapper);
	}

	@SuppressWarnings("unchecked")
	@Override
	public List<Map<String, Object>> keySiteCountAndBuildingTree(String bizOrgCode) {
		List<Map<String, Object>> da=null;
		int allCount = 0;
		Map<String, Integer> keySiteCountMap = parseKeySiteCount(bizOrgCode);
		ResponseModel<Object> response = equipFeignClient.getBuildingTree();
		List<Map<String, Object>> buildingMapList = (List<Map<String, Object>>) response.getResult();
		if (buildingMapList == null || buildingMapList.size() < 1) {
			return da;
		}
		List<Map<String, Object>> childrens  = ((List<Map<String, Object>>) buildingMapList.get(0).get(CHILDREN)).stream().filter(i->i.containsKey(BIZORGCODE) && i.get(BIZORGCODE).toString().contains(bizOrgCode)).collect(Collectors.toList());
		Map<String, Object> reMap = parseTree(childrens,
				keySiteCountMap, allCount);
		Map<String, Object> fristMap = buildingMapList.get(0);
		fristMap.put("id", 0);
		fristMap.put("name", fristMap.get("instanceName") + "(" + reMap.get("allCount") + ")");
		fristMap.put(CHILDREN, reMap.get(CHILDREN));
		buildingMapList.clear();
		buildingMapList.add(fristMap);
		return buildingMapList;
	}

	@SuppressWarnings("unchecked")
	private Map<String, Object> parseTree(List<Map<String, Object>> children, Map<String, Integer> keySiteCountMap,
			int allCount) {
		Map<String, Object> resultMap = new HashMap<String, Object>();
		if (!ValidationUtil.isEmpty(children)) {
			for (Map<String, Object> child : children) {
				if (child.get("id") != null) {
					if (keySiteCountMap.containsKey(child.get("id").toString())) {
						allCount = allCount + keySiteCountMap.get(child.get("id").toString()).intValue();
						child.put("name",
								child.get("name") + "(" + keySiteCountMap.get(child.get("id").toString()) + ")");
					} else {
						child.put("name", child.get("name") + "(" + 0 + ")");
					}
				} else {
					child.put("name", child.get("name") + "(" + 0 + ")");
				}
				if (!ValidationUtil.isEmpty(child.get(CHILDREN))) {
					parseTree((List<Map<String, Object>>) child.get(CHILDREN), keySiteCountMap, allCount);
				}
			}
		}
		resultMap.put(CHILDREN, children);
		resultMap.put("allCount", allCount);
		return resultMap;
	}

	private Map<String, Integer> parseKeySiteCount(String bizOrgCode) {
		Map<String, Integer> map = new HashMap<String, Integer>();

		List<Map<String, Object>> list = keySiteMapper.getKeySiteCount(bizOrgCode);
		for (Map<String, Object> map2 : list) {
			Object parentBuilingIdString = map2.get("parent_building_id");
			if (ObjectUtils.isEmpty(parentBuilingIdString)) {
				continue;
			}
			String[] parentBuilingIdArray = parentBuilingIdString.toString().split(",");
			for (int i = 0; i < parentBuilingIdArray.length; i++) {
				if (map.containsKey(parentBuilingIdArray[i])) {
					int num = map.get(parentBuilingIdArray[i]).intValue();
					num = num + Integer.parseInt(map2.get("count").toString());
					map.put(parentBuilingIdArray[i], num);
				} else {
					map.put(parentBuilingIdArray[i], Integer.parseInt(map2.get("count").toString()));
				}
			}
		}
		return map;

	}

	public Map<String, String> getNodeAllParentIds(List<String> ids) {
		Map<String, String> map = new HashMap<String, String>();
		ResponseModel<List<Map<String, Object>>> response = equipFeignClient.getBuildingTreeList();
		List<Map<String, Object>> responseList = response.getResult();
		if (response.getResult() == null && response.getResult().size() < 1) {
			return null;
		}
		ids.stream().forEach(i -> {

			String tegartString = getNodeAllParentIds(responseList, i, i);
			map.put(i, tegartString);
		});
		return map;
	}

	private String getNodeAllParentIds(List<Map<String, Object>> list, String id, String tegartString) {
		for (Map<String, Object> map : list) {
			if (map.get("id").toString().equals(id) && map.get(PARENTID) != null) {
				tegartString = tegartString + "," + map.get(PARENTID).toString();
				 getNodeAllParentIds(list, map.get(PARENTID).toString(), tegartString);
			}
		}
		return tegartString;
	}

	public List<Long> getNodeAllnodeIds(Long id) {
		List<Long> da=null;
		List<Long> resultList = new ArrayList<Long>();
		resultList.add(id);
		ResponseModel<List<Map<String, Object>>> response = equipFeignClient.getBuildingTreeList();
		List<Map<String, Object>> responseList = response.getResult();
		if (response.getResult() == null && response.getResult().size() < 1) {
			return da;
		}
		return getNodeAllnodeIds(resultList, responseList, id.toString());
	}

	private List<Long> getNodeAllnodeIds(List<Long> resultList, List<Map<String, Object>> list, String id) {
		for (Map<String, Object> map : list) {
			if (map.get(PARENTID).toString().equals(id) && map.get(PARENTID) != null) {
				resultList.add(Long.parseLong(map.get("id").toString()));
				getNodeAllnodeIds(resultList, list, map.get("id").toString());
			}
		}
		return resultList;
	}
}
