package jnpf.limsService.print;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import jnpf.exception.DataException;
import jnpf.limsEntity.LimsJianyanXiangEntity;
import jnpf.limsEntity.LimsPrintTemplateEntity;
import jnpf.limsEntity.LimsQingyandanEntity;
import jnpf.limsEntity.LimsWendingxingKaocaJihuaEntity;
import jnpf.limsEntity.LimsWendingxingKaocaJihuaZhouqiEntity;
import jnpf.limsMapper.LimsJianyanXiangMapper;
import jnpf.limsMapper.LimsQingyandanMapper;
import jnpf.limsMapper.LimsWendingxingKaocaJihuaMapper;
import jnpf.limsMapper.LimsWendingxingKaocaJihuaZhouqiMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 稳定性考察汇总模板渲染器（template_id = wendingxing_kaoca_huizong）。
 */
@Component
public class WendingxingKaocaHuizongRenderer implements PrintTemplateRenderer {

    public static final String TEMPLATE_ID = "wendingxing_kaoca_huizong";
    private static final String EMPTY_RESULT = "/";

    @Autowired
    private LimsWendingxingKaocaJihuaMapper jihuaMapper;

    @Autowired
    private LimsWendingxingKaocaJihuaZhouqiMapper zhouqiMapper;

    @Autowired
    private LimsQingyandanMapper qingyandanMapper;

    @Autowired
    private LimsJianyanXiangMapper jianyanXiangMapper;

    @Autowired
    private ObjectMapper objectMapper;

    @Override
    public String getTemplateId() {
        return TEMPLATE_ID;
    }

    @Override
    public Map<String, Object> render(String baogaoId, LimsPrintTemplateEntity tpl) {
        if (baogaoId == null || baogaoId.trim().isEmpty()) {
            throw new DataException("缺少稳定性考察计划 id");
        }

        LimsWendingxingKaocaJihuaEntity jihua = selectJihua(baogaoId);
        if (jihua == null) {
            throw new DataException("稳定性考察计划不存在或已删除: " + baogaoId);
        }

        Map<String, Object> config = parseConfig(tpl);
        List<LimsWendingxingKaocaJihuaZhouqiEntity> cycles = selectCycles(baogaoId);
        Map<String, List<LimsQingyandanEntity>> qingyandanByCycle = selectQingyandan(baogaoId, cycles);
        Map<String, List<LimsJianyanXiangEntity>> itemsByQingyandan = selectItems(qingyandanByCycle);

        LinkedHashMap<String, String> periodLabels = buildPeriodLabels(cycles, config.get("zhouqiDanwei"));
        Map<String, Object> data = new LinkedHashMap<>();
        data.put("schemeName", jihua.getKaocaMingcheng());
        data.put("periods", new ArrayList<>(periodLabels.values()));
        data.put("reports", buildReports(cycles, periodLabels, qingyandanByCycle, itemsByQingyandan));
        return data;
    }

    private LimsWendingxingKaocaJihuaEntity selectJihua(String baogaoId) {
        QueryWrapper<LimsWendingxingKaocaJihuaEntity> query = new QueryWrapper<>();
        query.eq("f_id", baogaoId);
        query.and(w -> w.isNull("f_delete_mark").or().ne("f_delete_mark", 1));
        return jihuaMapper.selectOne(query);
    }

    /**
     *
     * 根据计划 ID 查询周期列表数据
     *
     * @param baogaoId
     * @return
     */
    private List<LimsWendingxingKaocaJihuaZhouqiEntity> selectCycles(String baogaoId) {
        QueryWrapper<LimsWendingxingKaocaJihuaZhouqiEntity> query = new QueryWrapper<>();
        query.eq("kaoca_jihua_id", baogaoId);
        query.and(w -> w.isNull("f_delete_mark").or().ne("f_delete_mark", 1));
        query.and(w -> w.isNull("shifou_jixu_zhixing").or().ne("shifou_jixu_zhixing", "no"));
        query.orderByAsc("jiahua_anpai_riqi", "f_id");
        return zhouqiMapper.selectList(query);
    }

