package com.iailab.module.ansteel.api.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.iailab.framework.common.util.date.DateUtils;
import com.iailab.framework.common.util.object.ConvertUtils;
import com.iailab.module.ansteel.api.dao.PowerRunStateDao;
import com.iailab.module.ansteel.api.dto.*;
import com.iailab.module.ansteel.api.service.DataApi;
import com.iailab.module.ansteel.common.constant.CommonConstant;
import com.iailab.module.data.api.plan.PlanItemApi;
import com.iailab.module.data.api.plan.dto.ApiPlanDataDTO;
import com.iailab.module.data.api.point.DataPointApi;
import com.iailab.module.data.api.point.dto.ApiPointValueQueryDTO;
import com.iailab.module.data.common.ApiDataQueryDTO;
import com.iailab.module.model.api.mcs.McsApi;
import com.iailab.module.model.api.mcs.dto.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

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

@Slf4j
@Service
public class DataServiceImpl implements DataApi {

    @Autowired
    private DataPointApi dataPointApi;

    @Autowired
    private McsApi mcsApi;

    @Autowired
    private PlanItemApi planItemApi;

    @Autowired
    private PowerRunStateDao powerRunStateDao;

    @Override
    public List<PowerRunStateDTO> getPowerRunState() {
        List<PowerRunStateDTO> list = ConvertUtils.sourceToTarget(powerRunStateDao.selectList(new QueryWrapper<>()), PowerRunStateDTO.class);
        if (!CollectionUtils.isEmpty(list)) {
            list.stream().map(item -> {
                StringBuffer sb = new StringBuffer();
                sb.append(item.getQhRate());
                sb.append(",");
                sb.append(item.getFhRate());
                sb.append(",");
                sb.append(item.getGasTotal());
                sb.append(",");
                sb.append(item.getGasCost());
                sb.append(",");
                sb.append(item.getGasSurplus());
                sb.append(",");
                sb.append(item.getBfg());
                sb.append(",");
                sb.append(item.getLdg());
                sb.append(",");
                sb.append(item.getCog());
                String[] arr = sb.toString().split(",");
                Map<String, Object> adjValue = dataPointApi.queryPointsRealValue(Arrays.asList(arr));
                item.setQhRate(ObjectUtils.isEmpty(adjValue.get(arr[0])) ? "0" : new BigDecimal(adjValue.get(arr[0]).toString()).setScale(2, BigDecimal.ROUND_HALF_UP).toString());
                item.setFhRate(ObjectUtils.isEmpty(adjValue.get(arr[1])) ? "0" : new BigDecimal(adjValue.get(arr[1]).toString()).setScale(2, BigDecimal.ROUND_HALF_UP).toString());
                item.setGasTotal(ObjectUtils.isEmpty(adjValue.get(arr[2])) ? "0" : new BigDecimal(adjValue.get(arr[2]).toString()).setScale(2, BigDecimal.ROUND_HALF_UP).toString());
                item.setGasCost(ObjectUtils.isEmpty(adjValue.get(arr[3])) ? "0" : new BigDecimal(adjValue.get(arr[3]).toString()).setScale(2, BigDecimal.ROUND_HALF_UP).toString());
                item.setGasSurplus(ObjectUtils.isEmpty(adjValue.get(arr[4])) ? "0" : new BigDecimal(adjValue.get(arr[4]).toString()).setScale(2, BigDecimal.ROUND_HALF_UP).toString());
                item.setBfg(ObjectUtils.isEmpty(adjValue.get(arr[5])) ? "0" : new BigDecimal(adjValue.get(arr[5]).toString()).setScale(2, BigDecimal.ROUND_HALF_UP).toString());
                item.setLdg(ObjectUtils.isEmpty(adjValue.get(arr[6])) ? "0" : new BigDecimal(adjValue.get(arr[6]).toString()).setScale(2, BigDecimal.ROUND_HALF_UP).toString());
                item.setCog(ObjectUtils.isEmpty(adjValue.get(arr[7])) ? "0" : new BigDecimal(adjValue.get(arr[7]).toString()).setScale(2, BigDecimal.ROUND_HALF_UP).toString());

                return item;
            }).collect(Collectors.toList());
        }
        return list;
    }

