package jnpf.bizcommon.audit.service.value;

import com.alibaba.fastjson.JSON;
import jnpf.bizcommon.audit.entity.model.AuditFieldDiffViewVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

/**
 * 按 JNPF dictionaryType 批量解析字典项；一次详情至多执行一条字典查询。
 *
 * <p>{@code @Order} 的含义见 {@link LimsQingyandanFieldValueResolver} 的类注释。
 */
@Slf4j
@Component
@Order(JnpfDictionaryFieldValueResolver.ORDER)
public class JnpfDictionaryFieldValueResolver implements AuditFieldValueResolver {

    /** 平台通用解析器，排在表专用（100）之后、用户兜底（300）之前。 */
    public static final int ORDER = 200;

    private static final String UNAVAILABLE = "名称暂不可用";

    private final DictionaryLookup lookup;

    @Autowired
    public JnpfDictionaryFieldValueResolver(JdbcTemplate jdbcTemplate) {
        this(new JdbcDictionaryLookup(jdbcTemplate));
    }

    JnpfDictionaryFieldValueResolver(DictionaryLookup lookup) {
        this.lookup = lookup;
    }

    @Override
    public boolean supports(String targetTable) {
        return true;
    }

    @Override
    public void resolve(AuditFieldValueContext context, List<AuditFieldDiffViewVO> fields) {
        if (context == null || blank(context.getTenantId()) || fields == null || fields.isEmpty()
                || context.getDictionaryTypes().isEmpty()) {
            return;
        }
        Set<String> dictionaryTypes = new LinkedHashSet<>();
        Set<String> values = new LinkedHashSet<>();
        for (AuditFieldDiffViewVO field : fields) {
            String dictionaryType = dictionaryType(context, field);
            if (dictionaryType == null || displaysResolved(field)) {
                continue;
            }
            dictionaryTypes.add(dictionaryType);
            values.addAll(parseValues(field.getOldData()));
            values.addAll(parseValues(field.getNewData()));
        }
        if (dictionaryTypes.isEmpty() || values.isEmpty()) {
            return;
        }

        Map<String, Map<String, String>> labels = lookup.labels(
                context.getTenantId().trim(), dictionaryTypes, values);
        for (AuditFieldDiffViewVO field : fields) {
            String dictionaryType = dictionaryType(context, field);
            Map<String, String> dictionary = dictionaryType == null
                    ? null : labels.get(dictionaryType);
            if (dictionary == null) {
                continue;
            }
            boolean multiple = "multiEnum".equals(field.getValueType())
                    || startsWithArray(field.getOldData()) || startsWithArray(field.getNewData());
            if (blank(field.getValueType())) {
                field.setValueType(multiple ? "multiEnum" : "enum");
            }
            if (field.getOldDisplay() == null) {
                field.setOldDisplay(display(field.getOldData(), dictionary));
            }
            if (field.getNewDisplay() == null) {
                field.setNewDisplay(display(field.getNewData(), dictionary));
            }
        }
    }

    private static String dictionaryType(AuditFieldValueContext context, AuditFieldDiffViewVO field) {
        if (field == null || blank(field.getField())) {
            return null;
        }
        return context.getDictionaryTypes().get(field.getField().trim().toLowerCase(Locale.ROOT));
    }

    private static boolean displaysResolved(AuditFieldDiffViewVO field) {
        return (blank(field.getOldData()) || field.getOldDisplay() != null)
                && (blank(field.getNewData()) || field.getNewDisplay() != null);
    }

    private static String display(String raw, Map<String, String> labels) {
        if (blank(raw)) {
            return "";
        }
        List<String> values = parseValues(raw);
        if (values.isEmpty()) {
            return UNAVAILABLE;
        }
        List<String> result = new ArrayList<>(values.size());
        for (String value : values) {
            String label = labels.get(value);
            result.add(blank(label) ? UNAVAILABLE : label);
        }
        return String.join("、", result);
    }