    private Map<String, List<LimsQingyandanEntity>> selectQingyandan(
            String baogaoId, List<LimsWendingxingKaocaJihuaZhouqiEntity> cycles) {
        if (cycles.isEmpty()) {
            return Collections.emptyMap();
        }

        List<String> cycleIds = cycles.stream()
                .map(LimsWendingxingKaocaJihuaZhouqiEntity::getId)
                .collect(Collectors.toList());
        QueryWrapper<LimsQingyandanEntity> query = new QueryWrapper<>();
        query.eq("wendingxing_jilu_id", baogaoId);
        query.in("wendingxing_zhouqi_id", cycleIds);
        query.and(w -> w.isNull("f_delete_mark").or().ne("f_delete_mark", 1));
        query.orderByAsc("f_id");

        Map<String, List<LimsQingyandanEntity>> result = new HashMap<>();
        for (LimsQingyandanEntity row : qingyandanMapper.selectList(query)) {
            result.computeIfAbsent(row.getWendingxingZhouqiId(), key -> new ArrayList<>()).add(row);
        }
        return result;
    }

    private Map<String, List<LimsJianyanXiangEntity>> selectItems(
            Map<String, List<LimsQingyandanEntity>> qingyandanByCycle) {
        List<String> qingyandanIds = qingyandanByCycle.values().stream()
                .flatMap(List::stream)
                .map(LimsQingyandanEntity::getId)
                .collect(Collectors.toList());
        if (qingyandanIds.isEmpty()) {
            return Collections.emptyMap();
        }

        QueryWrapper<LimsJianyanXiangEntity> query = new QueryWrapper<>();
        query.in("qingyandan_id", qingyandanIds);
        query.and(w -> w.isNull("f_delete_mark").or().ne("f_delete_mark", 1));
        query.orderByAsc("f_id");

        Map<String, List<LimsJianyanXiangEntity>> result = new HashMap<>();
        for (LimsJianyanXiangEntity row : jianyanXiangMapper.selectList(query)) {
            result.computeIfAbsent(row.getQingyandanId(), key -> new ArrayList<>()).add(row);
        }
        return result;
    }

    private LinkedHashMap<String, String> buildPeriodLabels(
            List<LimsWendingxingKaocaJihuaZhouqiEntity> cycles, Object unitConfig) {
        LinkedHashMap<String, String> result = new LinkedHashMap<>();
        for (LimsWendingxingKaocaJihuaZhouqiEntity cycle : cycles) {
            String key = periodKey(cycle);
            result.putIfAbsent(key, formatNumber(cycle.getZhouqi())
                    + resolveUnit(cycle.getZhouqiDanwei(), unitConfig));
        }
        return result;
    }

    private List<Map<String, Object>> buildReports(
            List<LimsWendingxingKaocaJihuaZhouqiEntity> cycles,
            LinkedHashMap<String, String> periodLabels,
            Map<String, List<LimsQingyandanEntity>> qingyandanByCycle,
            Map<String, List<LimsJianyanXiangEntity>> itemsByQingyandan) {
        LinkedHashMap<String, List<LimsWendingxingKaocaJihuaZhouqiEntity>> cyclesByBatch =
                new LinkedHashMap<>();
        for (LimsWendingxingKaocaJihuaZhouqiEntity cycle : cycles) {
            cyclesByBatch.computeIfAbsent(valueOrEmpty(cycle.getPihao()), key -> new ArrayList<>())
                    .add(cycle);
        }

        List<Map<String, Object>> reports = new ArrayList<>();
        for (Map.Entry<String, List<LimsWendingxingKaocaJihuaZhouqiEntity>> batch
                : cyclesByBatch.entrySet()) {
            LinkedHashMap<String, ReportRow> rows = new LinkedHashMap<>();
            for (LimsWendingxingKaocaJihuaZhouqiEntity cycle : batch.getValue()) {
                String periodKey = periodKey(cycle);
                for (LimsQingyandanEntity qingyandan
                        : qingyandanByCycle.getOrDefault(cycle.getId(), Collections.emptyList())) {
                    for (LimsJianyanXiangEntity item
                            : itemsByQingyandan.getOrDefault(qingyandan.getId(), Collections.emptyList())) {
                        String rowKey = valueOrEmpty(item.getJianyanXiangmuMingcheng()) + "\u0000"
                                + valueOrEmpty(item.getBiaozhunGuiding());
                        String standard = resultOrSlash(item.getBiaozhunGuiding());
                        String value = resultOrSlash(item.getJianyanJieguo());
                        if ("数值".equals(item.getShujuLeixing())) {
                            value += item.getFenjianDanwei();
                            standard += item.getFenjianDanwei();
                        }
                        String finalStandard = standard;
                        ReportRow row = rows.computeIfAbsent(rowKey,
                                key -> new ReportRow(item.getJianyanXiangmuMingcheng(), finalStandard));
                        if (!row.values.containsKey(periodKey)
                                || EMPTY_RESULT.equals(row.values.get(periodKey))) {
                            row.values.put(periodKey, value);
                        }
                    }
                }
            }

            List<Map<String, Object>> reportRows = new ArrayList<>();
            for (ReportRow source : rows.values()) {
                Map<String, Object> row = new LinkedHashMap<>();
                row.put("item", source.item);
                row.put("standard", source.standard);
                List<String> values = periodLabels.keySet().stream()
                        .map(key -> source.values.getOrDefault(key, EMPTY_RESULT))
                        .collect(Collectors.toList());
                row.put("values", values);
                reportRows.add(row);
            }

            Map<String, Object> report = new LinkedHashMap<>();
            report.put("batchNo", batch.getKey());
            report.put("rows", reportRows);
            reports.add(report);
        }
        return reports;
    }

