package com.persagy.proxy.adm.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.persagy.dmp.basic.model.QueryCriteria;
import com.persagy.dmp.basic.utils.JsonNodeUtils;
import com.persagy.dmp.common.model.entity.BaseEntity;
import com.persagy.dmp.define.entity.ObjectTypeDefine;
import com.persagy.proxy.adm.model.*;
import com.persagy.proxy.adm.request.AdmQueryCriteria;
import com.persagy.proxy.adm.request.AdmResponse;
import com.persagy.proxy.adm.service.IAdmSpaceService;
import com.persagy.proxy.common.client.DmpRwdClient;
import com.persagy.proxy.common.entity.DmpResult;
import com.persagy.proxy.common.entity.InstanceUrlParam;
import com.persagy.proxy.common.entity.ObjRelationDTO;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.formula.functions.T;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * ADM 空间 实现类
 * @author lvxy
 * @date 2021/8/18
 */
@Slf4j
@Service
public class AdmSpaceServiceImpl extends AbstractAdmBaseServiceImpl<AdmSpace> implements IAdmSpaceService {
    @Autowired
    private DmpRwdClient rwdClient;
    @Autowired
    private ObjectMapper objectMapper;

    @Override
    public List<AdmSpace> doInsertExt(InstanceUrlParam context, Class<AdmSpace> clazz, List<AdmSpace> voList) {
        Map<String, AdmSpace> spaceIdMap = CollUtil.fieldValueMap(voList, BaseEntity.PROP_ID);
        //key spid, value floorId
        Map<String, String> spId2FlId_map = voList.stream().filter(admSpace -> StrUtil.isNotEmpty(admSpace.getFloorId())).collect(Collectors.toMap(AdmSpace::getId,AdmSpace::getFloorId));
        //查询空间中floorId 对应的flool
        DmpResult<JSONArray> floors = queryFloors(context, spId2FlId_map);
        ArrayList<AdmFloor> floorList = CollUtil.newArrayList(JSONUtil.toList(floors.getData().toString(),AdmFloor.class));
        //space.height = floor.infos.height
        List<AdmSpace> vos = processHeight(spaceIdMap, floorList, spId2FlId_map);
        //插入空间
        List<AdmSpace> vosR = doInsert(context, clazz, vos);
        //添加绑定关系
        DmpResult<List<ObjRelationDTO>> dmpResult = processRelations(context, vosR);
        //处理关系标记
        //TODO 处理关系标记
        //processRelationType();
        return doInsert(context, clazz, vosR);
    }

    @Override
    public List<AdmSpace> doUpdateExt(InstanceUrlParam context, Class<AdmSpace> clazz, List<AdmSpace> voList) {
        return null;
    }



    @Override
    public List<AdmSpace> doUpdateFloorORBuilding(InstanceUrlParam context, List<AdmUpDataFloorAndBuildingRequests> voList) {

            voList.stream().forEach(requestData -> {

            });

            //根据id查询对象集合
            //处理关系





        return null;
    }

    @Override
    public List<AdmSpace> doUpdateOutline(InstanceUrlParam context, Class<AdmSpace> clazz, List<AdmSpace> voList) {
        return null;
    }

    @Override
    public void doDeleteExt(InstanceUrlParam context, List<AdmSpace> voList) {

    }

    @Override
    public AdmResponse doQueryType(InstanceUrlParam context, AdmDCSQueryRequest request) {
        //查询定义类型
        ObjectNode criteriaEq = JsonNodeFactory.instance.objectNode();
        criteriaEq.put("parentCode", "space");
        DmpResult<JSONArray> resultDef = queryDefineType(context, criteriaEq);
        List<JSONObject> defineList = null;
        if(resultDef.getResult().equals(DmpResult.SUCCESS)){
            defineList = JSONUtil.toList(resultDef.getData().toString(), JSONObject.class);
            //获取实际空间对象的数量
            //根据classCode floorId 查询查询实际存在的空间
            assembleDefineTypes(context, defineList, request.getFloorId());
            // 设置返回值
            AdmResponse response = AdmResponse.success(defineList);
            Long total = resultDef.getCount() == null ? null : resultDef.getCount().longValue();
            response.setTotal(total);
            return response;
        }else{
            return null;
        }
    }

