package com.vci.ubcs.code.applyjtcodeservice.feigh;

import com.alibaba.cloud.commons.lang.StringUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.vci.ubcs.code.applyjtcodeservice.entity.*;
import com.vci.ubcs.code.applyjtcodeservice.feign.IMdmInterJtClient;
import com.vci.ubcs.code.applyjtcodeservice.service.*;
import com.vci.ubcs.code.applyjtcodeservice.vo.*;
import com.vci.ubcs.code.feign.IMdmEngineClient;
import com.vci.ubcs.starter.revision.model.BaseModel;
import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
import com.vci.ubcs.starter.util.MdmBtmTypeConstant;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.NotNull;
import org.springblade.core.tenant.annotation.NonDS;
import org.springblade.core.tool.api.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.RestController;
import springfox.documentation.annotations.ApiIgnore;

import java.util.*;
import java.util.stream.Collectors;

/***
 * 提供与集团申请feigh
 */
@NonDS
@ApiIgnore
@RestController
@Data
@Slf4j
public class MdmInterJtClient implements IMdmInterJtClient {
	@Value("${docking.apply.partCoe:10}")
	public String partCoe;
	/**
	 * 集团申请单服务
	 */
	private final IDockingPreApplyFormService dockingPreApplyFormService;

	/**
	 * 集团分类模型视图服务
	 */
	private final IDockingPreViewModelService dockingPreViewModelService;

	/**
	 * 集团分类属性服务
	 */
	private final IDockingPreMetaAttrService dockingPreMetaAttrService;

	/**
	 * 集团分类申请单服务
	 */
	private final IDockingPreClassifyService dockingPreClassifyService;
	/***
	 * 属性映射服务
	 */
	private final IDockingPreAttrMappingService dockingPreAttrMappingService;
	/**
	 * 集团取值范围申请单服务
	 */
	private final IDockingPreAttrRangeService dockingPreAttrRangeService;

	/**
	 * 集团属性映射配置属性
	 */
	private final IGroupMdmInterService groupMdmInterService;

	@Autowired(required = false)
	private IMdmEngineClient mdmEngineClient;
	/***
	 * 申请集团编码
	 * @return
	 */
	public R applyGroupCode(String oids,String btmName){
		try {
			return groupMdmInterService.applyGroupCode(oids,btmName);
		}catch (Throwable e){
			return R.fail("集团码申请失败："+e.getMessage());
		}
	}

	/***
	 * 查询集团属性映射
	 * @param codeClassifyOid:编码分类oid
	 * @return
	 */
	@Override
	public R<List<DockingPreAttrMappingVO>> list_mapping(String codeClassifyOid) {
		List<DockingPreAttrMapping> dockingPreAttrMappings=	dockingPreAttrMappingService.selectByWrapper(Wrappers.<DockingPreAttrMapping>query().lambda().eq(DockingPreAttrMapping::getTargetClassifyId,codeClassifyOid));
		List<DockingPreAttrMappingVO> dockingPreAttrMappingVOList=new ArrayList<>();
		if(!CollectionUtils.isEmpty(dockingPreAttrMappings)){
			dockingPreAttrMappingVOList=dockingPreAttrMappingService.dockingPreAttrMappingDO2VOS(dockingPreAttrMappings,true);
		}
		return R.data(dockingPreAttrMappingVOList);
	}

