package com.iailab.module.model.api;

import com.alibaba.fastjson.JSON;
import com.iailab.module.model.api.mdk.MdkApi;
import com.iailab.module.model.api.mdk.dto.*;
import com.iailab.framework.common.pojo.CommonResult;
import com.iailab.module.model.mcs.pre.entity.DmModuleEntity;
import com.iailab.module.model.mcs.pre.service.DmModuleService;
import com.iailab.module.model.mcs.pre.service.MmPredictItemService;
import com.iailab.module.model.mdk.predict.PredictModuleHandler;
import com.iailab.module.model.mdk.vo.ItemVO;
import com.iailab.module.model.mdk.vo.PredictResultVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.Valid;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import static com.iailab.framework.common.pojo.CommonResult.error;
import static com.iailab.framework.common.pojo.CommonResult.success;

/**
 * @author PanZhibao
 * @Description
 * @createTime 2024年08月26日
 */
@Slf4j
@RestController
@Validated
public class MdkApiImpl implements MdkApi {

    @Autowired
    private DmModuleService dmModuleService;

    @Autowired
    private MmPredictItemService mmPredictItemService;

    @Autowired
    private PredictModuleHandler predictModuleHandler;

    /**
     * 按模块预测
     *
     * @param reqDTO
     * @return
     */
    @Override
    public CommonResult<MdkPredictModuleRespDTO> predictModule(MdkPredictReqDTO reqDTO) {
        MdkPredictModuleRespDTO resp = new MdkPredictModuleRespDTO();
        Map<String, MdkPredictItemRespDTO> predictItemRespMap = new HashMap<>();
        try {
            if (reqDTO.getPredictTime() == null) {
                throw new Exception("PredictTime不能为空");
            }
            if (reqDTO.getModuleType() == null) {
                throw new Exception("ModuleType不能为空");
            }
            log.info("预测参数：" + JSON.toJSONString(reqDTO));
            MdkPredictModuleRespDTO result = new MdkPredictModuleRespDTO();
            result.setPredictTime(reqDTO.getPredictTime());
            result.setModuleType(reqDTO.getModuleType());
            List<DmModuleEntity> moduleList = dmModuleService.getModuleByModuleType(reqDTO.getModuleType());
            log.info("预测计算开始: " + System.currentTimeMillis());
            for (DmModuleEntity module : moduleList) {
                int intervalTime = 0;
                if (module.getPredicttime() != null) {
                    intervalTime = (int) (reqDTO.getPredictTime().getTime() - module.getPredicttime().getTime()) / (1000 * 60);
                }
                List<ItemVO> predictItemList = mmPredictItemService.getByModuleId(module.getId());
                Map<String, PredictResultVO> predictResultMap = predictModuleHandler.predict(predictItemList, reqDTO.getPredictTime(), intervalTime);
                for (Map.Entry<String, PredictResultVO> entry : predictResultMap.entrySet()) {
                    List<MdkPredictDataDTO> predictData = entry.getValue().getPredictList().stream().map(t-> {
                        MdkPredictDataDTO dto1 = new MdkPredictDataDTO();
                        dto1.setDataTime(t.getDataTime());
                        dto1.setDataValue(t.getDataValue());
                        return dto1;
                    }).collect(Collectors.toList());
                    MdkPredictItemRespDTO itemResp = new MdkPredictItemRespDTO();
                    itemResp.setItemId(entry.getValue().getPredictId());
                    itemResp.setPredictData(predictData);
                    predictItemRespMap.put(entry.getKey(), itemResp);
                }
            }
            log.info("预测计算结束: " + System.currentTimeMillis());
        } catch (Exception ex) {
            return error(999, ex.getMessage());
        }
        resp.setPredictItemRespMap(predictItemRespMap);
        return success(resp);
    }

    /**
     * 单个预测
     *
     * @param reqDTO
     * @return
     */
    @Override
    public CommonResult<MdkPredictItemRespDTO> predictItem(@Valid @RequestBody MdkPredictReqDTO reqDTO) {
        MdkPredictItemRespDTO resp = new MdkPredictItemRespDTO();

        return success(resp);
    }

    /**
     * 预测调整
     *
     * @param reqDTO
     * @return
     */
    @Override
    public CommonResult<Boolean> predictAutoAdjust(@Valid @RequestBody MdkPredictReqDTO reqDTO) {


        return success(true);
    }

    /**
     * 执行调度模型
     *
     * @param reqDTO
     * @return
     */
    @Override
    public CommonResult<MdkScheduleRespDTO> doSchedule(@Valid @RequestBody MdkScheduleReqDTO reqDTO) {
        MdkScheduleRespDTO resp = new MdkScheduleRespDTO();

        return success(resp);
    }
}