package com.ld.igds.es.manager;

import com.ld.igds.common.CoreCommonService;
import com.ld.igds.common.CoreSerService;
import com.ld.igds.constant.BizType;
import com.ld.igds.constant.Constant;
import com.ld.igds.constant.RespCodeEnum;
import com.ld.igds.data.ChartLine;
import com.ld.igds.data.PageResponse;
import com.ld.igds.es.dto.EsData;
import com.ld.igds.es.dto.EsParam;
import com.ld.igds.es.dto.EsSummary;
import com.ld.igds.es.service.CoreEsService;
import com.ld.igds.io.EsRemoteManager;
import com.ld.igds.io.RemoteEsService;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.request.BaseRequest;
import com.ld.igds.io.response.BaseResponse;
import com.ld.igds.models.Depot;
import com.ld.igds.models.DepotConf;
import com.ld.igds.models.DeviceSer;
import com.ld.igds.order.ExeOrderService;
import com.ld.igds.order.data.ExeRequest;
import com.ld.igds.util.ContextUtil;
import com.ld.igds.util.DateUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.*;

/**
 * 能耗管理
 *
 * @author: andy.jia
 * @description:
 * @version:
 * @data:2020年2月17日
 */
@Slf4j
@Component
public class EsManager {

    @Autowired
    private CoreEsService coreEsService;
    @Autowired
    private CoreCommonService commonService;
    @Autowired
    private CoreSerService coreSerService;
    @Autowired
    private EsRemoteManager remoteManager;
    @Autowired
    private ExeOrderService exeOrderService;

    public PageResponse<Map<String, Object>> querySummaryData(EsParam param) {

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

        if (null == param.getCompanyId()) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        // 第一步，根据参数获取每个仓库的统计信息，用于页面的柱状图，同时用来汇总
        List<EsSummary> list = coreEsService.getSummaryGroupByDepot(param);
        if (null == list || list.isEmpty()) {
            log.debug("---------没有获取到数据信息-------");
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "根据条件获取数据为空");
        }

        // 第二步，根据列表获取总数据信息
        EsSummary sum = new EsSummary();
        Depot depot;
        for (EsSummary esSummary : list) {
            sum.setEpSum(sum.getEpSum() + esSummary.getEpSum());
            sum.setEqSum(sum.getEqSum() + esSummary.getEqSum());
            sum.setEsSum(sum.getEsSum() + esSummary.getEsSum());
            depot = commonService.getCacheDepot(param.getCompanyId(), esSummary.getGroupTag());
            // 获取仓库名称
            if (null != depot) {
                esSummary.setDepotName(depot.getName());
            } else {
                esSummary.setDepotName(esSummary.getGroupTag());
            }
        }
        sum.setEsCur(sum.getEsSum());

        // 固定获取上个月的能耗统计
        Date date = param.getCheckDate();
        Date start = DateUtil.getPreMonthFirst(date);
        Date end = DateUtil.getMonthFirst(date);
        param.setStart(start);
        param.setEnd(end);

        EsSummary esSummary = coreEsService.getSummaryByParam(param);
        sum.setEsMom(esSummary.getEsSum());

        // 固定获取去年本月的能耗信息
        start = DateUtils.addYears(start, -1);
        start = DateUtils.addMonths(start, 1);
        end = DateUtils.addYears(end, -1);
        end = DateUtils.addMonths(end, 1);
        param.setStart(start);
        param.setEnd(end);
        esSummary = coreEsService.getSummaryByParam(param);
        sum.setEsYoy(esSummary.getEsSum());

        result.put("esSum", sum);
        result.put("esSumList", list);

