package com.whdc.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Sets;
import com.whdc.exception.MyException;
import com.whdc.model.dto.ApiDto;
import com.whdc.model.dto.GroupWarningDto;
import com.whdc.model.vo.AdcdTree;
import com.whdc.model.vo.WarningData;
import com.whdc.model.vo.WarningHistoryListVo;
import com.whdc.model.vo.WarningListVo;
import com.whdc.service.IAddressBookService;
import com.whdc.service.IAdinfoService;
import com.whdc.utils.HttpUtil;
import com.whdc.utils.ResultJson;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.compress.utils.Lists;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpStatus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

/**
 * Description:
 * Created by XuSan on 2024/5/23.
 *
 * @author XuSan
 * @version 1.0
 */
@Slf4j
@Api(tags = "预警 - Controller")
@RestController
@RequestMapping("/warning")
public class WarningController {


    @Autowired
    private IAddressBookService addressBookService;

    @Autowired
    private IAdinfoService adinfoService;

    /**
     * 气象预警
     *
     * @param dto
     * @return
     */
    @ApiOperation(value = "气象预警")
    @PostMapping("/getGroupWarning")
    public ResultJson<List<WarningListVo>> getGroupWarning(
            @RequestBody GroupWarningDto dto) {

        ApiDto apiDto = new ApiDto();
        apiDto.setStartTime(dto.getStartTime());
        apiDto.setEndTime(dto.getEndTime());
        apiDto.setPageNumber(dto.getPageNumber());
        apiDto.setPageSize(dto.getPageSize());
        ArrayList<ApiDto.Filter> filter = Lists.newArrayList();

        String publishUnit = dto.getPublishUnit();
//        if (StringUtils.isNotBlank(publishUnit)) {
//            String[] split = publishUnit.split(",");
//            if (split.length > 1) {
//                String str = "(";
//                for (String s : split) {
//                    str += s + ",";
//                }
//                str = str.substring(0, str.length() - 1) + ")";
//                filter.add(new ApiDto.Filter("publishUnit", "in " + str, ""));
//
//            } else {
//                filter.add(new ApiDto.Filter("publishUnit", "like", String.format("%s%s%s", "%", publishUnit, "%")));
//            }
//        }
        String warnSignalLevel = dto.getWarnSignalLevel();
//        if (StringUtils.isNotBlank(warnSignalLevel)) {
//            String[] split = warnSignalLevel.split(",");
//            if (split.length > 1) {
//                String str = "(";
//                for (String s : split) {
//                    str += s + ",";
//                }
//                str = str.substring(0, str.length() - 1) + ")";
//                filter.add(new ApiDto.Filter("warnSignalLevel", "in " + str, ""));
//
//            } else {
//                filter.add(new ApiDto.Filter("warnSignalLevel", "like", String.format("%s%s%s", "%", warnSignalLevel, "%")));
//            }
//        }
        String warnSignalType = dto.getWarnSignalType();
//        if (StringUtils.isNotBlank(warnSignalType)) {
//            String[] split = warnSignalType.split(",");
//            if (split.length > 1) {
//                String str = "(";
//                for (String s : split) {
//                    str += s + ",";
//                }
//                str = str.substring(0, str.length() - 1) + ")";
//                filter.add(new ApiDto.Filter("warnSignalType", "in " + str, ""));
//
//            } else {
//                filter.add(new ApiDto.Filter("warnSignalType", "like", String.format("%s%s%s", "%", warnSignalType, "%")));
//            }
//        }

        apiDto.setFilter(filter);
//        String str = HttpUtil.sendPost("http://223.75.53.141:8000/shzh/met/zyqxfw/api/warning/getGroupWarning", JSON.toJSONString(apiDto));
        String str = HttpUtil.sendPost("http://127.0.0.1:20000/shzh/met/zyqxfw/api/warning/getGroupWarning", JSON.toJSONString(apiDto));
        JSONObject json = JSON.parseObject(str);
        if (json != null && json.getInteger("code") == HttpStatus.SC_OK) {
            List<WarningData> data = json.getJSONArray("data").toJavaList(WarningData.class);

            return ResultJson.ok(getList(data, publishUnit, warnSignalLevel, warnSignalType));
        }

        return ResultJson.ok(json);
    }