    @Override
    public PreDataChartRespVO getPreDataChart(PreDataSingleChartReqVO reqVO) {
        Map<String, String> tMap = new HashMap<>();
        List<ChartParamDTO> list = mcsApi.getChartParamList(reqVO.getChartCode());
        if (CollectionUtils.isEmpty(list)) {
            return null;
        }
        list.forEach(item -> {
            tMap.put(item.getParamCode(), item.getParamValue());
        });
        String itemCode = tMap.get(CommonConstant.ITEM_CODE);
        if (itemCode == null) {
            return null;
        }
        String resultStr = tMap.get(CommonConstant.RESULT_STR);
        if (resultStr == null) {
            return null;
        }
        String resultIndex = tMap.get(CommonConstant.RESULT_INDEX);

        PredictItemVO predictItem = mcsApi.getPredictItemByItemNo(itemCode);
        if (predictItem == null || predictItem.getLastTime() == null) {
            return null;
        }
        String timeFormat = StringUtils.isBlank(reqVO.getTimeFormat()) ? DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND : reqVO.getTimeFormat();
        int lengthLeft = tMap.get(CommonConstant.LENGTH_LEFT) == null ? predictItem.getPredictLength() : new BigDecimal(tMap.get(CommonConstant.LENGTH_LEFT)).intValue();
        int lengthRight = tMap.get(CommonConstant.LENGTH_RIGHT) == null ? predictItem.getPredictLength() : new BigDecimal(tMap.get(CommonConstant.LENGTH_RIGHT)).intValue();
        String trendsDataH = tMap.get(CommonConstant.TRENDSDATA_H) == null ? null : tMap.get(CommonConstant.TRENDSDATA_H);
        String trendsDataL = tMap.get(CommonConstant.TRENDSDATA_L) == null ? null : tMap.get(CommonConstant.TRENDSDATA_L);

        Date[] timeArray = calResultTime(predictItem, reqVO.getStartTime(), reqVO.getEndTime(), lengthLeft, lengthRight);
        Date startTime = timeArray[1];
        Date endTime = timeArray[2];

        PreDataSingleChartRespVO resultOld = mcsApi.getPreDataSingleChart(reqVO);
        PreDataChartRespVO result = ConvertUtils.sourceToTarget(resultOld, PreDataChartRespVO.class);
        PreDataViewDTO preDataView = ConvertUtils.sourceToTarget(resultOld.getDataView(), PreDataViewDTO.class);
        if(trendsDataH != null) {
            ApiPointValueQueryDTO pointValueQueryDTO = new ApiPointValueQueryDTO();
            pointValueQueryDTO.setPointNo(trendsDataH);
            List<ApiPointValueDTO> trendsDataHList = ConvertUtils.sourceToTarget(dataPointApi.queryPointHistoryValue(pointValueQueryDTO), ApiPointValueDTO.class);
            List<Object[]> newList = new ArrayList<>();
            trendsDataHList.forEach(item -> {
                Object[] dataItem = new Object[2];
                dataItem[0] = item.getT();
                dataItem[1] = item.getV();
                newList.add(dataItem);
            });
            preDataView.setTrendsDataH(newList);
        }
        if(trendsDataL != null) {
            ApiPointValueQueryDTO pointValueQueryDTO = new ApiPointValueQueryDTO();
            pointValueQueryDTO.setPointNo(trendsDataL);
            List<ApiPointValueDTO> trendsDataLList = ConvertUtils.sourceToTarget(dataPointApi.queryPointHistoryValue(pointValueQueryDTO), ApiPointValueDTO.class);
            List<Object[]> newList = new ArrayList<>();
            trendsDataLList.forEach(item -> {
                Object[] dataItem = new Object[2];
                dataItem[0] = item.getT();
                dataItem[1] = item.getV();
                newList.add(dataItem);
            });
            preDataView.setTrendsDataL(newList);
        }
        MmItemOutputDTO outputDTO = mcsApi.getItemOutputByItemid(predictItem.getId(), resultStr, resultIndex);

        PreItemResultReqVO preItemResultReqVO = new PreItemResultReqVO();
        preItemResultReqVO.setOutputid(outputDTO.getId());
        preItemResultReqVO.setStartTime(startTime);
        preItemResultReqVO.setEndTime(endTime);
        preItemResultReqVO.setTimeFormat(timeFormat);

        preDataView.setPreData(resultOld.getDataView().getPreDataL());

        result.setPreDataView(preDataView);
        return result;
    }

