package ieven.server.webapp.service.datastatic;

import com.google.common.collect.Lists;
import ieven.server.webapp.domain.data.DataMap;
import ieven.server.webapp.domain.data.StaticInput;
import ieven.server.webapp.domain.data.StaticModelInput;
import ieven.server.webapp.infrastructure.wrapper.Mapped;
import ieven.server.webapp.service.FieldsService;
import ieven.server.webapp.service.Ops;
import ieven.server.webapp.util.SplitCharacterEnum;
import ieven.server.webapp.util.excel.PublicStatic;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.*;
import java.util.regex.Pattern;

@Slf4j
@Service
public class DataStaticService extends Ops {
    @Autowired
    FieldsService fieldsService;
    @Autowired
    private MongoTemplate mongoTemplate;

    public Mapped update(StaticInput staticInput) {
        //获取需要修改的数据
        DataMap dataMap = this.mongoTemplate.findById(staticInput.getLineId(), DataMap.class);
        if (dataMap == null) {
            return Mapped.ERROR("当前数据不存在");
        }
        if (StringUtils.isBlank(String.valueOf(dataMap.get("交易主体账号"))) || "null".equals(String.valueOf(dataMap.get("交易主体账号")))) {
            return Mapped.ERROR("交易主体账号有误");
        }

        //修改汇总表中的数据
        Query query = new Query();
        query.addCriteria(Criteria.where("_id").is(staticInput.getLineId()));
        Update update = new Update();
        if (StringUtils.isNotBlank(staticInput.getJyzthm())) {
            update.set("交易主体户名", PublicStatic.specialFormatStr(staticInput.getJyzthm()));
        }

        if (StringUtils.isNotBlank(staticInput.getZjhm())) {
            update.set("证件号码", PublicStatic.specialFormatStr(staticInput.getZjhm()));
        }

        if (StringUtils.isNotBlank(staticInput.getJyzthm()) || StringUtils.isNotBlank(staticInput.getZjhm())) {
            mongoTemplate.updateFirst(query, update, DataMap.class);
        }

        //修改明细表的交易主体户名
        if (StringUtils.isNotBlank(staticInput.getJyzthm())) {
            String modelId = staticInput.getModelId();
            List<String> fileIds = new ArrayList<>();
            String jyztzh = String.valueOf(dataMap.get("交易主体账号"));
            String dateFileId = getFileId("数据分析-主体信息汇总明细", modelId, mongoTemplate);
            if (StringUtils.isNotBlank(dateFileId)) {
                fileIds.add(dateFileId);
            }

            //五联单
            String dateFileIdwld = getFileId("五联单-账户明细", modelId, mongoTemplate);
            if (StringUtils.isNotBlank(dateFileIdwld)) {
                fileIds.add(dateFileIdwld);
            }

            //财付通
            String dateFileIdcft = getFileId("财付通-交易明细", modelId, mongoTemplate);
            if (StringUtils.isNotBlank(dateFileIdcft)) {
                fileIds.add(dateFileIdcft);
            }
            //反诈
            String dateFileIdfzza = getFileId("反诈治安-交易明细", modelId, mongoTemplate);
            if (StringUtils.isNotBlank(dateFileIdfzza)) {
                fileIds.add(dateFileIdfzza);
            }

            if (CollectionUtils.isNotEmpty(fileIds)) {
                Query queryjyzthm = new Query();
                queryjyzthm.addCriteria(Criteria.where("fileId").in(fileIds).and("交易主体账号").is(jyztzh));
                Update updatejy = new Update();
                updatejy.set("交易主体户名", PublicStatic.specialFormatStr(staticInput.getJyzthm()));
                mongoTemplate.updateMulti(queryjyzthm, updatejy, DataMap.class);
            }
        }
        return Mapped.OK();
    }