        return new PageResponse<Map<String, Object>>(RespCodeEnum.CODE_0000, result);
    }

    public PageResponse<Map<String, Object>> queryDetailData(EsParam param) {

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

        if (null == param.getCompanyId()) {
            param.setCompanyId(ContextUtil.getDefaultCompanyId());
        }

        if (null == param.getDepotId()) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "没有获取到需要查询的仓库信息");
        }

        // 第一步，根据参数获取满足条件内的数据信息
        List<EsData> list = coreEsService.listDetailChartData(param);

        if (null == list || list.isEmpty()) {
            log.debug("---------没有获取到数据信息-------");
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "根据条件获取数据为空");
        }

        // 第二步，根据列表获取总数据信息
        EsSummary sum = new EsSummary();
        for (EsData esData : list) {
            sum.setEpSum(sum.getEpSum() + esData.getEp());
            sum.setEqSum(sum.getEqSum() + esData.getEq());
            sum.setEsSum(sum.getEsSum() + esData.getEs());
        }
        sum.setEsCur(sum.getEsSum());

        // 固定获取上个月的能耗统计
        Date date = param.getCheckDate();
        Date start = DateUtil.getPreMonthFirst(date);
        Date end = DateUtil.getMonthFirst(date);
        param.setStart(start);
        param.setEnd(end);

        EsSummary esSummary = coreEsService.getSummaryByParam(param);
        sum.setEsMom(esSummary.getEsSum());

        // 固定获取去年本月的能耗信息
        start = DateUtils.addYears(start, -1);
        start = DateUtils.addMonths(start, 1);
        end = DateUtils.addYears(end, -1);
        end = DateUtils.addMonths(end, 1);
        param.setStart(start);
        param.setEnd(end);
        esSummary = coreEsService.getSummaryByParam(param);
        sum.setEsYoy(esSummary.getEsSum());

        // 第三步，缓存获取当前实时能耗信息
        EsData esCur = coreEsService.getCacheEsData(param.getCompanyId(), param.getDepotId());

        result.put("esCur", esCur);
        result.put("esSum", sum);
        result.put("esSumList", list);
        return new PageResponse<Map<String, Object>>(RespCodeEnum.CODE_0000, result);
    }

    /**
     * 大屏页面主动获取能耗统计信息，并更新缓存，推送到大屏，默认15天走势
     *
     * @param companyId
     * @return
     */
    public ChartLine queryScreenEsChart(String companyId) {

        EsParam esParam = new EsParam();
        esParam.setCompanyId(companyId);
        esParam.setStart(DateUtil.getNewByDay(new Date(), -15));

        return coreEsService.queryScreenEsChart(esParam, true);
    }

    /**
     * 根据配置信息获取能耗
     *
     * @param depotConf
     * @return
     */
    public BaseResponse checkEsByConf(DepotConf depotConf) {
        DeviceSer deviceSer = coreSerService.getCacheSer(depotConf.getCompanyId(), depotConf.getEsSer());

        if (null == deviceSer) {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "执行失败：没有配置能耗分机");
        }
        if (null == deviceSer.getProtocol()) {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "执行失败：没有配置通讯协议。");
        }

//        if (Constant.YN_N.equals(deviceSer.getStatus())) {
//            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
//                    "执行失败：能耗分机不在线。");
//        }

        RemoteEsService remoteEsService = remoteManager.getRemoteEsService(deviceSer.getProtocol());

        if (null == remoteEsService) {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "执行失败：能耗分机配置协议未实现。");
        }

        BaseRequest request = new BaseRequest();
        request.setSerId(deviceSer.getId());
        request.setPort(deviceSer.getPort());
        request.setIp(deviceSer.getIp());
        request.setCompanyId(deviceSer.getCompanyId());
        request.setBizType(BizType.ES.getCode());
        request.setSerName(deviceSer.getName());
        request.setDepotId(depotConf.getDepotId());
        request.setDepotName(depotConf.getDepotName());
        ExeRequest exeRequest = new ExeRequest(request);
        exeOrderService.checkExecute(exeRequest);
        BaseResponse response = remoteEsService.checkEs(request);
        exeOrderService.addCache(exeRequest);
        return response;
    }

    public PageResponse<List<EsData>> queryCurEsData() {

        Map<String, EsData> result = coreEsService.getCacheEsDataMap(ContextUtil.getCompanyId());

        if (null == result || result.isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "没有获取到实时信息");
        }
        //获取有能耗配置的仓库列表
        List<Depot> listDepot = this.listEsDepot(null);
        if (null == listDepot || listDepot.isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "没有获取到实时信息");
        }
        List<EsData> list = new ArrayList<>();
        EsData dto;
        //标记仓库是否有电表数据
        boolean flag;
        for (Depot depot : listDepot) {
            flag = true;
            for (String key : result.keySet()) {
                if(key.startsWith(depot.getId())){
                    dto =  result.get(key);
                    dto.setDepotName(depot.getName());
                    if(StringUtils.isNotEmpty(dto.getDeviceName())){
                        dto.setDepotName(depot.getName() + " - " + dto.getDeviceName());
                    }
                    dto.setDepotId(key);
                    list.add(dto);
                    flag = false;
                }
            }
            if (flag){
                //标识没有当前仓库的电表数据，加入当前电表
                dto = new EsData();
                dto.setDepotName(depot.getName());
                dto.setDepotId(depot.getId());
                dto.setUa(0.0);
                dto.setUb(0.0);
                dto.setUc(0.0);
                dto.setIa(0.0);
                dto.setIb(0.0);
                dto.setIc(0.0);
                dto.setEsInc(0.0);
                dto.setUpdateTime(new Date());
            }
        }
        return new PageResponse<List<EsData>>(RespCodeEnum.CODE_0000, list);
    }

    /**
     * 获取配置能耗分机的仓库列表
     *
     * @param deptId
     * @return
     */
    public List<Depot> listEsDepot(String deptId) {

        if (StringUtils.isEmpty(deptId)) {
            deptId = ContextUtil.subDeptId(null);
        }

        String companyId = ContextUtil.getCompanyId();
        List<Depot> list = commonService.getCacheDepotList(companyId, deptId);

        if (null == list || list.isEmpty()) {
            return list;
        }
        List<Depot> result = new ArrayList<>();
        DepotConf depotConf;
        for (Depot depot : list) {
            depotConf = commonService.getCacheDepotConf(companyId, depot.getId());
            if (null == depotConf) {
                continue;
            }
            if (StringUtils.isNotEmpty(depotConf.getEsSer())) {
                result.add(depot);
            }
        }

        return result;
    }
}