package com.iailab.module.data.point.collection.handler;

import com.iailab.module.data.api.point.DataPointApi;
import com.iailab.module.data.api.point.dto.ApiPointDTO;
import com.iailab.module.data.api.point.dto.ApiPointValueQueryDTO;
import com.iailab.module.data.common.enums.CommonConstant;
import com.iailab.module.data.enums.DataPointFreqEnum;
import com.iailab.module.data.influxdb.pojo.InfluxPointValuePOJO;
import com.iailab.module.data.point.collection.PointCollector;
import com.iailab.module.data.point.collection.utils.GenInfluxPointValueUtils;
import com.iailab.module.data.point.common.ExtremaUnitEnum;
import com.iailab.module.data.point.common.ExtremalTypeEnum;
import com.iailab.module.data.point.dto.DaPointDTO;
import com.iailab.module.data.point.service.DaPointService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;

/**
 * 极值点处理类
 *
 * @author PanZhibao
 * @Description
 * @createTime 2025年05月14日
 */
@Slf4j
@Component
public class ExtremalHandle {

    @Resource
    private DaPointService daPointService;

    @Autowired
    @Lazy
    private DataPointApi dataPointApi;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public List<InfluxPointValuePOJO> handle(Date collectTime, List<DaPointDTO> dtos, Map<String, Object> dataMap, List<String> listGood, List<String> listBad) {
        List<InfluxPointValuePOJO> result = new ArrayList<>();
        try {
            log.info("极值点处理开始");
            if (CollectionUtils.isEmpty(dtos)) {
                return result;
            }
            dtos.forEach(dto -> {
                try {
                    Object rawValue = singleCompute(dto, collectTime, listGood, listBad);
                    BigDecimal coefficient = dto.getUnittransfactor() == null ? BigDecimal.ONE : dto.getUnittransfactor();
                    BigDecimal calValue = new BigDecimal(rawValue.toString()).multiply(coefficient);
                    InfluxPointValuePOJO pojo = GenInfluxPointValueUtils.getByPoint(dto, calValue);
                    pojo.setTimestamp(GenInfluxPointValueUtils.getByMin(collectTime, DataPointFreqEnum.getEumByCode(dto.getMinfreqid())));
                    dataMap.put(dto.getPointNo(), calValue);
                    result.add(pojo);
                } catch (Exception ex) {
                    ex.printStackTrace();
                    log.info("极值点异常！PointNo=" + dto.getPointNo());
                }
            });
        } catch (Exception ex) {
            ex.printStackTrace();
            log.info("极值点处理异常！");
        }
        return result;
    }

    public Map<String, Object> getCurrent(List<String> pointNos) {
        Map<String, Object> data = new HashMap<>();
        List<DaPointDTO> pointExtremalList = daPointService.getExtremalPoint(pointNos);
        if (CollectionUtils.isEmpty(pointExtremalList)) {
            return data;
        }
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.MILLISECOND, 0);
        calendar.set(Calendar.SECOND, 0);
        pointExtremalList.forEach(item -> {
            Object value = CommonConstant.BAD_VALUE;
            if (redisTemplate.hasKey(PointCollector.PV + item.getPointNo())) {
                value = redisTemplate.opsForValue().get(PointCollector.PV + item.getPointNo());
            } else {
                value = singleCompute(item, calendar.getTime(), new ArrayList<>(), new ArrayList<>());
                BigDecimal coefficient = item.getUnittransfactor() == null ? BigDecimal.ONE : item.getUnittransfactor();
                value = new BigDecimal(value.toString()).multiply(coefficient);
            }
            data.put(item.getPointNo(), value);
        });
        return data;
    }

    private Object singleCompute(DaPointDTO dto, Date collectTime, List<String> listGood, List<String> listBad) {
        Object value = CommonConstant.BAD_VALUE;
        ApiPointDTO momentPoint = dataPointApi.getInfoByNo(dto.getMomentPoint());
        if (momentPoint == null) {
            if (listBad != null) {
                listBad.add(dto.getPointNo());
            }
            return CommonConstant.BAD_VALUE;
        }
        log.info("极值:" + dto.getPointNo());

        // 动态长度
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(collectTime);
        calendar.add(Calendar.SECOND, -1 * DataPointFreqEnum.getEumByCode(momentPoint.getMinfreqid()).getValue());
        Date endTime = calendar.getTime();
        Date startTime = ExtremaUnitEnum.getStartTime(calendar, dto.getLength(), dto.getExtremalUnit());
        ApiPointValueQueryDTO queryDto = new ApiPointValueQueryDTO();
        queryDto.setPointNo(momentPoint.getPointNo());
        queryDto.setStart(startTime);
        queryDto.setEnd(endTime);
        Map<String, Object> eValue = new HashMap<>();
        switch (ExtremalTypeEnum.getEumByCode(dto.getExtremalType())) {
            case MAX:
                eValue = dataPointApi.queryPointMaxValueRange(queryDto);
                break;
            case MIN:
                eValue = dataPointApi.queryPointMinValueRange(queryDto);
                break;
            default:
                break;
        }
        if (eValue != null) {
            value = eValue.get(momentPoint.getPointNo());
            listGood.add(dto.getPointNo());
        }
        return value;
    }
}