    /**
     * 历史气象预警统计
     *
     * @param dto
     * @return
     */
    @ApiOperation(value = "历史气象预警统计")
    @PostMapping("/getHistoryGroupWarning")
    public ResultJson<List<WarningHistoryListVo>> getHistoryGroupWarning(@RequestBody GroupWarningDto dto) {

        ApiDto apiDto = new ApiDto();
        apiDto.setStartTime(dto.getStartTime());
        apiDto.setEndTime(dto.getEndTime());
        apiDto.setPageNumber(dto.getPageNumber());
        apiDto.setPageSize(dto.getPageSize());
        ArrayList<ApiDto.Filter> filter = Lists.newArrayList();

        String publishUnit = dto.getPublishUnit();
//        if (StringUtils.isNotBlank(publishUnit)) {
//            String[] split = publishUnit.split(",");
//            if (split.length > 1) {
//                String str = "(";
//                for (String s : split) {
//                    str += s + ",";
//                }
//                str = str.substring(0, str.length() - 1) + ")";
//                filter.add(new ApiDto.Filter("publishUnit", "in " + str, ""));
//
//            } else {
//                filter.add(new ApiDto.Filter("publishUnit", "like", String.format("%s%s%s", "%", publishUnit, "%")));
//            }
//        }
        String warnSignalLevel = dto.getWarnSignalLevel();
//        if (StringUtils.isNotBlank(warnSignalLevel)) {
//            String[] split = warnSignalLevel.split(",");
//            if (split.length > 1) {
//                String str = "(";
//                for (String s : split) {
//                    str += s + ",";
//                }
//                str = str.substring(0, str.length() - 1) + ")";
//                filter.add(new ApiDto.Filter("warnSignalLevel", "in " + str, ""));
//
//            } else {
//                filter.add(new ApiDto.Filter("warnSignalLevel", "like", String.format("%s%s%s", "%", warnSignalLevel, "%")));
//            }
//        }
        String warnSignalType = dto.getWarnSignalType();
//        if (StringUtils.isNotBlank(warnSignalType)) {
//            String[] split = warnSignalType.split(",");
//            if (split.length > 1) {
//                String str = "(";
//                for (String s : split) {
//                    str += s + ",";
//                }
//                str = str.substring(0, str.length() - 1) + ")";
//                filter.add(new ApiDto.Filter("warnSignalType", "in " + str, ""));
//
//            } else {
//                filter.add(new ApiDto.Filter("warnSignalType", "like", String.format("%s%s%s", "%", warnSignalType, "%")));
//            }
//        }


        apiDto.setFilter(filter);
        String str = HttpUtil.sendPost("http://223.75.53.141:8000/shzh/met/zyqxfw/api/warning/getGroupWarning", JSON.toJSONString(apiDto));
//        String str = HttpUtil.sendPost("http://127.0.0.1:20000/shzh/met/zyqxfw/api/warning/getGroupWarning", JSON.toJSONString(apiDto));
        JSONObject json = JSON.parseObject(str);
        if (json != null && json.getInteger("code") == HttpStatus.SC_OK) {
            List<WarningData> data = json.getJSONArray("data").toJavaList(WarningData.class);
            return ResultJson.ok(getCount(data, publishUnit, warnSignalLevel, warnSignalType));
        }

        return ResultJson.ok(json);
    }