	/***
	 * 申请集团编码数据维护
	 * @return
	 */
	@Override
	public R receiveEditApply(String oids, String btmName) {
		try {
			return groupMdmInterService.receiveEditApply(oids,btmName);
		}catch (Throwable e){
			return R.fail("集团码数据修改失败："+e.getMessage());
		}
	}
	/*
	 * 主数据业务服务
	 */
	/**
	 * 获取集团集团码，赋值到主数据
	 * @param dockingReturnStoreVO
	 * @return 返回集成结果信息
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public R getApplyGroupCode(DockingReturnStoreVO dockingReturnStoreVO) {
		log.info("获取集团集团码，赋值到主数据 start");
		try {
			Map<String,List<BaseModel>> editObjectMap = new HashMap<>();

			List<DockingPreApplyForm> dockingPreApplyFormList = new ArrayList();
			//String classId = javaObject.getClassId();
			//String sysName = javaObject.getSysName();
			List<MainData> mainDataList = dockingReturnStoreVO.getMainData();
			for (MainData mainData : mainDataList) {
				JSONObject jcontent = new JSONObject();
				//编码状态
				String formState = mainData.getFormState();
				//申请单
				String applyId = mainData.getApplyId();
				String customCoding = StringUtils.isBlank(mainData.getCustomCoding()) ? "" : mainData.getCustomCoding();//集团码
				String msg = "";
				log.info("申请单:"+applyId+",集团码："+customCoding);
				boolean res = false;
				if ("1".equals(formState)) {
					msg = "集团审核中";
				} else if ("2".equals(formState)) {
					msg = "驳回";
				} else if ("3".equals(formState)) {
					msg = "集团审核中";
				} else if ("4".equals(formState)) {
					msg = "审核结束，赋码失败";
				} else if ("5".equals(formState)) {
					res = true;
					msg = "审核结束，赋码成功";
				} else if ("6".equals(formState)) {
					msg = "待301赋码";
				} else if ("7".equals(formState)) {
					res = true;
					msg = "已赋码";
				} else if ("8".equals(formState)) {
					res = true;
					msg = "已赋码（沿用）";
				} else if ("9".equals(formState)) {
					msg = "审核中";
				}
				jcontent.put("applyId", applyId);
				jcontent.put("formState", formState);
				jcontent.put("customCoding", customCoding);
				jcontent.put("msg", msg);
				List<DockingPreApplyForm> oldDockingPreApplyFormList = dockingPreApplyFormService.list(Wrappers.<DockingPreApplyForm>query().lambda()
					.eq(DockingPreApplyForm::getId, applyId));
				if (CollectionUtils.isEmpty(oldDockingPreApplyFormList)) {
					continue; //// return false;
				}
				DockingPreApplyForm dockingPreApplyForm = oldDockingPreApplyFormList.get(0);
				dockingPreApplyForm.setMsg(msg);
				dockingPreApplyForm.setCode("1");
				if (res) {
					dockingPreApplyForm.setGroupCode(customCoding);
				}
				//返回结果信息
				dockingPreApplyForm.setContent(jcontent.toJSONString());
				dockingPreApplyFormList.add(dockingPreApplyForm);
				String jdataid = dockingPreApplyForm.getDataOid();
				String jdatabtmname = dockingPreApplyForm.getDataBtmName();
				if (res) {
					//此处需要查询业务数据，去更改
					BaseModel baseModel = new BaseModel();
					String classOid=baseModel.getData().getOrDefault("CODECLSFID","");
					if(partCoe.equals(classOid)){
						baseModel.setId(10+customCoding);
					}
					String btmeName=baseModel.getBtmname();
					baseModel.getData().put("groupcode",customCoding);
					log.info("申请单:"+applyId+",集团码："+customCoding+"编码："+baseModel.getId());
					editObjectMap.getOrDefault(btmeName,new ArrayList<>()).add(baseModel);

				}
			}
			if(!CollectionUtils.isEmpty(editObjectMap)) {
				//调用主数据服务批量保存接口
				editObjectMap.forEach((btmName, modeList) -> {
					mdmEngineClient.updateBatchBtypeDatas(btmName, modeList);
				});
			}
			dockingPreApplyFormService.saveOrUpdateBatch(dockingPreApplyFormList);
		}catch (Throwable e){
			e.printStackTrace();
			return R.fail("集团码集成赋值失败"+e);
		}
		log.info("获取集团集团码，赋值到主数据 end");
		return R.success("集团码赋值成功");
	}

	/***
	 * 接受集团分类主模型数据
	 * @param dockingClassifyModelAttrVO
	 * @return
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public R pubMdmModel(DockingClassifyModelAttrVO dockingClassifyModelAttrVO) {
		log.info("");
		try {
			this.saveDatas(dockingClassifyModelAttrVO);
		}catch (Throwable e){
			e.printStackTrace();
			return R.fail("接受集团分类主模型数据失败"+e);
		}
		log.info("接受集团分类主模型数据 end");
		return R.success("接受集团分类主模型数据成功");
	}

	/***
	 * 组织 保存数据方法
	 * @param dockingClassifyModelAttrVO
	 * @throws Throwable
	 */
	private boolean saveDatas(DockingClassifyModelAttrVO dockingClassifyModelAttrVO) throws Throwable {
		List<DockingPreClassify> dockingPreClassifyArrayList=new ArrayList<>();
		try {
			DockingClassifyMainVO mainData = dockingClassifyModelAttrVO.getDataStructure();
			List<DockingClassifyVO> classList = mainData.getClassList();
			Map<String, List<DockingClassifyViewVO>> classInfoMap = mainData.getClassInfos();
			for (DockingClassifyVO jclassObject : classList) {
				String id =StringUtils.isBlank(jclassObject.getId())?"":jclassObject.getId();
				String className = StringUtils.isBlank(jclassObject.getClassName())?"":jclassObject.getClassName();
				String pid = StringUtils.isBlank(jclassObject.getPid())?"":jclassObject.getPid();
				String nodeLink = StringUtils.isBlank(jclassObject.getNodeLink())?"":jclassObject.getNodeLink();
				String nodeLinkName = StringUtils.isBlank(jclassObject.getNodeLinkName())?"":jclassObject.getNodeLinkName();
				String classNumber = StringUtils.isBlank(jclassObject.getClassNumber())?"":jclassObject.getClassNumber();
				//ClientBusinessObject classObject = objectOperation.readBusinessObjectById(id, "jclass");// 获取分类信息
			 	DockingPreClassify dockingPreClassify=dockingPreClassifyService.getById(id);
				log.info("classify:-------------->集团分类主机:"+id);
				log.info("classify:-------------->集团分类名称:"+className);
				log.info("classify:--------------> 集团分类父节点:"+pid);
				log.info("classify:-------------->链接:"+nodeLink);
				log.info("classify:-------------->链接名称:"+nodeLinkName);

				if (dockingPreClassify == null|| StringUtils.isBlank(dockingPreClassify.getOid())) {
					dockingPreClassify = new DockingPreClassify();
					DefaultAttrAssimtUtil.addDefaultAttrAssimt(dockingPreClassify, MdmBtmTypeConstant.DOCKING_PRE_JCLASSIFY);
				} else {
					DefaultAttrAssimtUtil.updateDefaultAttrAssimt(dockingPreClassify);
				}
				dockingPreClassify.setOid(id);
				dockingPreClassify.setName(className);
				dockingPreClassify.setPid(pid);
				dockingPreClassify.setId(classNumber);
				dockingPreClassify.setNodeLink(nodeLink);
				dockingPreClassify.setNodeLinkName(nodeLinkName);
				dockingPreClassify.setClassName(className);
				dockingPreClassifyArrayList.add(dockingPreClassify);
				// 获取对应的分类视图模型
				if (classInfoMap.containsKey(id)) {
					List<DockingClassifyViewVO> list = classInfoMap.get(id);
					getVilewMode(jclassObject, list);
				}
			}
			boolean res= dockingPreClassifyService.saveOrUpdateBatch(dockingPreClassifyArrayList);
			return res;
		} catch (Throwable e) {
			e.printStackTrace();
			throw new Throwable("存储视图模型出现问题");
		}
	}
	/***
	 * 获取分类视图
	 *
	 * @param jclassObject
	 * @throws Throwable
	 */
	private void getVilewMode(@NotNull DockingClassifyVO jclassObject, List<DockingClassifyViewVO> list)
		throws Throwable {
		String nodeLinkName = jclassObject.getNodeLinkName();
		try {
			String jclassId =StringUtils.isBlank(jclassObject.getId())?"":jclassObject.getId();
			Map<String, DockingPreViewModel> jviewmodelMap = new HashMap<String, DockingPreViewModel>();
			//Map<String, String> condtionMa = new HashMap<String, String>();
		//	condtionMa.put("jsourceclsfid", jclassId);
			List<DockingPreViewModel> dockingPreViewModelList= dockingPreViewModelService.list(Wrappers.<DockingPreViewModel>query().lambda().eq(DockingPreViewModel::getSourceClassifyId,false));// 根据分类查询模型视图对象
			for (DockingPreViewModel dockingPreViewModel : dockingPreViewModelList) {
				jviewmodelMap.put(dockingPreViewModel.getViewName(),dockingPreViewModel);
			}

			for (DockingClassifyViewVO viewInfo : list) {
				String viewName =StringUtils.isBlank(viewInfo.getViewName())?"":viewInfo.getViewName();
				String impactList = viewInfo.getImpactList() == null ? "" : viewInfo.getImpactList().get(0).get(0);
				log.info("VilewMode:-------------->视图名称:"+viewName);
				log.info("VilewMode:-------------->影响编码项:"+impactList);
				log.info("VilewMode:--------------> 集团分类主键:"+jclassId);
				List<DockingClassifyMetaAttrVO> metaList = viewInfo.getMetaList();
				DockingPreViewModel jviewModelObject = null;
				if (jviewmodelMap.containsKey(viewName)) {
					jviewModelObject = jviewmodelMap.get(viewName);
					//影响编码项的数据
					jviewModelObject.setImpactList(impactList);
					DefaultAttrAssimtUtil.updateDefaultAttrAssimt(jviewModelObject);
				} else {
					jviewModelObject =new DockingPreViewModel();
					DefaultAttrAssimtUtil.addDefaultAttrAssimt(jviewModelObject,MdmBtmTypeConstant.DOCKING_PRE_JVIEWMODEL);
					jviewModelObject.setSourceClassifyId(jclassId);// 集团分类id
					jviewModelObject.setViewName(viewName);// 集团视图名称
					//影响编码项的数据
					jviewModelObject.setImpactList(impactList);
					dockingPreViewModelList.add(jviewModelObject);
				}
				// 获取模型视图下的属性集
				// String oid = jviewModelObject.getOid();
				List<DockingPreMetaAttr>allDockingPreMetaAttrList=new ArrayList<>();
				getMetaAttrObject(metaList, jclassId, jviewModelObject, "root",allDockingPreMetaAttrList);
				//保存模型视图属性
				dockingPreMetaAttrService.saveOrUpdateBatch(allDockingPreMetaAttrList);
				//保存模型视图
				dockingPreViewModelService.saveOrUpdateBatch(dockingPreViewModelList);
			}
		} catch (Throwable e) {
			e.printStackTrace();
			throw new Throwable("组织分类" + nodeLinkName + "模型视图存储出现问题");
		}
	}


