package com.doumee.service.business.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.doumee.core.utils.Constants;
import com.doumee.dao.business.YwConditionerUsageMapper;
import com.doumee.dao.business.YwElectricalDataMapper;
import com.doumee.dao.business.model.YwConditionerUsage;
import com.doumee.dao.business.model.YwElectricalData;
import com.doumee.dao.business.vo.DailyEnergyStatVO;
import com.doumee.service.business.YwWorkDeskEnergyService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

@Service
public class YwWorkDeskEnergyServiceImpl implements YwWorkDeskEnergyService {

    private static final int DAYS = 30;
    private static final DateTimeFormatter DATE_FMT = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    private static final String READ_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

    @Autowired
    private YwElectricalDataMapper ywElectricalDataMapper;

    @Autowired
    private YwConditionerUsageMapper ywConditionerUsageMapper;

    @Override
    public List<DailyEnergyStatVO> electricalDailyStats() {
        LocalDate end = LocalDate.now();
        LocalDate start = end.minusDays(DAYS - 1L);
        LocalDate queryStart = start.minusDays(1L);
        Map<String, DailyEnergyStatVO> bucket = initDailyBucket(start, end);

        List<YwElectricalData> rows = ywElectricalDataMapper.selectList(new QueryWrapper<YwElectricalData>().lambda()
                .eq(YwElectricalData::getIsdeleted, Constants.ZERO)
                .ge(YwElectricalData::getCreateDate, java.sql.Date.valueOf(queryStart))
                .le(YwElectricalData::getCreateDate, java.sql.Date.valueOf(end.plusDays(1))));

        SimpleDateFormat dayFmt = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat readTimeFmt = new SimpleDateFormat(READ_TIME_PATTERN);
        Map<String, Map<String, MeterDayReading>> meterDayLatest = new HashMap<>();

        for (YwElectricalData row : rows) {
            String meterKey = resolveMeterKey(row);
            if (StringUtils.isBlank(meterKey)) {
                continue;
            }
            String dayKey = resolveElectricalDayKey(row, dayFmt);
            if (StringUtils.isBlank(dayKey)) {
                continue;
            }
            BigDecimal totalEnergy = resolveTotalEnergy(row);
            if (totalEnergy.compareTo(BigDecimal.ZERO) < 0) {
                continue;
            }
            long readingTime = resolveReadingTime(row, readTimeFmt);
            MeterDayReading snapshot = new MeterDayReading(totalEnergy, parseDecimal(row.getDqdj()), readingTime);
            upsertLatestReading(meterDayLatest, meterKey, dayKey, snapshot);
        }

        for (LocalDate day = start; !day.isAfter(end); day = day.plusDays(1)) {
            String todayKey = day.format(DATE_FMT);
            String yesterdayKey = day.minusDays(1).format(DATE_FMT);
            DailyEnergyStatVO stat = bucket.get(todayKey);
            for (Map<String, MeterDayReading> dayReadings : meterDayLatest.values()) {
                MeterDayReading todayReading = dayReadings.get(todayKey);
                MeterDayReading yesterdayReading = dayReadings.get(yesterdayKey);
                if (todayReading == null || yesterdayReading == null) {
                    continue;
                }
                BigDecimal usage = todayReading.totalEnergy.subtract(yesterdayReading.totalEnergy);
                if (usage.compareTo(BigDecimal.ZERO) <= 0) {
                    continue;
                }
                stat.setTotalKwh(stat.getTotalKwh().add(usage));
                stat.setTotalFee(stat.getTotalFee().add(usage.multiply(todayReading.price)));
            }
        }
        return normalizeBucket(bucket);
    }

    @Override
    public List<DailyEnergyStatVO> conditionerDailyStats() {
        LocalDate end = LocalDate.now();
        LocalDate start = end.minusDays(DAYS - 1L);
        Map<String, DailyEnergyStatVO> bucket = initDailyBucket(start, end);

        List<YwConditionerUsage> rows = ywConditionerUsageMapper.selectList(new QueryWrapper<YwConditionerUsage>().lambda()
                .eq(YwConditionerUsage::getIsdeleted, Constants.ZERO)
                .ge(YwConditionerUsage::getUsageDate, java.sql.Date.valueOf(start))
                .le(YwConditionerUsage::getUsageDate, java.sql.Date.valueOf(end)));

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        for (YwConditionerUsage row : rows) {
            if (row.getUsageDate() == null) {
                continue;
            }
            String dayKey = sdf.format(row.getUsageDate());
            if (!bucket.containsKey(dayKey)) {
                continue;
            }
            DailyEnergyStatVO stat = bucket.get(dayKey);
            stat.setTotalKwh(stat.getTotalKwh().add(nullToZero(row.getSumDl())));
            stat.setTotalFee(stat.getTotalFee().add(nullToZero(row.getSumDf())));
        }
        return normalizeBucket(bucket);
    }