    /**
     * 正在生效预警
     *
     * @param data
     * @return
     */
    private List<WarningListVo> getList(List<WarningData> data,
                                        String reqPublishUnit,
                                        String reqWarnSignalLevel,
                                        String reqWarnSignalType) {

        List<WarningListVo> respList = Lists.newArrayList();
        for (WarningData datum : data) {
            for (WarningData.TypeList typeList : datum.getTypeList()) {
                // 预警类型
                String type = typeList.getType();
                List<WarningData.Warning> warnList = typeList.getWarnList();

                warnList = warnListFilter(warnList, reqPublishUnit, reqWarnSignalLevel, reqWarnSignalType);

                for (WarningData.Warning warning : warnList) {
                    WarningListVo vo = new WarningListVo();
                    String publishUnit = warning.getPublishUnit();
                    vo.setTitle(publishUnit + "发布" + type + "预警");
                    vo.setPublishTime(warning.getPublishTime());
                    vo.setContent(warning.getContent());
                    vo.setWarnSignalType(warning.getWarnSignalType());
                    vo.setWarnSignalLevel(warning.getWarnSignalLevel());
                    vo.setAdnm(publishUnit.replace("气象台", ""));
                    vo.setAddressBooks(addressBookService.getListByAdnm(publishUnit.replace("气象台", "")));
                    respList.add(vo);
                }
            }
        }


        return respList.stream().sorted(Comparator.comparing(WarningListVo::getPublishTime).reversed())
                .collect(Collectors.toList());
    }

    /**
     * 正在生效预警
     *
     * @return
     */
    private List<WarningData.Warning> warnListFilter(List<WarningData.Warning> warnList,
                                                     String publishUnit,
                                                     String warnSignalLevel,
                                                     String warnSignalType
    ) {
        if (StringUtils.isNotBlank(publishUnit)) {
            HashSet<String> set = Sets.newHashSet(publishUnit.split(","));
            if (CollectionUtils.isNotEmpty(set)) {
                warnList = warnList.stream()
                        .filter(w ->
                                set.contains(w.getPublishUnit().split("气象")[0])
                        ).collect(Collectors.toList());
            }
        }


        if (StringUtils.isNotBlank(warnSignalLevel)) {
            HashSet<String> set = Sets.newHashSet(warnSignalLevel.split(","));
            if (CollectionUtils.isNotEmpty(set)) {
                warnList = warnList.stream()
                        .filter(w ->
                                set.contains(w.getWarnSignalLevel())
                        ).collect(Collectors.toList());
            }
        }


        if (StringUtils.isNotBlank(warnSignalType)) {
            HashSet<String> set = Sets.newHashSet(warnSignalType.split(","));
            if (CollectionUtils.isNotEmpty(set)) {
                warnList = warnList.stream()
                        .filter(w ->
                                set.contains(w.getWarnSignalType())
                        ).collect(Collectors.toList());
            }
        }

        return warnList;
    }