    private Map<String, Object> parseConfig(LimsPrintTemplateEntity tpl) {
        if (tpl == null || tpl.getConfig() == null || tpl.getConfig().trim().isEmpty()) {
            return Collections.emptyMap();
        }
        try {
            return objectMapper.readValue(tpl.getConfig(), new TypeReference<Map<String, Object>>() { });
        } catch (Exception e) {
            throw new DataException("打印模板 config JSON 解析失败: " + e.getMessage());
        }
    }

    @SuppressWarnings("unchecked")
    private String resolveUnit(String code, Object config) {
        String source = valueOrEmpty(code);
        if (config instanceof Map) {
            Object configured = ((Map<String, Object>) config).get(source);
            return labelOf(configured, source);
        }
        if (config instanceof List) {
            for (Object entry : (List<?>) config) {
                if (!(entry instanceof Map)) {
                    continue;
                }
                Map<String, Object> option = (Map<String, Object>) entry;
                String value = firstString(option, "value", "id", "code", "enCode");
                if (source.equals(value)) {
                    return firstNonEmpty(firstString(option, "label", "name", "fullName", "text"), source);
                }
            }
        }
        return source;
    }

    @SuppressWarnings("unchecked")
    private String labelOf(Object configured, String fallback) {
        if (configured instanceof Map) {
            return firstNonEmpty(firstString((Map<String, Object>) configured,
                    "label", "name", "fullName", "text", "value"), fallback);
        }
        return configured == null ? fallback : configured.toString();
    }

    private String firstString(Map<String, Object> values, String... keys) {
        for (String key : keys) {
            Object value = values.get(key);
            if (value != null && !value.toString().trim().isEmpty()) {
                return value.toString();
            }
        }
        return "";
    }

    private String periodKey(LimsWendingxingKaocaJihuaZhouqiEntity cycle) {
        return formatNumber(cycle.getZhouqi()) + "\u0000" + valueOrEmpty(cycle.getZhouqiDanwei());
    }

    private String formatNumber(BigDecimal value) {
        return value == null ? "" : value.stripTrailingZeros().toPlainString();
    }

    private String resultOrSlash(String value) {
        return value == null || value.trim().isEmpty() ? EMPTY_RESULT : value;
    }

    private String firstNonEmpty(String value, String fallback) {
        return value == null || value.trim().isEmpty() ? fallback : value;
    }

    private String valueOrEmpty(String value) {
        return value == null ? "" : value;
    }

    private static final class ReportRow {
        private final String item;
        private final String standard;
        private final Map<String, String> values = new HashMap<>();

        private ReportRow(String item, String standard) {
            this.item = item;
            this.standard = standard;
        }
    }
}