    private static void upsertLatestReading(Map<String, Map<String, MeterDayReading>> meterDayLatest,
                                            String meterKey,
                                            String dayKey,
                                            MeterDayReading snapshot) {
        Map<String, MeterDayReading> dayMap = meterDayLatest.computeIfAbsent(meterKey, key -> new HashMap<>());
        MeterDayReading existing = dayMap.get(dayKey);
        if (existing == null || snapshot.readingTime >= existing.readingTime) {
            dayMap.put(dayKey, snapshot);
        }
    }

    private static String resolveMeterKey(YwElectricalData row) {
        if (StringUtils.isNotBlank(row.getAddress())) {
            return row.getAddress().trim();
        }
        if (StringUtils.isNotBlank(row.getDeviceId())) {
            return "dev:" + row.getDeviceId().trim();
        }
        if (StringUtils.isNotBlank(row.getMid())) {
            return "mid:" + row.getMid().trim();
        }
        return null;
    }

    private static BigDecimal resolveTotalEnergy(YwElectricalData row) {
        BigDecimal total = parseDecimal(row.getZhygzdl());
        if (total.compareTo(BigDecimal.ZERO) <= 0) {
            total = parseDecimal(row.getZyje());
        }
        return total;
    }

    private static long resolveReadingTime(YwElectricalData row, SimpleDateFormat readTimeFmt) {
        if (StringUtils.isNotBlank(row.getAddTime())) {
            String addTime = row.getAddTime().trim();
            if (addTime.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")) {
                try {
                    return readTimeFmt.parse(addTime).getTime();
                } catch (ParseException ignored) {
                    // fallback to createDate
                }
            }
        }
        Date createDate = row.getCreateDate();
        return createDate == null ? 0L : createDate.getTime();
    }

    private static List<DailyEnergyStatVO> normalizeBucket(Map<String, DailyEnergyStatVO> bucket) {
        List<DailyEnergyStatVO> list = new ArrayList<>(bucket.values());
        for (DailyEnergyStatVO stat : list) {
            stat.setTotalKwh(stat.getTotalKwh().setScale(2, RoundingMode.HALF_UP));
            stat.setTotalFee(stat.getTotalFee().setScale(2, RoundingMode.HALF_UP));
        }
        return list;
    }

    private static Map<String, DailyEnergyStatVO> initDailyBucket(LocalDate start, LocalDate end) {
        Map<String, DailyEnergyStatVO> bucket = new LinkedHashMap<>();
        for (LocalDate d = start; !d.isAfter(end); d = d.plusDays(1)) {
            DailyEnergyStatVO vo = new DailyEnergyStatVO();
            vo.setStatDate(d.format(DATE_FMT));
            vo.setTotalKwh(BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP));
            vo.setTotalFee(BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP));
            bucket.put(vo.getStatDate(), vo);
        }
        return bucket;
    }

    private static String resolveElectricalDayKey(YwElectricalData row, SimpleDateFormat sdf) {
        if (StringUtils.isNotBlank(row.getAddTime())) {
            String addTime = row.getAddTime().trim();
            if (addTime.length() >= 10) {
                return addTime.substring(0, 10);
            }
        }
        Date createDate = row.getCreateDate();
        return createDate == null ? null : sdf.format(createDate);
    }

    private static BigDecimal parseDecimal(String val) {
        if (StringUtils.isBlank(val)) {
            return BigDecimal.ZERO;
        }
        try {
            return new BigDecimal(val.trim());
        } catch (NumberFormatException e) {
            return BigDecimal.ZERO;
        }
    }

    private static BigDecimal nullToZero(BigDecimal val) {
        return val == null ? BigDecimal.ZERO : val;
    }

    private static class MeterDayReading {
        private final BigDecimal totalEnergy;
        private final BigDecimal price;
        private final long readingTime;

        private MeterDayReading(BigDecimal totalEnergy, BigDecimal price, long readingTime) {
            this.totalEnergy = totalEnergy;
            this.price = price;
            this.readingTime = readingTime;
        }
    }
}