    public Mapped staticModel(StaticModelInput staticModelInput) {
        String modelId = staticModelInput.getModelId();
        String dateFileId = getFileId("数据分析-主体信息汇总明细", modelId, mongoTemplate);
        String dateFileIdUser = getFileId("数据分析-所有主体信息汇总", modelId, mongoTemplate);
        if (StringUtils.isBlank(dateFileId)) {
            return Mapped.ERROR("数据分析-主体信息汇总明细不存在");
        }

        if (StringUtils.isBlank(dateFileIdUser)) {
            return Mapped.ERROR("数据分析-所有主体信息汇总");
        }

        //查询所有的主体信息汇总
        List<DataMap> dataMaps = this.mongoTemplate.find((new Query(
                Criteria.where("fileId")
                        .is(dateFileIdUser))), DataMap.class);
        Map<String, List<DataMap>> personMap = new HashMap<>();
        Map<String, List<DataMap>> personzhmcMap = new HashMap<>();
        for (DataMap dataMap : dataMaps) {
            String zh = String.valueOf(dataMap.get("账号"));
            String zhmc = String.valueOf(dataMap.get("账户名称"));
            String key1=zh+"-"+zhmc;
            String key=zhmc+"-"+zh;
            if (zh.equals("w12124268") || zhmc.equals("w12124268")) {
                System.out.println("555");
            }
            List<DataMap> dataMaps1 = personMap.get(key1);
            List<DataMap> dataMapshmc = personzhmcMap.get(key);
            if (CollectionUtils.isEmpty(dataMaps1)) {
                personMap.put(key1, Lists.newArrayList(dataMap));
            } else {
                dataMaps1.add(dataMap);
                personMap.put(key1, dataMaps1);
            }

            if (CollectionUtils.isEmpty(dataMapshmc)) {
                personzhmcMap.put(key, Lists.newArrayList(dataMap));
            } else {
                dataMapshmc.add(dataMap);
                personzhmcMap.put(key, dataMapshmc);
            }
        }

        //分两种情况,1:主体是否有数据如果有就按交易主体的计算

        Query query = new Query();
        //Pattern compile = Pattern.compile("^((?!" + "张"+ ").)*$",Pattern.CASE_INSENSITIVE);
        query.addCriteria(Criteria.where("fileId").is(dateFileId));
        query.addCriteria(new Criteria().andOperator(getQuery()));
        if (StringUtils.isNotBlank(staticModelInput.getJyztzh())) {
            query.addCriteria(Criteria.where("交易主体账号").in(Objects.requireNonNull(SplitCharacterEnum.splitByCharacter(staticModelInput.getJyztzh()))));
        }
        if (StringUtils.isNotBlank(staticModelInput.getJyzthm())) {
            query.addCriteria(Criteria.where("交易主体户名").in(Objects.requireNonNull(SplitCharacterEnum.splitByCharacter(staticModelInput.getJyzthm()))));
        }
        if (StringUtils.isNotBlank(staticModelInput.getJyztzhds())) {
            query.addCriteria(Criteria.where("交易对手账号").in(Objects.requireNonNull(SplitCharacterEnum.splitByCharacter(staticModelInput.getJyztzhds()))));
        }
        if (StringUtils.isNotBlank(staticModelInput.getJyzthmds())) {
            query.addCriteria(Criteria.where("交易对手户名").in(Objects.requireNonNull(SplitCharacterEnum.splitByCharacter(staticModelInput.getJyzthmds()))));
        }

        if (StringUtils.isNotBlank(staticModelInput.getJysjStart()) && StringUtils.isBlank(staticModelInput.getJysjEnd())) {
            query.addCriteria(Criteria.where("交易时间").gte(staticModelInput.getJysjStart()));
        }
        if (StringUtils.isNotBlank(staticModelInput.getJysjEnd()) && StringUtils.isBlank(staticModelInput.getJysjStart())) {
            query.addCriteria(Criteria.where("交易时间").lte(staticModelInput.getJysjEnd()));
        }
        if (StringUtils.isNotBlank(staticModelInput.getJysjEnd()) && StringUtils.isNotBlank(staticModelInput.getJysjStart())) {
            query.addCriteria(Criteria.where("交易时间").gte(staticModelInput.getJysjStart()).lte(staticModelInput.getJysjEnd()));
        }

        Map<String, Object> dataMap = new HashMap<>();

        List<Map<String, Object>> partyDataList = new ArrayList<>();
        List<Map<String, Object>> relationshipGraphList = new ArrayList<>();
        List<Map<String, Object>> relationshipGraphListnew = new ArrayList<>();
        List<DataMap> dataMapDetail = this.mongoTemplate.find(query, DataMap.class);
        //先去判断从是否有大于2的数据

        Map<String,List<DataMap>>dsMap=new HashMap<>();

        Map<String,Set<String>>zh=new HashMap<>();
        for (DataMap map : dataMapDetail) {
            String jydszh = String.valueOf(map.get("交易对手账号"));
            String jydshm = String.valueOf(map.get("交易对手户名"));
            String jyds = String.valueOf(map.get("交易主体账号"));
            String jyhm = String.valueOf(map.get("交易主体户名"));
            if (jydszh.equals("w12124268") || jyds.equals("w12124268")) {
                System.out.println("555");
            }
            if (PublicStatic.checkStr(jydszh)) {
                continue;
            }
            String key=jydszh+"-"+jydshm;
            List<DataMap> dataMaps1 = dsMap.get(key);
            if(CollectionUtils.isEmpty(dataMaps1)){
                dsMap.put(key,Lists.newArrayList(map));
            }else {
                dataMaps1.add(map);
                dsMap.put(key,dataMaps1);
            }

            //存储主体账号
            Set<String> strings = zh.get(key);
            if(CollectionUtils.isEmpty(strings)){
                Set<String> objects = new HashSet<>();
                objects.add(jyds);
                zh.put(key,objects);
            }else {
                strings.add(jyds);
                zh.put(key,strings);
            }
        }
        if(dsMap==null){
            return Mapped.ERROR("数据有误,请重新查询");
        }
        List<DataMap>newList=Lists.newArrayList();
        for (Map.Entry<String,Set<String>> entry : zh.entrySet()) {
           if(entry.getValue().size()>1){
               if (entry.getKey().equals("w12124268") || entry.getKey().equals("w12124268")) {
                   System.out.println("555");
               }
               List<DataMap> dataMaps1 = dsMap.get(entry.getKey());
               newList.addAll(dataMaps1);
           }
        }

        List<String> userList = new ArrayList<>();
        List<String> usermcList = new ArrayList<>();
        List<String> userAllList = new ArrayList<>();
        for (DataMap map : newList) {
            String jythm = String.valueOf(map.get("交易主体户名"));
            String jythmds = String.valueOf(map.get("交易对手户名"));
            String jydszh = String.valueOf(map.get("交易对手账号"));
            String jyzh = String.valueOf(map.get("交易主体账号"));
            if (StringUtils.isBlank(jythm) || "null".equals(jythm)) {
                continue;
            }
            String jdlx = String.valueOf(map.get("借贷类型"));
            if (!jdlx.equals("借") && !jdlx.equals("贷")) {
                continue;
            }

            String key=jythm+"-"+jyzh;
            String key1=jydszh+"-"+jythmds;
            //获取节点名称
            List<DataMap> dataMapsparty1 = personzhmcMap.get(key);
            List<DataMap> dataMapsparty2 = personMap.get(key1);
            if(CollectionUtils.isEmpty(dataMapsparty1)||CollectionUtils.isEmpty(dataMapsparty2)){
                continue;
            }
            if (!userList.contains(key)) {
                Map<String, Object> userMap = new HashMap<>();
                if (CollectionUtils.isNotEmpty(dataMapsparty1)) {
                    userMap.put("id", String.valueOf(dataMapsparty1.get(0).get("_id")));
                    userMap.put("name", dataMapsparty1.get(0).get("账户名称"));
                    userMap.put("relationPersons", dataMapsparty1);
                    userMap.put("type", "主");
                    partyDataList.add(userMap);
                    userList.add(key);
                }
            }

            if (!usermcList.contains(key1)) {
                Map<String, Object> userMap = new HashMap<>();
                if (CollectionUtils.isNotEmpty(dataMapsparty2)) {
                    String cid = String.valueOf(dataMapsparty2.get(0).get("_id"));
                    userMap.put("id", cid);
                    userMap.put("name", dataMapsparty2.get(0).get("账号"));
                    userMap.put("relationPersons", dataMapsparty2);
                    userMap.put("type", "从");
                    partyDataList.add(userMap);
                    usermcList.add(key1);
                }
            }
            //增加线上数据
            Map<String, Object> total = new HashMap<>();
            Map<String, Object> party1 = new HashMap<>();
            Map<String, Object> party2 = new HashMap<>();
            Map<String, Object> relationData = new HashMap<>();

            String userAllId = "";
            if (jdlx.equals("借")) {
                List<DataMap> dataMaps1 = personzhmcMap.get(key);
                List<DataMap> dataMaps2 = personMap.get(key1);
                if (CollectionUtils.isNotEmpty(dataMaps1) && CollectionUtils.isNotEmpty(dataMaps2)) {
                    String one = String.valueOf(dataMaps1.get(0).get("_id"));
                    party1.put("id", one);
                    party1.put("name", dataMaps1.get(0).get("账户名称"));

                    String two = String.valueOf(dataMaps2.get(0).get("_id"));
                    party2.put("id", two);
                    party2.put("name", dataMaps2.get(0).get("账号"));
                    userAllId = one + "-" + two;
                }

            }
            else if (jdlx.equals("贷")) {
                List<DataMap> dataMaps1 = personzhmcMap.get(key);
                List<DataMap> dataMaps2 = personMap.get(key1);
                if (CollectionUtils.isNotEmpty(dataMaps1) && CollectionUtils.isNotEmpty(dataMaps2)) {
                    String two = String.valueOf(dataMaps1.get(0).get("_id"));
                    party2.put("id", String.valueOf(dataMaps1.get(0).get("_id")));
                    party2.put("name", dataMaps1.get(0).get("账户名称"));

                    String one = String.valueOf(dataMaps2.get(0).get("_id"));
                    party1.put("id", String.valueOf(dataMaps2.get(0).get("_id")));
                    party1.put("name", dataMaps2.get(0).get("账号"));
                    userAllId = one + "-" + two;
                }
            }
            if (!userAllList.contains(userAllId)) {
                //查询所有的数据
                //查询所有的主体信息汇总
                BigDecimal sum = BigDecimal.ZERO;
                List<DataMap> dataDetailList = this.mongoTemplate.find((new Query(
                        Criteria.where("fileId")
                                .is(dateFileId)
                                .and("交易主体户名")
                                .is(jythm)
                                .and("交易对手账号")
                                .is(jydszh))), DataMap.class);
                for (DataMap dataMap1 : dataDetailList) {
                    String jyje = String.valueOf(dataMap1.get("交易金额"));
                    sum = sum.add(new BigDecimal(jyje));
                }
                relationData.put("modelId", modelId);
                relationData.put("fileId", dateFileId);
                relationData.put("jythm", jythm);
                relationData.put("jydszh", jydszh);
                relationData.put("jeTotal", sum);
                relationData.put("sum", dataDetailList.size());
                total.put("party1", party1);
                total.put("party2", party2);
                total.put("relationData", relationData);
                total.put("userAllId", userAllId);
                //total.put("relationships", dataDetailList);
                relationshipGraphList.add(total);
                userAllList.add(userAllId);
                if (partyDataList.size() > 300) {
                    return Mapped.ERROR("节点超过300个,请重新查询");
                }
            }
        }
        for (Map<String, Object> stringObjectMap : relationshipGraphList) {
            Map<String, Object> party1 = (Map) stringObjectMap.get("party1");
            Map<String, Object> party2 = (Map) stringObjectMap.get("party2");
            String name1 = String.valueOf(party1.get("name"));
            String name2 = String.valueOf(party2.get("name"));
            String value1 = name2 + "-" + name1;
            stringObjectMap.put("type", 1);
            for (Map<String, Object> objectMap : relationshipGraphList) {
                Map<String, Object> party11 = (Map) objectMap.get("party1");
                Map<String, Object> party21 = (Map) objectMap.get("party2");
                String name11 = String.valueOf(party11.get("name"));
                String name21 = String.valueOf(party21.get("name"));
                String value11 = name11 + "-" + name21;
                if (value1.equals(value11)) {
                    stringObjectMap.put("type", 2);
                    continue;
                }
            }
            relationshipGraphListnew.add(stringObjectMap);

        }

        dataMap.put("partyData", partyDataList);
        dataMap.put("relationshipGraph", relationshipGraphListnew);
        Mapped mapped = Mapped.OK();
        mapped.put("result", dataMap);
        return mapped;
    }