	/***
	 * 获取模型视图属性
	 * @throws Throwable
	 */
	private void getMetaAttrObject(List<DockingClassifyMetaAttrVO> metaList,
								   String jclassId, DockingPreViewModel jviewModelObject, String pid,List<DockingPreMetaAttr>allDockingPreMetaAttrList)throws Throwable {
		try {
			//// 根据分类查询模型视图对象
			List<DockingPreMetaAttr> dockingPreMetaAttrList = dockingPreMetaAttrService.selectByWrapper(Wrappers.<DockingPreMetaAttr>query().lambda()
				.eq(DockingPreMetaAttr::getSourceClassifyId,jclassId).eq(DockingPreMetaAttr::getViewModelId,jviewModelObject.getOid())
				.eq(DockingPreMetaAttr:: getPid,pid));
				Map<String,DockingPreMetaAttr> jmetaattrMap = dockingPreMetaAttrList.stream().filter(
				s -> StringUtils.isNotBlank(s.getEnglishName())).collect(Collectors.toMap(s -> s.getEnglishName().toLowerCase(Locale.ROOT), t -> t));

			for (DockingClassifyMetaAttrVO dockingClassifyMetaAttrVO : metaList) {
				String chineseName =StringUtils.isBlank(dockingClassifyMetaAttrVO.getChineseName())?"":dockingClassifyMetaAttrVO.getChineseName();// 属性名称
				String englishName = StringUtils.isBlank(dockingClassifyMetaAttrVO.getEnglishName())?"":dockingClassifyMetaAttrVO.getEnglishName();// 英文名称
				String defaultValue = StringUtils.isBlank(dockingClassifyMetaAttrVO.getDefaultValue())?"":dockingClassifyMetaAttrVO.getDefaultValue();
				Integer metadataType =dockingClassifyMetaAttrVO.getMetadataType();// 类型
				Integer necessaryConf = dockingClassifyMetaAttrVO.getNecessaryConf();// 是否必填
				Map<String, String> range = dockingClassifyMetaAttrVO.getRange()==null?new HashMap<String, String>():dockingClassifyMetaAttrVO.getRange();// 取值范围

				log.info("metaAttr:-------------->属性名称:"+chineseName);
				log.info("metaAttr:-------------->英文名称:"+englishName);
				log.info("metaAttr:-------------->默认值:"+defaultValue);
				log.info("metaAttr:--------------> 类型:"+metadataType);
				log.info("metaAttr:-------------->  是否必填:"+necessaryConf);
				DockingPreMetaAttr dockingPreMetaAttr = new DockingPreMetaAttr();
				if (jmetaattrMap.containsKey(englishName)) {
					dockingPreMetaAttr = jmetaattrMap.get(englishName);
					dockingPreMetaAttr.setChineseName(chineseName);
					dockingPreMetaAttr.setDefaultValue(defaultValue);
					DefaultAttrAssimtUtil.updateDefaultAttrAssimt(dockingPreMetaAttr);
				} else {
					DefaultAttrAssimtUtil.addDefaultAttrAssimt(dockingPreMetaAttr,MdmBtmTypeConstant.DOCKING_PRE_JMETAATRR);
					dockingPreMetaAttr.setSourceClassifyId(jclassId);// 集团分类id
					dockingPreMetaAttr.setViewModelId(jviewModelObject.getOid());// 集团视图模型id
					dockingPreMetaAttr.setChineseName(chineseName);// 属性名称
					dockingPreMetaAttr.setEnglishName(englishName);// 属性字段
					dockingPreMetaAttr.setDefaultValue(defaultValue);// 属性名称
					dockingPreMetaAttr.setMetaDataType(metadataType);// 属性类型
					dockingPreMetaAttr.setNecesSaryConf(necessaryConf);// 属性必填项
					dockingPreMetaAttr.setPid(pid);// 父节点id
				}
				if(range!=null&&range.size()>0){
					// 获取属性值域
					getRange(dockingPreMetaAttr, range);
				}
				/***
				 * 获取子节点
				 */
				DockingClassifyMetaAttrVO compositeMeta = dockingClassifyMetaAttrVO.getCompositeMeta();
				if (compositeMeta != null) {
					pid = StringUtils.isBlank(dockingPreMetaAttr.getOid())?"":dockingPreMetaAttr.getOid();// 当前oid
					List<DockingClassifyMetaAttrVO> childMetaList = new ArrayList<>();
					childMetaList.add(compositeMeta);
					getMetaAttrObject(childMetaList, jclassId,jviewModelObject, pid,allDockingPreMetaAttrList);
				}

			}

		} catch (Throwable e) {
			e.printStackTrace();
			log.error("组织模型视图"+ jviewModelObject.getViewName()
				+ "属性存储出现问题" + e);
			throw new Throwable("组织模型视图"+ jviewModelObject.getViewName()
				+ "属性存储出现问题" + e);
		}
	}