    private List<WarningHistoryListVo> getCount(List<WarningData> data,
                                                String publishUnit,
                                                String warnSignalLevel,
                                                String reqWarnSignalType
    ) {

        List<WarningData.Warning> warnList = Lists.newArrayList();
        for (WarningData datum : data) {
            for (WarningData.TypeList typeList : datum.getTypeList()) {
                warnList.addAll(typeList.getWarnList());
            }
        }

        warnList = warnListFilter(warnList, publishUnit, warnSignalLevel, reqWarnSignalType);

        Map<String, List<WarningData.Warning>> warnMap = warnList.stream()
                .collect(Collectors
                        .groupingBy(WarningData.Warning::getPublishUnit, Collectors.toList()));


        List<WarningHistoryListVo> voList = Lists.newArrayList();

        warnMap.forEach((k, v) -> {
            WarningHistoryListVo vo = new WarningHistoryListVo();
            vo.setEffectArea(k.split("气象")[0]);
            vo.setWarnSignalType("暴雨");


//            List<WarningHistoryListVo> typeList = Lists.newArrayList();

            // 类型 只要暴雨
            Map<String, List<WarningData.Warning>> types = v.stream()
                    .filter(o -> "暴雨".equals(o.getWarnSignalType()))
                    .collect(Collectors
                            .groupingBy(WarningData.Warning::getWarnSignalType, Collectors.toList()));

//            Set<String> warnSignalType = Sets.newHashSet("雷电", "暴雨", "大风", "冰雹", "雷雨大风");
            types.forEach((kt, vt) -> {

//                WarningHistoryListVo voType = new WarningHistoryListVo();
//                voType.setWarnSignalType(kt);
//                warnSignalType.remove(kt);
                // 等级分组
                Map<String, Long> levels = vt.stream()
                        .collect(Collectors.groupingBy(WarningData.Warning::getWarnSignalLevel, Collectors.counting()));

                levels.forEach((k1, v1) -> {
                    switch (k1) {
                        case "红色":
//                            voType.setRedCount(v1.intValue());
                            vo.setRedCount(v1.intValue() + vo.getRedCount());
                            break;
                        case "橙色":
//                            voType.setOraCount(v1.intValue());
                            vo.setOraCount(v1.intValue() + vo.getOraCount());
                            break;
                        case "黄色":
//                            voType.setYelCount(v1.intValue());
                            vo.setYelCount(v1.intValue() + vo.getYelCount());
                            break;
                        case "蓝色":
//                            voType.setBluCount(v1.intValue());
                            vo.setBluCount(v1.intValue() + vo.getBluCount());
                            break;
                        default:
                            throw new MyException("当前预警等级不存在: " + k1);
                    }
                });
//                voType.setSumCount(vt.size());
//                typeList.add(voType);

            });

            // 保证完整数据
//            warnSignalType.forEach(kt -> {
//                WarningHistoryListVo voType = new WarningHistoryListVo();
//                voType.setWarnSignalType(kt);
//                typeList.add(voType);
//            });

//            vo.setChild(typeList);
            vo.setSumCount(vo.getRedCount() + vo.getOraCount() + vo .getYelCount() + vo.getBluCount());
            voList.add(vo);
        });


        // 进行行政区划匹配
        if (CollectionUtils.isNotEmpty(voList)) {
            List<AdcdTree> tree = adinfoService.tree(null, null);
            Map<String, List<WarningHistoryListVo>> areaMap = voList.stream()
                    .collect(Collectors
                            .groupingBy(WarningHistoryListVo::getEffectArea, Collectors.toList()));

            return setAll(getAdcdByWhlVo(tree, areaMap));
        }

        return setAll(voList);
    }

    private List<WarningHistoryListVo> setAll(List<WarningHistoryListVo> vos) {
        if (CollectionUtils.isNotEmpty(vos)) {
            WarningHistoryListVo vo = new WarningHistoryListVo();
            vo.setWarnSignalType("暴雨");
            vo.setEffectArea("总计");
            int oraSum = vos.stream().mapToInt(WarningHistoryListVo::getOraCount).sum();
            vo.setOraCount(oraSum);
            int redSum = vos.stream().mapToInt(WarningHistoryListVo::getRedCount).sum();
            vo.setRedCount(redSum);
            int bluSum = vos.stream().mapToInt(WarningHistoryListVo::getBluCount).sum();
            vo.setBluCount(bluSum);
            int yelSum = vos.stream().mapToInt(WarningHistoryListVo::getYelCount).sum();
            vo.setYelCount(yelSum);
            vo.setSumCount(oraSum + redSum + bluSum + yelSum);
            vos.add(0, vo);
        }
        return vos;
    }

    private List<WarningHistoryListVo> getAdcdByWhlVo(List<AdcdTree> tree, Map<String, List<WarningHistoryListVo>> areaMap) {
        List<WarningHistoryListVo> respList = Lists.newArrayList();

        for (AdcdTree adcdTree : tree) {
            String adnm = adcdTree.getAdnm();
            List<AdcdTree> children = adcdTree.getChildren();

            List<WarningHistoryListVo> vos = areaMap.remove(adnm);
            if (CollectionUtils.isNotEmpty(vos)) {
                WarningHistoryListVo vo = vos.get(0);
                List<WarningHistoryListVo> childList = Lists.newArrayList();

                if (CollectionUtils.isNotEmpty(children)) {
                    // 第一个是市级单位
                    for (int i = 1; i < children.size(); i++) {
                        AdcdTree t = children.get(i);
                        String adnm1 = t.getAdnm();
                        List<WarningHistoryListVo> vos1 = areaMap.remove(adnm1);
                        if (CollectionUtils.isNotEmpty(vos1)) {
                            childList.addAll(vos1);
                        }
                    }
                }


                vo.setAreaChild(childList);
                respList.add(vo);
            }

        }

        return respList;
    }
}