    public List<Criteria> getQuery() {
        List<Criteria> dataList = new ArrayList<>();
        List<String> filedsList = Lists.newArrayList("交易对手账号", "交易对手户名");
        List<String> noQueryData = Lists.newArrayList(
                "公司", "慈善", "红十字", "店", "工作室", "商行", "中心", "经营部", "水果行", "餐厅", "超市", "市场", "商贸", "西饼屋", "科技", "酒楼", "停车场", "ETC", "etc", "服务", "批发",
                "渔场", "浴场", "设计", "物业", "咨询", "批发", "合作社", "工厂", "鞋厂", "动物园", "植物园", "土黑猪", "猫狗", "学校", "学院", "大学", "棋牌", "娱乐", "袜厂", "制品厂", "加油站",
                "体育馆", "研究所", "保健院", "龙虾", "羊蝎子", "足道", "公安局", "税务局", "法院", "菜馆", "棋牌", "水产行", "海鲜行", "公司", "服饰", "服装", "基金", "宠物", "车行", "保险", "理财",
                "支付宝", "财付通", "apple", "烟酒", "经营者", "商户"
        );
        for (String s : filedsList) {
            for (String noQueryDatum : noQueryData) {
                Criteria newCri = new Criteria(s);
                Pattern compile = Pattern.compile("^((?!" + noQueryDatum + ").)*$", Pattern.CASE_INSENSITIVE);
                newCri.regex(compile);
                dataList.add(newCri);
            }
        }
        return dataList;
    }
}