    @Override
    public AdmResponse doQuerySpaces(InstanceUrlParam context, AdmDCSQueryRequest request) {
        return null;
    }

    /**
     * 空间的类型是根据项目自定义的
     * 参见中心
     * @Select("SELECT s.object_type as type,d.name  FROM zone_space_base s
     * LEFT JOIN dict.dict_space_project d ON s.object_type = d.id WHERE s.project_id = #{projectId} AND d.project_id = #{projectId}
     * GROUP BY object_type, d.name")
     * @param context
     * @return
     */
    @Override
    public List<JSONObject> doQuerySpaceTypes(InstanceUrlParam context) {
        //根据项目id查询空间类型
        Map<String, String> codeNameMap = queryProjectDefineType(context);
        if(CollUtil.isNotEmpty(codeNameMap)){
            //查询object
            JSONArray demObjs = queryAndDealObjs(context, codeNameMap.keySet());
            if(CollUtil.isNotEmpty(demObjs)){
                List<AdmSpace> spaceList = JSONArray.parseArray(JSONUtil.toJsonStr(demObjs), AdmSpace.class);
                Set<String> classCodes = spaceList.stream().map(space -> space.getClassCode()).collect(Collectors.toSet());
                if(CollUtil.isNotEmpty(classCodes)){
                    codeNameMap.keySet().removeIf(code -> !classCodes.contains(code));
                }
            }
        }
        if(CollUtil.isNotEmpty(codeNameMap)){
            List<JSONObject> list = new ArrayList<>(codeNameMap.size());
            codeNameMap.keySet().stream().forEach(code ->{
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("name",codeNameMap.get(code));
                jsonObject.put("code",code);
                list.add(jsonObject);
            });
            return  list;
        }else{
            return null;
        }
    }

    private DmpResult<JSONArray> queryObj(InstanceUrlParam context, QueryCriteria criteriaObject){
        JSONObject paraPe = null;
        try {
            String paraStr = objectMapper.writeValueAsString(criteriaObject);
            paraPe = JSONObject.parseObject(paraStr);
        } catch (JsonProcessingException e) {
            throw new RuntimeException("转换查询条件出错：" + e.getMessage());
        }
        return rwdClient.queryObject(context, paraPe);
    }

    private JSONArray queryAndDealObjs(InstanceUrlParam context, Set<String> codes){
        QueryCriteria criteriaObject = new QueryCriteria();
        ObjectNode criteriaEq = JsonNodeFactory.instance.objectNode();
        ArrayNode array = criteriaEq.putObject("classCode").putArray("$in");
        codes.forEach(code -> array.add(code));
        criteriaEq.put("objType", "space");
        criteriaObject.setSize(1000L);
        criteriaObject.setPage(1L);
        criteriaObject.setCriteria(criteriaEq);

        DmpResult<JSONArray> dmpResult = queryObj(context, criteriaObject);
        if(CollUtil.isEmpty(dmpResult.getData())){
            return null;
        }
        JSONArray demObjs = dmpResult.getData();
        if(dmpResult.getCount() > criteriaObject.getSize()){
            for(int page = 2; page < dmpResult.getCount()/criteriaObject.getSize()+1; page++){
                criteriaObject.setPage(page*1L);
                demObjs.addAll(queryObj(context, criteriaObject).getData());
            }
        }
        return demObjs;
    }

    private Map<String, String> queryProjectDefineType(InstanceUrlParam context){
        Map<String, String> codeNameMap = null;
        ObjectNode criteriaEq = JsonNodeFactory.instance.objectNode();
        criteriaEq.put("projectId", context.getProjectId());
        criteriaEq.put("objType", "space");
        DmpResult<JSONArray> resultDef = queryDefineType(context, criteriaEq);
        if(resultDef.getResult().equals(DmpResult.SUCCESS) && CollUtil.isNotEmpty(resultDef.getData())){
            List<ObjectTypeDefine> defineList = JSONUtil.toList(resultDef.getData().toString(), ObjectTypeDefine.class);
            codeNameMap = defineList.stream().collect(Collectors.toMap(ObjectTypeDefine::getCode, ObjectTypeDefine::getName, (k1,k2)->k1));
        }
        return codeNameMap;
    }