    @SuppressWarnings("unchecked")
    private static List<String> parseValues(String raw) {
        if (blank(raw)) {
            return Collections.emptyList();
        }
        String trimmed = raw.trim();
        if (!trimmed.startsWith("[")) {
            return Collections.singletonList(trimmed);
        }
        try {
            Object parsed = JSON.parse(trimmed);
            if (!(parsed instanceof Collection)) {
                return Collections.emptyList();
            }
            List<String> result = new ArrayList<>();
            for (Object value : (Collection<Object>) parsed) {
                if (value != null && !String.valueOf(value).trim().isEmpty()) {
                    result.add(String.valueOf(value).trim());
                }
            }
            return result;
        } catch (RuntimeException ignored) {
            return Collections.emptyList();
        }
    }

    private static boolean startsWithArray(String raw) {
        return raw != null && raw.trim().startsWith("[");
    }

    private static boolean blank(String value) {
        return value == null || value.trim().isEmpty();
    }

    interface DictionaryLookup {
        Map<String, Map<String, String>> labels(String tenantId, Set<String> dictionaryTypes,
                                                Set<String> values);
    }

    /** 表名和列名固定；dictionaryType、值和租户全部参数化。 */
    private static final class JdbcDictionaryLookup implements DictionaryLookup {
        private final NamedParameterJdbcTemplate jdbc;

        private JdbcDictionaryLookup(JdbcTemplate jdbcTemplate) {
            this.jdbc = new NamedParameterJdbcTemplate(jdbcTemplate);
        }

        @Override
        public Map<String, Map<String, String>> labels(
                String tenantId, Set<String> dictionaryTypes, Set<String> values) {
            try {
                MapSqlParameterSource params = new MapSqlParameterSource()
                        .addValue("dictionaryTypes", dictionaryTypes)
                        .addValue("values", values)
                        .addValue("tenantId", tenantId);
                List<Map<String, Object>> rows = jdbc.queryForList(
                        "SELECT t.f_id AS type_id, t.f_en_code AS type_code, "
                                + "d.f_id AS data_id, d.f_en_code AS data_code, d.f_full_name AS data_name "
                                + "FROM base_dictionary_data d "
                                + "JOIN base_dictionary_type t ON t.f_id = d.f_dictionary_type_id "
                                + "WHERE (t.f_id IN (:dictionaryTypes) OR t.f_en_code IN (:dictionaryTypes)) "
                                + "AND (d.f_id IN (:values) OR d.f_en_code IN (:values)) "
                                + "AND COALESCE(NULLIF(t.f_tenant_id, ''), '0') = :tenantId "
                                + "AND COALESCE(NULLIF(d.f_tenant_id, ''), '0') = :tenantId "
                                + "AND COALESCE(t.f_delete_mark, 0) = 0 "
                                + "AND COALESCE(d.f_delete_mark, 0) = 0",
                        params);
                Map<String, Map<String, String>> result = new LinkedHashMap<>();
                for (Map<String, Object> row : rows) {
                    String typeId = text(row.get("type_id"));
                    String typeCode = text(row.get("type_code"));
                    String dataId = text(row.get("data_id"));
                    String dataCode = text(row.get("data_code"));
                    String label = text(row.get("data_name"));
                    put(result, typeId, dataId, dataCode, label);
                    put(result, typeCode, dataId, dataCode, label);
                }
                return result;
            } catch (RuntimeException ex) {
                log.warn("[AUDIT-QUERY] JNPF 字典批量解析失败 typeCount={} valueCount={} err={}",
                        dictionaryTypes.size(), values.size(), ex.getClass().getSimpleName());
                return Collections.emptyMap();
            }
        }

        private static void put(Map<String, Map<String, String>> result, String type,
                                String dataId, String dataCode, String label) {
            if (type == null || label == null) {
                return;
            }
            Map<String, String> values = result.computeIfAbsent(type, key -> new LinkedHashMap<>());
            if (dataId != null) {
                values.put(dataId, label);
            }
            if (dataCode != null) {
                values.put(dataCode, label);
            }
        }

        private static String text(Object value) {
            if (value == null) {
                return null;
            }
            String result = String.valueOf(value).trim();
            return result.isEmpty() ? null : result;
        }
    }
}