package com.iailab.module.model.mdk.sample;

import com.iailab.module.data.api.ind.IndItemApi;
import com.iailab.module.data.api.ind.dto.ApiIndItemDTO;
import com.iailab.module.data.api.plan.dto.ApiPlanItemDTO;
import com.iailab.module.data.api.point.dto.ApiPointDTO;
import com.iailab.module.data.enums.DataPointFreqEnum;
import com.iailab.module.data.enums.TimeGranularitySecEnum;
import com.iailab.module.model.mcs.pre.service.MmPredictItemService;
import com.iailab.module.model.mdk.common.enums.ModelParamType;
import com.iailab.module.model.mdk.sample.dto.ColumnItem;
import com.iailab.module.model.mdk.sample.dto.SampleInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;

import java.util.Calendar;
import java.util.Date;
import java.util.Map;

/**
 * @author PanZhibao
 * @Description
 * @createTime 2024年09月03日
 */
abstract class SampleInfoConstructor {

    @Autowired
    private IndItemApi indItemApi;

    @Autowired
    private MmPredictItemService mmPredictItemService;

    /**
     * prepareSampleInfo
     *
     * @param modelId
     * @param predictTime
     * @return
     */
    protected SampleInfo prepareSampleInfo(String modelId, Date predictTime, Map<Integer, Integer> dynamicDataLength) {
        //样本的列信息
        return getColumnInfo(modelId, predictTime, dynamicDataLength);
    }

    /**
     * 返回样本矩阵的列数
     *
     * @param modelId
     * @return
     */
    protected abstract Integer getSampleColumn(String modelId);


    /**
     * 样本的列信息
     *
     * @param modelId
     * @param predictTime
     * @return
     */
    protected abstract SampleInfo getColumnInfo(String modelId, Date predictTime, Map<Integer, Integer> dynamicDataLength);

    /**
     * 样本的采样周期
     *
     * @param modelId
     * @return
     */
    protected abstract Integer getSampleCycle(String modelId);

    /**
     * 获取开始时间
     *
     * @param columnItem
     * @param originalTime
     * @return
     * @throws Exception
     */
    protected Date getStartTime(ColumnItem columnItem, Date originalTime) {
        Date dateTime = new Date();
        switch (ModelParamType.getEumByCode(columnItem.getParamType())) {
            case DATAPOINT:
                dateTime = calculateTime(originalTime, true, columnItem.getDataLength(), columnItem.getGranularity());
                break;
            case PLAN:
                dateTime = calculateTime(originalTime, true, columnItem.getDataLength() + 1, columnItem.getGranularity());
                break;
            case IND:
            case IND_ASCII:
                dateTime = calculateTime(originalTime, true, columnItem.getDataLength() - 1, columnItem.getGranularity());
                break;
            case NORMALITEM:
            case MERGEITEM:
                dateTime = calculateTime(originalTime, false, 1, columnItem.getGranularity());
                break;
            default:
                break;
        }
        return dateTime;
    }

    /**
     * 获取结束时间
     *
     * @param columnItem
     * @param originalTime
     * @return
     * @throws Exception
     */
    protected Date getEndTime(ColumnItem columnItem, Date originalTime) {
        Date dateTime = new Date();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(originalTime);
        switch (ModelParamType.getEumByCode(columnItem.getParamType())) {
            case DATAPOINT:
                dateTime = calculateTime(originalTime, true, 1, columnItem.getGranularity());
                break;
            case PLAN:
                dateTime = calculateTime(originalTime, true, 1, columnItem.getGranularity());
                break;
            case IND:
            case IND_ASCII:
                dateTime = originalTime;
                break;
            case NORMALITEM:
            case MERGEITEM:
                dateTime = calculateTime(originalTime, false, columnItem.getDataLength() + 1, columnItem.getGranularity());
                break;
            default:
                break;
        }
        return dateTime;
    }

    /**
     * 获取粒度，s
     *
     * @param columnItem
     * @return
     * @throws Exception
     */
    protected Integer getGranularity(ColumnItem columnItem,Map<String, ApiPointDTO> pointMap, Map<String, ApiPlanItemDTO> planMap,Map<String, ApiIndItemDTO> indMap) {
        // 默认60s
        Integer granularity = 60;
        switch (ModelParamType.getEumByCode(columnItem.getParamType())) {
            case DATAPOINT:
                ApiPointDTO dataPoint = pointMap.get(columnItem.getParamId());
                granularity = DataPointFreqEnum.getEumByCode(dataPoint.getMinfreqid()).getValue();
                break;
            case NORMALITEM:
            case MERGEITEM:
                granularity = mmPredictItemService.getItemByOutPutId(columnItem.getParamId()).getGranularity();
                break;
            case IND:
            case IND_ASCII:
                ApiIndItemDTO indItemDTO = indMap.get(columnItem.getParamId());
                granularity = TimeGranularitySecEnum.getEumByCode(indItemDTO.getTimeGranularity()).getValue();;
                break;
            case PLAN:
                ApiPlanItemDTO apiPlanItemDTO = planMap.get(columnItem.getParamId());
                granularity = TimeGranularitySecEnum.getEumByCode(apiPlanItemDTO.getTimeGranularity()).getValue();
                break;
            default:
                break;
        }
        return granularity;
    }

    /**
     * 计算取值的时间
     *
     * @param originalTime
     * @param backward
     * @param dataLength
     * @param granularity
     * @return
     */
    public Date calculateTime(Date originalTime, Boolean backward, int dataLength, int granularity) {
        int timeLength;
        if (backward) {
            timeLength = (-1) * dataLength;
        } else {
            timeLength = dataLength;
        }
        Date desTime = originalTime;
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(desTime);
        calendar.set(Calendar.MILLISECOND, 0);
        // 数据长度 * 粒度
        calendar.add(Calendar.SECOND, timeLength * granularity);
        return calendar.getTime();
    }

    protected int getDataLength(Map<Integer, Integer> dynamicDataLength, Integer port, Integer dataLength) {
        if (CollectionUtils.isEmpty(dynamicDataLength)) {
            return dataLength;
        }
        if (dynamicDataLength.containsKey(port)) {
            return dynamicDataLength.get(port);
        }
        return dataLength;
    }
}