	/**
	 * @throws Throwable
	 *             * 获取值域
	 * @param metaAttrObject
	 * @param range
	 * @throws
	 */
	private void getRange(DockingPreMetaAttr metaAttrObject,Map<String, String> range) throws Throwable {
		String metaAttrOid =StringUtils.isBlank(metaAttrObject.getOid())?"":metaAttrObject.getOid();// 属性的oid
		String jchinesename = StringUtils.isBlank(metaAttrObject.getChineseName())?"":metaAttrObject.getChineseName();
		Map<String, DockingPreAttrRange> rangeMap = new HashMap<>();
		try {
			Map<String, String> condtionMa = new HashMap<String, String>();
			condtionMa.put("jmetalistid", metaAttrOid);
			List<DockingPreAttrRange> jmetaattrList = dockingPreAttrRangeService.selectByWrapper(Wrappers.<DockingPreAttrRange>query().lambda()
				.eq(DockingPreAttrRange::getMetaListId,metaAttrOid));// 根据分类查询模型视图对象
			rangeMap= jmetaattrList.stream().collect(Collectors.toMap(s -> StringUtils.isNotBlank(s.getNumText().toLowerCase(Locale.ROOT))?"":s.getNumText().toLowerCase(Locale.ROOT), t -> t));

			for (String rangeKey : range.keySet()) {
				DockingPreAttrRange rangeObject = new DockingPreAttrRange();
				String keyValue = StringUtils.isBlank(range.get(rangeKey))?"":range.get(rangeKey);
				log.info("range:-------------->显示值"+rangeKey+",内部值"+keyValue);
				if (rangeMap.containsKey(rangeKey)) {
					rangeObject = rangeMap.get(rangeKey);
					rangeObject.setNumTextValue(keyValue);
					rangeObject.setNumText(rangeKey);
					DefaultAttrAssimtUtil.updateDefaultAttrAssimt(rangeObject);
				} else {
					DefaultAttrAssimtUtil.addDefaultAttrAssimt(rangeObject,MdmBtmTypeConstant.DOCKING_PRE_JRANGE);
					rangeObject.setNumTextValue(keyValue);
					rangeObject.setNumText(rangeKey);
					rangeObject.setTs(rangeObject.getLastModifyTime());
					rangeObject.setMetaListId(metaAttrOid);
					log.info("range:-------------->属性内部值:"+metaAttrOid);
					log.info("range:-------------->时间:"+rangeObject.getLastModifyTime());
					jmetaattrList.add(rangeObject);
				}
			}
			dockingPreAttrRangeService.saveOrUpdateBatch(jmetaattrList);
		} catch (Throwable e) {
			e.printStackTrace();
			log.info("组织属性：【" + jchinesename + "】值域出现问题"+ e);
			throw new Throwable("组织属性：【" + jchinesename + "】值域出现问题"+ e);
		}
	}

}