package com.ruoyi.safe.service.impl;

import com.ruoyi.dto.MapDto;
import com.ruoyi.safe.dto.SafeChartItemDto;
import com.ruoyi.safe.dto.SafeHiddenTypeStatDto;
import com.ruoyi.safe.dto.SafeLatestEventDto;
import com.ruoyi.safe.dto.SafeOverviewDto;
import com.ruoyi.safe.dto.SafeTrendDto;
import com.ruoyi.safe.mapper.SafeDashboardMapper;
import com.ruoyi.safe.service.SafeDashboardService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.YearMonth;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 安全数据驾驶舱服务实现
 */
@Service
@RequiredArgsConstructor
public class SafeDashboardServiceImpl implements SafeDashboardService {

    private static final DateTimeFormatter MONTH_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM");
    private static final int TREND_MONTHS = 6;
    private static final int EVENT_DEFAULT_LIMIT = 10;
    private static final int HAZARD_RANK_DEFAULT_LIMIT = 8;
    private static final int RECTIFY_RANK_DEFAULT_LIMIT = 5;
    private static final int LIMIT_MAX = 20;

    private final SafeDashboardMapper safeDashboardMapper;

    @Override
    public SafeOverviewDto getOverview() {
        SafeOverviewDto dto = safeDashboardMapper.selectOverview();
        return dto == null ? new SafeOverviewDto() : dto;
    }

    @Override
    public List<SafeLatestEventDto> getLatestEvents(Integer limit) {
        return safeDashboardMapper.selectLatestEvents(normalizeLimit(limit, EVENT_DEFAULT_LIMIT));
    }

    @Override
    public List<SafeChartItemDto> getHiddenTypeDistribution() {
        List<SafeHiddenTypeStatDto> stats = safeDashboardMapper.selectHiddenTypeDistribution();
        long grandTotal = stats.stream().mapToLong(s -> nvl(s.getTotalCount())).sum();
        List<SafeChartItemDto> result = new ArrayList<>();
        for (SafeHiddenTypeStatDto stat : stats) {
            int total = nvl(stat.getTotalCount());
            SafeChartItemDto item = new SafeChartItemDto();
            item.setName(stat.getName());
            item.setValue(String.valueOf(total));
            item.setRate(rate(total, grandTotal));
            item.setChildren(Arrays.asList(
                    buildChild("已整改", nvl(stat.getRectifiedCount()), total),
                    buildChild("待整改", nvl(stat.getPendingCount()), total)));
            result.add(item);
        }
        return result;
    }

    @Override
    public List<SafeTrendDto> getHiddenTrend() {
        YearMonth endMonth = YearMonth.now();
        YearMonth startMonth = endMonth.minusMonths(TREND_MONTHS - 1L);
        List<SafeTrendDto> rows = safeDashboardMapper.selectHiddenTrend(startMonth.atDay(1));
        Map<String, SafeTrendDto> rowMap = rows.stream()
                .collect(Collectors.toMap(SafeTrendDto::getMonth, Function.identity(), (a, b) -> a));

        List<SafeTrendDto> result = new ArrayList<>();
        for (YearMonth month = startMonth; !month.isAfter(endMonth); month = month.plusMonths(1)) {
            String key = month.format(MONTH_FORMATTER);
            SafeTrendDto row = rowMap.get(key);
            if (row == null) {
                row = new SafeTrendDto();
                row.setMonth(key);
                row.setReportedCount(0);
                row.setCompletedCount(0);
            } else {
                row.setReportedCount(nvl(row.getReportedCount()));
                row.setCompletedCount(nvl(row.getCompletedCount()));
            }
            result.add(row);
        }
        return result;
    }

    @Override
    public List<MapDto> getHazardRiskDistribution() {
        List<MapDto> rows = safeDashboardMapper.selectHazardRiskDistribution();
        long total = rows.stream().mapToLong(row -> parseCount(row.getValue())).sum();
        rows.forEach(row -> row.setRate(rate(parseCount(row.getValue()), total)));
        return rows;
    }

    @Override
    public List<MapDto> getHazardTypeRanking(Integer limit) {
        List<MapDto> rows = safeDashboardMapper.selectHazardTypeRanking();
        long total = rows.stream().mapToLong(row -> parseCount(row.getValue())).sum();
        rows.forEach(row -> row.setRate(rate(parseCount(row.getValue()), total)));
        return truncate(rows, normalizeLimit(limit, HAZARD_RANK_DEFAULT_LIMIT));
    }

    @Override
    public List<MapDto> getHiddenRectifyRanking(Integer limit) {
        List<MapDto> rows = safeDashboardMapper.selectHiddenRectifyRanking();
        long total = rows.stream().mapToLong(row -> parseCount(row.getValue())).sum();
        List<MapDto> result = new ArrayList<>();
        for (MapDto row : rows) {
            row.setRate(rate(parseCount(row.getValue()), total));
            if (!"未指派".equals(row.getName())) {
                result.add(row);
            }
        }
        return truncate(result, normalizeLimit(limit, RECTIFY_RANK_DEFAULT_LIMIT));
    }

    private SafeChartItemDto buildChild(String name, int value, int parentTotal) {
        SafeChartItemDto child = new SafeChartItemDto();
        child.setName(name);
        child.setValue(String.valueOf(value));
        child.setRate(rate(value, parentTotal));
        return child;
    }

    private List<MapDto> truncate(List<MapDto> rows, int limit) {
        return rows.size() > limit ? new ArrayList<>(rows.subList(0, limit)) : rows;
    }

    private int normalizeLimit(Integer limit, int defaultValue) {
        if (limit == null || limit < 1) {
            return defaultValue;
        }
        return Math.min(limit, LIMIT_MAX);
    }

    private int nvl(Integer value) {
        return value == null ? 0 : value;
    }

    private long parseCount(String value) {
        if (value == null || value.isBlank()) {
            return 0L;
        }
        try {
            return Long.parseLong(value.trim());
        } catch (NumberFormatException e) {
            return 0L;
        }
    }

    private String rate(long part, long total) {
        if (total <= 0) {
            return BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP).toPlainString();
        }
        return BigDecimal.valueOf(part)
                .multiply(BigDecimal.valueOf(100))
                .divide(BigDecimal.valueOf(total), 2, RoundingMode.HALF_UP)
                .toPlainString();
    }
}