    private Date[] calResultTime(PredictItemVO predictItem, Date startTimeReq, Date endTimeReq, int lengthLeft, int lengthRight) {
        Date[] result = new Date[3];
        Date predictTime = predictItem.getLastTime();
        Integer granularity = predictItem.getGranularity();
        Date startTime = startTimeReq;
        if (startTime == null) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(predictItem.getLastTime());
            calendar.add(Calendar.SECOND, -1 * lengthLeft * granularity);
            startTime = calendar.getTime();
        }
        Date endTime = endTimeReq;
        if (endTime == null) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(predictItem.getLastTime());
            calendar.add(Calendar.SECOND, lengthRight * granularity);
            endTime = calendar.getTime();
        }
        if (endTime.getTime() <= startTime.getTime()) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(startTime);
            calendar.add(Calendar.SECOND, lengthRight * granularity);
            endTime = calendar.getTime();
        }
        result[0] = predictTime;
        result[1] = startTime;
        result[2] = endTime;
        return result;
    }
    /**
     *  查询原始计划、修正计划数据
     */
    @Override
    public Map<String, Object> getPlanDataChart(PlanDataChartReqVO reqVO) {
        Map<String, Object> result = new HashMap<>(2);
        Map<String, String> tMap = new HashMap<>();
        List<ChartParamDTO> list = mcsApi.getChartParamList(reqVO.getChartCode());
        if (CollectionUtils.isEmpty(list)) {
            return null;
        }
        list.forEach(item -> {
            tMap.put(item.getParamCode(), item.getParamValue());
        });
        String planCode = tMap.get(CommonConstant.PLAN_CODE);
        if (planCode == null) {
            return null;
        }

        Date startTime = DateUtils.parse(reqVO.getStartTime(), DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND);
        Date endTime = DateUtils.parse(reqVO.getEndTime(), DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND);
        Date predictTime = DateUtils.parse(reqVO.getPredictTime(), DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND);
        // 原始计划数据
        LinkedHashMap<String, List<String[]>> planData = getRealPlanData(planCode, startTime, endTime, predictTime);

        // 修正计划数据
        LinkedHashMap<String, List<String[]>> predData = new LinkedHashMap<>();
        predData.put(reqVO.getChartCode(), getPrePlanData(reqVO.getChartCode(), predictTime, endTime));
        result.put("planData", planData);
        result.put("predData", predData);
        return result;
    }

    //原始计划
    public LinkedHashMap<String, List<String[]>> getRealPlanData(String planCode, Date startTime, Date endTime, Date predictTime) {
        LinkedHashMap<String, List<String[]>> result = new LinkedHashMap<>();
        ApiDataQueryDTO apiDataQueryDTO = new ApiDataQueryDTO();
        apiDataQueryDTO.setItemNo(planCode);
        apiDataQueryDTO.setStart(startTime);
        apiDataQueryDTO.setEnd(endTime);
        LinkedHashMap<String, List<ApiPlanDataDTO>> planData = planItemApi.queryPlanItemRecordValue(apiDataQueryDTO);
        planData.forEach((key, value) -> {
            List<String[]> recods = new ArrayList<>();
            if (!CollectionUtils.isEmpty(value)) {
                value.forEach(item -> {
                    String[] ri = new String[3];
                    ri[0] = DateUtils.format(DateUtils.parse(item.getStartTime(), DateUtils.DATE_TIME_PATTERN_STRING), "yyyy-MM-dd HH:mm:00");
                    ri[1] = DateUtils.format(DateUtils.parse(item.getEndTime(), DateUtils.DATE_TIME_PATTERN_STRING), "yyyy-MM-dd HH:mm:00");
                    ri[2] = "2";
                    if (DateUtils.parse(item.getStartTime(), "yyyyMMddHHmmss").getTime() < predictTime.getTime()) {
                        ri[2] = "1";
                    }
                    recods.add(ri);
                });
            }
            result.put(key, recods);
        });
        return result;
    }

    //修正计划
    public List<String[]> getPrePlanData(String charCode, Date startTime, Date endTime) {
        List<String[]> result = new ArrayList<>();
        PreDataSingleChartReqVO queryDto = new PreDataSingleChartReqVO();
        queryDto.setChartCode(charCode);
        queryDto.setStartTime(startTime);
        queryDto.setEndTime(startTime);
        PreDataSingleChartRespVO chartData = mcsApi.getPreDataSingleChart(queryDto);
        if (CollectionUtils.isEmpty(chartData.getDataView().getPreDataN())) {
            return result;
        }

        double lastValue = 0;
        for (int i = 0; i < chartData.getDataView().getPreDataN().size(); i++) {
            Object[] dataItem = chartData.getDataView().getPreDataN().get(i);
            double cv = new BigDecimal(dataItem[1].toString()).doubleValue();
            if (cv == 1 && cv != lastValue) {
                String[] sa = new String[3];
                sa[0] = (String) dataItem[0];
                sa[1] = getEndTime(chartData.getDataView().getPreDataN(), i);
                sa[2] = "2";
                result.add(sa);
            }
            lastValue = cv;
        }
        return result;
    }

    private String getEndTime(List<Object[]> preDataN, int startIndex) {
        String endTime = "";
        double lastValue = 1;
        for (int i = startIndex; i < preDataN.size(); i++) {
            Object[] dataItem = preDataN.get(i);
            double cv = new BigDecimal(dataItem[1].toString()).doubleValue();
            if (cv == 0 && cv != lastValue) {
                return (String) dataItem[0];
            }
            lastValue = cv;
        }
        return endTime;
    }
}