    /**
     * 查询空间flooId对应的infos中height存在的 flool
     * @param context
     * @param spId2FlId_map
     * @return
     */
    private DmpResult<JSONArray> queryFloors(InstanceUrlParam context, Map<String, String> spId2FlId_map){
        QueryCriteria criteriaObject = new QueryCriteria();
        ObjectNode criteriaPe = JsonNodeFactory.instance.objectNode();
        ArrayNode array = criteriaPe.putObject("id").putArray("$in");
        spId2FlId_map.values().forEach(floorId -> array.add(floorId));
        criteriaPe.put("classCode", "floor");
        criteriaPe.put("objType", "floor");

        JSONObject height = new JSONObject();
        height.put("$gt", 0f);
        criteriaPe.putPOJO("height", height);

        criteriaObject.setCriteria(criteriaPe);
        criteriaObject.setSize(spId2FlId_map.size() * 1L);
        criteriaObject.setPage(1L);
        criteriaObject.setWithoutCount(true);
        // 转换参数
        JSONObject paraPe = null;
        try {
            String paraStr = objectMapper.writeValueAsString(criteriaObject);
            paraPe = JSONObject.parseObject(paraStr);
        } catch (JsonProcessingException e) {
            log.error(e.getMessage(), e);
            return null;
        }
        return rwdClient.queryObject(context, paraPe);
    }

    /**
     * space.height = floor.infos.height
     * @param spaceIdMap
     * @param floorList
     * @param spId2FlId_map
     * @return
     */
    private List<AdmSpace> processHeight(Map<String, AdmSpace> spaceIdMap, List<AdmFloor> floorList,  Map<String, String> spId2FlId_map){
        Map<String, String> newMap = spId2FlId_map.entrySet().stream().collect(Collectors.toMap(entry -> entry.getValue(), entry -> entry.getKey()));
        floorList.forEach(admFloor -> {
            if(CollUtil.isNotEmpty(admFloor.getInfos())){
                Float height = (Float) admFloor.getInfos().get("height");
                AdmSpace admSpace = spaceIdMap.get(newMap.get(admFloor.getId()));
                admSpace.setHeight(height);
            }
        });
        return (List<AdmSpace>) spaceIdMap.values();
    }

    /**
     * 添加绑定关系
     */
    private DmpResult<List<ObjRelationDTO>> processRelations(InstanceUrlParam context, List<AdmSpace> vosR){
        if(CollUtil.isNotEmpty(vosR)){
            JSONArray jsonArray = new JSONArray();
            vosR.forEach(admSpace -> {
                JSONObject requestData = new JSONObject();
                if (StrUtil.isNotEmpty(admSpace.getBuildingId())) {
                    addXParam("Bd2Sp", admSpace.getBuildingId(), admSpace.getId(), requestData);
                    addCommParam(context, requestData);
                    jsonArray.add(requestData);
                }
                if (StrUtil.isNotEmpty(admSpace.getFloorId())) {
                    addXParam("Fl2Sp", admSpace.getFloorId(), admSpace.getId(), requestData);
                    addCommParam(context, requestData);
                    jsonArray.add(requestData);
                }
            });
            DmpResult<List<ObjRelationDTO>> dmpResult = rwdClient.createObjRelations(context,jsonArray);
            return dmpResult;
        }else{
            return null;
        }
    }

    private JSONObject addXParam(String relCode, String masterObjType, String slaveObjType, JSONObject requestData){
        requestData.put("relCode", "Bd2Sp");
        requestData.put("masterObjType", masterObjType);
        requestData.put("slaveObjType", slaveObjType);
        return requestData;
    }

    private JSONObject addCommParam(InstanceUrlParam context, JSONObject requestData){
        requestData.put("sign", 1);
        requestData.put("graphCode", context.getGroupCode());
        requestData.put("projectId", context.getProjectId());
        return requestData;
    }

