package com.ruoyi.energymeter.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.energymeter.constant.EnergyMeterConstants;
import com.ruoyi.energymeter.dto.DailyUsageRow;
import com.ruoyi.energymeter.dto.DataRangeRow;
import com.ruoyi.energymeter.dto.MonthlyUsageRow;
import com.ruoyi.energymeter.mapper.EnergyMeterDeviceMapper;
import com.ruoyi.energymeter.mapper.EnergyMeterMeasurementMapper;
import com.ruoyi.energymeter.pojo.EnergyMeterDevice;
import com.ruoyi.energymeter.pojo.EnergyMeterMeasurement;
import com.ruoyi.energymeter.provider.MeterProviderClient;
import com.ruoyi.energymeter.service.EnergyMeterStatService;
import com.ruoyi.energymeter.util.EnergyMeterSupport;
import com.ruoyi.energymeter.vo.EnergyMeterOverviewVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 概览统计实现。
 *
 * <p>只从 D 粒度的 *_USAGE 指标汇总，绝不累加 POINT 表码；缺失日期保持 null，由前端显示缺口。</p>
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class EnergyMeterStatServiceImpl implements EnergyMeterStatService {

    private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd");

    private final EnergyMeterDeviceMapper deviceMapper;
    private final EnergyMeterMeasurementMapper measurementMapper;
    private final MeterProviderClient provider;

    @Override
    public EnergyMeterOverviewVO overview(String meterType, Long meterId, String month, Integer year) {
        String type = normalizeType(meterType);
        YearMonth selectedMonth = parseMonth(month);
        int selectedYear = year == null ? selectedMonth.getYear() : year;
        if (selectedYear < 2000 || selectedYear > 2100) {
            throw new ServiceException("年份不合法");
        }

        EnergyMeterOverviewVO vo = new EnergyMeterOverviewVO();
        vo.setMeterType(type);
        vo.setMetricCode(EnergyMeterConstants.usageMetric(type));
        vo.setUnit(EnergyMeterConstants.unit(type));
        vo.setMeterId(meterId);
        vo.setMockMode(provider.mockMode());
        vo.setSelectedMonth(selectedMonth.toString());
        vo.setSelectedYear(String.valueOf(selectedYear));
        vo.setMonthCost(null);
        vo.setYearCost(null);

        List<EnergyMeterDevice> devices = resolveDevices(type, meterId);
        vo.setDeviceCount(devices.size());
        vo.setScopeLabel(buildScopeLabel(devices, meterId));
        List<Long> meterIds = devices.stream().map(EnergyMeterDevice::getId).collect(Collectors.toList());

        LocalDate today = EnergyMeterSupport.today();
        LocalDate yesterday = today.minusDays(1);
        LocalDate monthStart = selectedMonth.atDay(1);
        LocalDate monthEndExclusive = selectedMonth.plusMonths(1).atDay(1);
        YearMonth previousMonth = selectedMonth.minusMonths(1);

        Map<LocalDate, BigDecimal> currentDaily = toDayMap(monthIdsEmpty(meterIds) ? List.of() : measurementMapper.sumDailyUsage(
                meterIds, vo.getMetricCode(), monthStart.atStartOfDay(), monthEndExclusive.atStartOfDay()));
        Map<LocalDate, BigDecimal> previousDaily = toDayMap(monthIdsEmpty(meterIds) ? List.of() : measurementMapper.sumDailyUsage(
                meterIds, vo.getMetricCode(), previousMonth.atDay(1).atStartOfDay(), monthStart.atStartOfDay()));

        int daysInMonth = selectedMonth.lengthOfMonth();
        int daysInPreviousMonth = previousMonth.lengthOfMonth();
        int cutDay = resolveCutDay(selectedMonth, today);

        List<EnergyMeterOverviewVO.MonthDayPoint> monthSeries = new ArrayList<>(daysInMonth);
        BigDecimal monthTotal = BigDecimal.ZERO;
        int collectedDays = 0;
        for (int day = 1; day <= daysInMonth; day++) {
            LocalDate date = monthStart.withDayOfMonth(day);
            BigDecimal currentValue = currentDaily.get(date);
            if (currentValue != null) {
                monthTotal = monthTotal.add(currentValue);
                if (day <= cutDay) {
                    collectedDays++;
                }
            }
            EnergyMeterOverviewVO.MonthDayPoint point = new EnergyMeterOverviewVO.MonthDayPoint();
            point.setDay(date.format(DATE_FORMAT));
            point.setCurrent(currentValue);
            point.setPrevious(day <= daysInPreviousMonth ? previousDaily.get(previousMonth.atDay(day)) : null);
            monthSeries.add(point);
        }
        vo.setMonthSeries(monthSeries);
        boolean monthHasData = !currentDaily.isEmpty();
        vo.setMonthHasData(monthHasData);
        vo.setMonthTotal(monthHasData ? monthTotal : null);

        BigDecimal previousTotal = BigDecimal.ZERO;
        int previousDayCount = 0;
        int compareDays = Math.min(cutDay, daysInPreviousMonth);
        for (int day = 1; day <= compareDays; day++) {
            BigDecimal value = previousDaily.get(previousMonth.atDay(day));
            if (value != null) {
                previousTotal = previousTotal.add(value);
                previousDayCount++;
            }
        }
        vo.setMonthPreviousTotal(previousDayCount > 0 ? previousTotal : null);

        int expectedDays = cutDay;
        // 设备入网之前的日期不应计入缺口：从设备同步起点与月初的较大者开始算
        if (!devices.isEmpty()) {
            LocalDate earliestSync = devices.stream()
                    .map(EnergyMeterDevice::getSyncStartDate)
                    .filter(java.util.Objects::nonNull)
                    .min(LocalDate::compareTo)
                    .orElse(null);
            if (earliestSync != null && earliestSync.isAfter(monthStart)) {
                int days = (int) java.time.temporal.ChronoUnit.DAYS.between(earliestSync,
                        monthStart.plusDays(cutDay));
                expectedDays = Math.max(0, Math.min(days, cutDay));
            }
        }
        vo.setCollectedDays(collectedDays);
        vo.setExpectedDays(expectedDays);
        vo.setCoverageRate(expectedDays <= 0 ? BigDecimal.valueOf(100)
                : BigDecimal.valueOf(collectedDays * 100.0 / expectedDays).setScale(1, RoundingMode.HALF_UP));

        java.time.LocalDate yearStart = LocalDate.of(selectedYear, 1, 1);
        java.time.LocalDate yearEndExclusive = yearStart.plusYears(1);
        java.time.LocalDate previousYearStart = yearStart.minusYears(1);
        Map<String, BigDecimal> currentMonthly = toMonthMap(monthIdsEmpty(meterIds) ? List.of()
                : measurementMapper.sumMonthlyUsage(meterIds, vo.getMetricCode(),
                yearStart.atStartOfDay(), yearEndExclusive.atStartOfDay()));
        Map<String, BigDecimal> previousMonthly = toMonthMap(monthIdsEmpty(meterIds) ? List.of()
                : measurementMapper.sumMonthlyUsage(meterIds, vo.getMetricCode(),
                previousYearStart.atStartOfDay(), yearStart.atStartOfDay()));
        boolean yearHasData = !currentMonthly.isEmpty();
        vo.setYearHasData(yearHasData);

        int currentYear = today.getYear();
        int cutMonth = selectedYear < currentYear ? 12 : (selectedYear > currentYear ? 0 : today.getMonthValue());
        List<EnergyMeterOverviewVO.YearMonthPoint> yearSeries = new ArrayList<>(12);
        BigDecimal yearTotal = BigDecimal.ZERO;
        for (int m = 1; m <= 12; m++) {
            String key = selectedYear + "-" + String.format("%02d", m);
            String previousKey = (selectedYear - 1) + "-" + String.format("%02d", m);
            BigDecimal currentValue = currentMonthly.get(key);
            if (currentValue != null) {
                yearTotal = yearTotal.add(currentValue);
            }
            EnergyMeterOverviewVO.YearMonthPoint point = new EnergyMeterOverviewVO.YearMonthPoint();
            point.setMonth(key);
            point.setCurrent(currentValue);
            point.setPrevious(previousMonthly.get(previousKey));
            yearSeries.add(point);
        }
        vo.setYearSeries(yearSeries);
        vo.setYearTotal(yearHasData ? yearTotal : null);

        BigDecimal previousYearTotal = BigDecimal.ZERO;
        int previousMonthCount = 0;
        for (int m = 1; m <= cutMonth; m++) {
            BigDecimal value = previousMonthly.get((selectedYear - 1) + "-" + String.format("%02d", m));
            if (value != null) {
                previousYearTotal = previousYearTotal.add(value);
                previousMonthCount++;
            }
        }
        vo.setYearPreviousTotal(previousMonthCount > 0 ? previousYearTotal : null);

        DataRangeRow range = monthIdsEmpty(meterIds) ? null
                : measurementMapper.selectDataRange(meterIds, vo.getMetricCode());
        vo.setDataStart(range != null && range.getMinTime() != null ? range.getMinTime().toLocalDate().format(DATE_FORMAT) : null);
        vo.setDataEnd(range != null && range.getMaxTime() != null ? range.getMaxTime().toLocalDate().format(DATE_FORMAT) : null);
        vo.setDataThrough(yesterday.format(DATE_FORMAT));

        LocalDateTime lastSuccess = devices.stream()
                .map(EnergyMeterDevice::getLastSuccessAt)
                .filter(java.util.Objects::nonNull)
                .max(LocalDateTime::compareTo)
                .orElse(null);
        vo.setLastSuccessAt(lastSuccess == null ? null : lastSuccess.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));

        boolean hasData = monthHasData || yearHasData || range != null && range.getMaxTime() != null;
        vo.setHasData(hasData);
        long manualCount = devices.stream()
                .filter(d -> EnergyMeterConstants.isManual(d.getSourceType()))
                .count();
        boolean manualOnly = !devices.isEmpty() && manualCount == devices.size();
        int expectedForStatus = expectedDays;
        if (manualOnly) {
            // 手工抄表按“抄表期数”计，不按自然日算缺口
            vo.setExpectedDays(collectedDays);
            vo.setCoverageRate(collectedDays > 0 ? BigDecimal.valueOf(100) : BigDecimal.ZERO);
            expectedForStatus = collectedDays;
        }
        applySyncStatus(vo, hasData, lastSuccess, collectedDays, expectedForStatus, monthHasData, yearHasData, manualOnly);
        return vo;
    }

    @Override
    public IPage<EnergyMeterMeasurement> pageMeasurements(Long meterId, String metricCode, String granularity,
                                                          LocalDate start, LocalDate end, long current, long size) {
        EnergyMeterDevice device = requireDevice(meterId);
        long safeSize = Math.min(Math.max(size, 1), 200);
        Page<EnergyMeterMeasurement> page = new Page<>(Math.max(current, 1), safeSize);
        LambdaQueryWrapper<EnergyMeterMeasurement> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EnergyMeterMeasurement::getMeterId, device.getId());
        if (StringUtils.isNotBlank(metricCode)) {
            wrapper.eq(EnergyMeterMeasurement::getMetricCode, metricCode);
        }
        if (StringUtils.isNotBlank(granularity)) {
            wrapper.eq(EnergyMeterMeasurement::getGranularity, granularity);
        }
        if (start != null) {
            wrapper.ge(EnergyMeterMeasurement::getMeasureTime, start.atStartOfDay());
        }
        if (end != null) {
            wrapper.lt(EnergyMeterMeasurement::getMeasureTime, end.plusDays(1).atStartOfDay());
        }
        wrapper.orderByDesc(EnergyMeterMeasurement::getMeasureTime)
                .orderByDesc(EnergyMeterMeasurement::getId);
        IPage<EnergyMeterMeasurement> result = measurementMapper.selectPage(page, wrapper);
        result.getRecords().forEach(item -> {
            item.setMeterName(device.getDisplayName());
            item.setMeterType(device.getMeterType());
            item.setMeterAddress(device.getMeterAddress());
        });
        return result;
    }

    /* ------------------------------------------------------------------ */

    private List<EnergyMeterDevice> resolveDevices(String meterType, Long meterId) {
        if (meterId != null) {
            EnergyMeterDevice device = requireDevice(meterId);
            if (!meterType.equals(device.getMeterType())) {
                throw new ServiceException("设备类型与当前能源类型不一致");
            }
            return List.of(device);
        }
        LambdaQueryWrapper<EnergyMeterDevice> wrapper = new LambdaQueryWrapper<>();
        Long tenantId = EnergyMeterSupport.currentTenantId();
        if (tenantId != null) {
            wrapper.eq(EnergyMeterDevice::getTenantId, tenantId);
        }
        wrapper.eq(EnergyMeterDevice::getMeterType, meterType)
                .eq(EnergyMeterDevice::getEnabled, 1)
                .eq(EnergyMeterDevice::getBindStatus, EnergyMeterConstants.BIND_VERIFIED)
                .orderByAsc(EnergyMeterDevice::getId);
        return deviceMapper.selectList(wrapper);
    }

    private EnergyMeterDevice requireDevice(Long meterId) {
        if (meterId == null) {
            throw new ServiceException("设备ID不能为空");
        }
        EnergyMeterDevice device = deviceMapper.selectById(meterId);
        if (device == null) {
            throw new ServiceException("设备不存在或已删除");
        }
        Long tenantId = EnergyMeterSupport.currentTenantId();
        if (tenantId != null && device.getTenantId() != null && !tenantId.equals(device.getTenantId())) {
            throw new ServiceException("无权访问该设备");
        }
        return device;
    }

    private String buildScopeLabel(List<EnergyMeterDevice> devices, Long meterId) {
        if (meterId != null && !devices.isEmpty()) {
            EnergyMeterDevice device = devices.get(0);
            return device.getDisplayName() + "（" + device.getMeterAddress() + "）";
        }
        return "全部已绑定设备（" + devices.size() + " 台）";
    }

    private void applySyncStatus(EnergyMeterOverviewVO vo, boolean hasData, LocalDateTime lastSuccess,
                                 int collectedDays, int expectedDays, boolean monthHasData, boolean yearHasData,
                                 boolean manualOnly) {
        String status;
        String text;
        if (manualOnly) {
            if (!monthHasData && !yearHasData) {
                status = "EMPTY";
                text = "暂无抄表记录";
            } else if (expectedDays > 0 && collectedDays < expectedDays) {
                status = "PARTIAL";
                text = "抄表数据存在缺口（" + collectedDays + "/" + expectedDays + " 天）";
            } else {
                status = "OK";
                text = "手工抄表数据";
            }
            vo.setSyncStatus(status);
            vo.setSyncStatusText(text);
            return;
        }
        if (!monthHasData && !yearHasData) {
            status = "EMPTY";
            text = "暂无采集数据";
        } else if (!hasData) {
            status = "EMPTY";
            text = "暂无采集数据";
        } else if (lastSuccess == null
                || lastSuccess.isBefore(EnergyMeterSupport.now().minusHours(36))) {
            status = "STALE";
            text = "超过 36 小时无成功采集";
        } else if (expectedDays > 0 && collectedDays < expectedDays) {
            status = "PARTIAL";
            text = "数据存在缺口（" + collectedDays + "/" + expectedDays + " 天）";
        } else {
            status = "OK";
            text = "数据完整";
        }
        vo.setSyncStatus(status);
        vo.setSyncStatusText(text);
    }

    private int resolveCutDay(YearMonth month, LocalDate today) {
        YearMonth currentMonth = YearMonth.from(today);
        if (month.isAfter(currentMonth)) {
            return 0;
        }
        if (month.equals(currentMonth)) {
            return Math.max(today.minusDays(1).getDayOfMonth(), 0);
        }
        return month.lengthOfMonth();
    }

    private Map<LocalDate, BigDecimal> toDayMap(List<DailyUsageRow> rows) {
        Map<LocalDate, BigDecimal> map = new HashMap<>();
        for (DailyUsageRow row : rows) {
            if (row.getDay() != null && row.getTotal() != null) {
                map.put(LocalDate.parse(row.getDay()), row.getTotal());
            }
        }
        return map;
    }

    private Map<String, BigDecimal> toMonthMap(List<MonthlyUsageRow> rows) {
        Map<String, BigDecimal> map = new HashMap<>();
        for (MonthlyUsageRow row : rows) {
            if (row.getMonth() != null && row.getTotal() != null) {
                map.put(row.getMonth(), row.getTotal());
            }
        }
        return map;
    }

    private boolean monthIdsEmpty(List<Long> ids) {
        return ids == null || ids.isEmpty();
    }

    private YearMonth parseMonth(String month) {
        if (StringUtils.isBlank(month)) {
            return YearMonth.now(EnergyMeterConstants.ZONE);
        }
        try {
            return YearMonth.parse(month.trim());
        } catch (Exception e) {
            throw new ServiceException("月份格式应为 yyyy-MM");
        }
    }

    private String normalizeType(String meterType) {
        String type = EnergyMeterConstants.canonicalType(meterType);
        if (type == null) {
            throw new ServiceException("能源类型只支持水表（WATER）、电表（ELECTRIC）或气表（GAS）");
        }
        return type;
    }
}