    /**
     * TODO 处理关系标记
     */
    private void processRelationType(InstanceUrlParam context, List<AdmSpace> vosR){
        String[] relationTypes = {"sp2sp_SpaceNeighborhood_5", "sp2sp_TrafficNetwork_1", "sp2sp_ConvectionNetwork_1", "sp2sp_RadiationNetwork_1"};
        List<String> listtype = Arrays.asList(relationTypes);
        JSONArray jsonArray = new JSONArray();
        listtype.forEach(type -> {
            JSONObject relationProjectCal = new JSONObject();
            addCommParam(context, relationProjectCal);
            //relationProjectCal.put("");

        });
        String relationType = "eq2sp_in";
        /**
         * val relationType = relationTypeProjectservice.select(SFilter.eq("projectId", projectId!!), SFilter.eq("relationType", "eq2sp_in"),SFilter.eq("zoneType", zoneSpace.classCode!!)).entity()
         *             if (relationType!=null){
         *                     relationType.computationalState = 2
         *                     relationTypeProjectservice.update(relationType)
         *             }
         */
    }

    /**
     * 清楚和空间关联的数据
     */
    private void deleteRelation(InstanceUrlParam context, String relCode, String ObjType){
    }


    /**
     * 转换为目标实体,并增加属性
     */
    private void assembleDefineTypes(InstanceUrlParam context, List<JSONObject> defineList, String floorId){
        boolean needCount = true;
        defineList.stream().forEach(defineType -> {
            //查询空间数量
            int count = needCount ? countSpace(context, defineType.getString("code"), floorId) : 0;
            //处理单个对象
            assembleDefineObj(defineType, count, context.getProjectId());
        });
    }

    /**
     * 单个转换为目标实体,并增加属性
     */
    private void assembleDefineObj(JSONObject defineType, int count, String projectId){
        defineType.put("count", count);
        defineType.put("projectId", projectId);
        defineType.remove("aliasName");
        defineType.remove("aliasCode");
        defineType.remove("valid");
        defineType.remove("objType");
        defineType.remove("groupCode");
        defineType.remove("parentCode");
        defineType.remove("id");
    }

    /**
     *  查询存在空间的数量
     * @param context
     * @param classCode
     * @param objFrom
     * @return
     */
    private int countSpace(InstanceUrlParam context, String classCode, String objFrom){
        QueryCriteria rwdQueryCriteria = new QueryCriteria();
        ObjectNode rwdCriteria = JsonNodeFactory.instance.objectNode();
        rwdCriteria.put("objType", "space");
        rwdCriteria.put("classCode", classCode);
        ObjectNode relationTO = JsonNodeFactory.instance.objectNode();
        relationTO.put("relCode", "Fl2Sp");
        if(StrUtil.isNotEmpty(objFrom)){
            relationTO.put("objFrom", objFrom);
        }
        rwdCriteria.putPOJO("relationTo", relationTO);
        rwdQueryCriteria.setCriteria(rwdCriteria);
        rwdQueryCriteria.setOnlyCount(true);
        // 转换参数
        JSONObject paraRel = null;
        try {
            String paraStr = objectMapper.writeValueAsString(rwdQueryCriteria);
            paraRel = JSONObject.parseObject(paraStr);
        } catch (JsonProcessingException e) {
            log.error(e.getMessage(), e);
        }
        return rwdClient.queryObject(context, paraRel).getCount();
    }


    private DmpResult<JSONArray> queryDefineType(InstanceUrlParam context, ObjectNode criteriaEq){
        QueryCriteria criteriaObject = new QueryCriteria();
        criteriaObject.setCriteria(criteriaEq);
        JSONObject paraPe = null;
        try {
            String paraStr = objectMapper.writeValueAsString(criteriaObject);
            paraPe = JSONObject.parseObject(paraStr);
        } catch (JsonProcessingException e) {
            throw new RuntimeException("查询公共定义的空间类型，转换查询条件出错：" + e.getMessage());
        }
        return rwdClient.queryDefClass(context, paraPe);
    }


}