package jnpf.bizcommon.audit.service;

import com.alibaba.fastjson.JSON;
import jnpf.bizcommon.audit.entity.AuditEventEntity;
import jnpf.audit.diff.AuditFieldDiff;
import jnpf.bizcommon.audit.entity.model.AuditFieldDiffViewVO;
import jnpf.bizcommon.audit.service.support.AuditQueryResponseSanitizer;
import jnpf.bizcommon.audit.service.value.AuditFieldValueContext;
import jnpf.bizcommon.audit.service.value.AuditFieldValueResolver;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

/** 将兼容字符串 fieldDiffs 装配成结构化、可展示且可脱敏的字段变更。 */
@Service
@Slf4j
public class AuditFieldDiffViewService {

    private final List<AuditFieldValueResolver> resolvers;
    private final ZoneId businessZone;

    @Autowired
    public AuditFieldDiffViewService(
            List<AuditFieldValueResolver> resolvers,
            @Value("${audit.query.business-time-zone:Asia/Shanghai}") String businessTimeZone) {
        this.resolvers = resolvers == null ? Collections.emptyList() : new ArrayList<>(resolvers);
        this.businessZone = parseZone(businessTimeZone);
    }

    /**
     * sanitizedFieldDiffs 已由查询脱敏器过滤无意义项并处理凭证引用，原始事件不会被修改。
     */
    @SuppressWarnings("unchecked")
    public List<AuditFieldDiffViewVO> build(AuditEventEntity event,
                                             String sanitizedFieldDiffs,
                                             Map<String, AuditFieldDiff.FieldMeta> currentMetadata) {
        if (sanitizedFieldDiffs == null || sanitizedFieldDiffs.trim().isEmpty()) {
            return Collections.emptyList();
        }
        Object parsed;
        try {
            parsed = JSON.parse(sanitizedFieldDiffs);
        } catch (Throwable ignored) {
            return Collections.emptyList();
        }
        if (!(parsed instanceof List)) {
            return Collections.emptyList();
        }

        List<AuditFieldDiffViewVO> views = new ArrayList<>();
        Map<String, String> dictionaryTypes = new LinkedHashMap<>();
        for (Object raw : (List<?>) parsed) {
            if (!(raw instanceof Map)) {
                continue;
            }
            Map<String, Object> item = (Map<String, Object>) raw;
            AuditFieldDiffViewVO view = toView(item,
                    currentMetadata, event == null ? null : event.getActionCode());
            if (view != null) {
                views.add(view);
                AuditFieldDiff.FieldMeta meta = metadata(currentMetadata, view.getField());
                String dictionaryType = firstText(item.get("dictionaryType"),
                        meta == null ? null : meta.dictionaryType());
                if (dictionaryType != null) {
                    dictionaryTypes.put(view.getField().toLowerCase(Locale.ROOT), dictionaryType);
                }
            }
        }

        AuditFieldValueContext context = new AuditFieldValueContext(
                event == null ? null : event.getTargetTable(),
                event == null ? null : event.getTenantId(),
                event == null ? null : event.getEventTime(),
                dictionaryTypes);
        List<AuditFieldDiffViewVO> resolvedViews = views;
        for (AuditFieldValueResolver resolver : resolvers) {
            if (resolver != null) {
                try {
                    if (!resolver.supports(context.getTargetTable())) {
                        continue;
                    }
                    List<AuditFieldDiffViewVO> candidate = copyViews(resolvedViews);
                    resolver.resolve(context, candidate);
                    resolvedViews = candidate;
                } catch (RuntimeException ex) {
                    // 解析失败只能降级当前 resolver，日志不携带字段值或详情正文。
                    log.warn("[AUDIT-QUERY] 字段值解析器失败 resolver={} err={}",
                            resolver.getClass().getSimpleName(), ex.getClass().getSimpleName());
                }
            }
        }
        for (AuditFieldDiffViewVO view : resolvedViews) {
            finishDisplay(view);
        }
        return resolvedViews;
    }

    /**
     * 为新事件固化可可靠解析的类型和展示值，同时保留旧 field_diffs 的 type/jnpfKey 等键。
     * 解析失败时原样返回，不能因为展示增强造成 Layer 0 事件丢失。
     */
    @SuppressWarnings("unchecked")
    public String enrichForPersistence(AuditEventEntity event,
                                       String fieldDiffs,
                                       Map<String, AuditFieldDiff.FieldMeta> metadata) {
        if (fieldDiffs == null || fieldDiffs.trim().isEmpty()) {
            return fieldDiffs;
        }
        try {
            Object parsed = JSON.parse(fieldDiffs);
            if (!(parsed instanceof List)) {
                return fieldDiffs;
            }
            List<AuditFieldDiffViewVO> views = build(event, fieldDiffs, metadata);
            Map<String, AuditFieldDiffViewVO> byField = new LinkedHashMap<>();
            for (AuditFieldDiffViewVO view : views) {
                if (view.getField() != null) {
                    byField.put(view.getField().toLowerCase(Locale.ROOT), view);
                }
            }
            for (Object raw : (List<?>) parsed) {
                if (!(raw instanceof Map)) {
                    continue;
                }
                Map<String, Object> item = (Map<String, Object>) raw;
                String field = text(item.get("field"));
                AuditFieldDiffViewVO view = field == null
                        ? null : byField.get(field.toLowerCase(Locale.ROOT));
                if (view == null) {
                    continue;
                }
                putIfMissing(item, "valueType", view.getValueType());
                putIfMissing(item, "componentType", view.getComponentType());
                if (Boolean.TRUE.equals(view.getMasked())) {
                    item.put("masked", true);
                    item.put("valueType", "masked");
                    item.put("componentType", "sign");
                    if (item.containsKey("oldData")) {
                        item.put("oldData", AuditFieldDiff.MASKED);
                    }
                    if (item.containsKey("newData")) {
                        item.put("newData", AuditFieldDiff.MASKED);
                    }
                    item.remove("oldDisplay");
                    item.remove("newDisplay");
                    continue;
                }
                if (Boolean.TRUE.equals(view.getTechnical())) {
                    item.put("technical", true);
                }
                if (snapshotDisplayType(view.getValueType())) {
                    putDisplayIfResolved(item, "oldDisplay", view.getOldDisplay());
                    putDisplayIfResolved(item, "newDisplay", view.getNewDisplay());
                }
            }
            return JSON.toJSONString(parsed);
        } catch (Throwable ex) {
            log.warn("[AUDIT-L0] 字段展示快照固化失败 err={}", ex.getClass().getSimpleName());
            return fieldDiffs;
        }
    }

    private AuditFieldDiffViewVO toView(Map<String, Object> item,
                                        Map<String, AuditFieldDiff.FieldMeta> currentMetadata,
                                        String actionCode) {
        String field = text(item.get("field"));
        if (field == null) {
            return null;
        }
        AuditFieldDiff.FieldMeta meta = metadata(currentMetadata, field);
        boolean credential = AuditQueryResponseSanitizer.isCredentialReference(field, item, meta);
        boolean masked = credential
                || AuditFieldDiff.MASKED.equals(text(item.get("oldData")))
                || AuditFieldDiff.MASKED.equals(text(item.get("newData")));

        AuditFieldDiffViewVO view = new AuditFieldDiffViewVO();
        view.setField(field);
        view.setTargetTable(text(item.get("targetTable")));
        view.setFieldName(credential ? "电子签名" : fieldName(item, meta));
        view.setChangeType(changeType(item, actionCode, masked));
        String componentType = credential ? "sign" : firstText(item.get("componentType"),
                item.get("jnpfKey"), meta == null ? null : meta.componentType());
        String valueType = masked ? "masked" : firstText(item.get("valueType"),
                meta == null ? null : meta.valueType());
        if (valueType == null && isTemporalComponent(componentType)) {
            valueType = inferValueType(componentType);
        }
        view.setValueType(valueType);
        view.setComponentType(componentType);
        view.setJnpfKey(firstText(item.get("jnpfKey"), componentType));
        view.setNameModified(bool(item.get("nameModified")));
        view.setType(integer(item.get("type")));
        view.setChidData(mapList(item.get("chidData")));
        view.setChidField(mapList(item.get("chidField")));
        view.setMasked(masked);
        view.setTechnical(bool(item.get("technical")));
        if (masked) {
            view.setOldData(null);
            view.setNewData(null);
            view.setOldDisplay(null);
            view.setNewDisplay(null);
            return view;
        }

        String oldData = rawText(item.get("oldData"));
        String newData = rawText(item.get("newData"));
        view.setOldData(oldData);
        view.setNewData(newData);
        view.setOldDisplay(firstTextPreserveEmpty(item.get("oldDisplay"), optionDisplay(meta, oldData),
                temporalDisplay(view.getValueType(), item, meta, oldData)));
        view.setNewDisplay(firstTextPreserveEmpty(item.get("newDisplay"), optionDisplay(meta, newData),
                temporalDisplay(view.getValueType(), item, meta, newData)));
        return view;
    }

    private void finishDisplay(AuditFieldDiffViewVO view) {
        if (Boolean.TRUE.equals(view.getMasked())) {
            return;
        }
        if (view.getValueType() == null) {
            view.setValueType(inferValueType(view.getComponentType()));
        }
        if (view.getComponentType() == null) {
            view.setComponentType("input");
        }
        view.setOldDisplay(fallbackDisplay(view.getValueType(), view.getOldData(), view.getOldDisplay()));
        view.setNewDisplay(fallbackDisplay(view.getValueType(), view.getNewData(), view.getNewDisplay()));
        if (view.getTechnical() == null) {
            view.setTechnical(Boolean.FALSE);
        }
        if (view.getMasked() == null) {
            view.setMasked(Boolean.FALSE);
        }
    }

    private String fallbackDisplay(String valueType, String raw, String display) {
        if (display != null) {
            return display;
        }
        if (raw == null || raw.trim().isEmpty()) {
            return "";
        }
        if ("reference".equals(valueType) || "multiReference".equals(valueType)
                || "enum".equals(valueType) || "multiEnum".equals(valueType)) {
            return "名称暂不可用";
        }
        return raw;
    }

    private String temporalDisplay(String valueType, Map<String, Object> item,
                                   AuditFieldDiff.FieldMeta meta, String raw) {
        if (!("date".equals(valueType) || "datetime".equals(valueType))
                || raw == null || raw.trim().isEmpty()) {
            return null;
        }
        try {
            long epochMillis = Long.parseLong(raw.trim());
            String pattern = firstText(item.get("format"), meta == null ? null : meta.format(),
                    "date".equals(valueType) ? "yyyy-MM-dd" : "yyyy-MM-dd HH:mm:ss");
            return DateTimeFormatter.ofPattern(pattern, Locale.ROOT)
                    .withZone(businessZone).format(Instant.ofEpochMilli(epochMillis));
        } catch (RuntimeException ignored) {
            return null;
        }
    }

    private static String optionDisplay(AuditFieldDiff.FieldMeta meta, String raw) {
        return meta == null ? null : meta.optionDisplay(raw);
    }

    private static boolean snapshotDisplayType(String valueType) {
        return "enum".equals(valueType) || "multiEnum".equals(valueType)
                || "reference".equals(valueType) || "multiReference".equals(valueType)
                || "date".equals(valueType) || "datetime".equals(valueType);
    }

    private static void putIfMissing(Map<String, Object> item, String key, String value) {
        if (!item.containsKey(key) && value != null) {
            item.put(key, value);
        }
    }

    private static void putDisplayIfResolved(Map<String, Object> item, String key, String display) {
        if (!item.containsKey(key) && display != null && !display.trim().isEmpty()
                && !"名称暂不可用".equals(display)) {
            item.put(key, display);
        }
    }

    private static AuditFieldDiff.FieldMeta metadata(
            Map<String, AuditFieldDiff.FieldMeta> metadata, String field) {
        if (metadata == null || field == null) {
            return null;
        }
        AuditFieldDiff.FieldMeta exact = metadata.get(field);
        if (exact != null) {
            return exact;
        }
        AuditFieldDiff.FieldMeta normalized = metadata.get(field.toLowerCase(Locale.ROOT));
        if (normalized != null) {
            return normalized;
        }
        StringBuilder snake = new StringBuilder(field.length() + 8);
        for (int i = 0; i < field.length(); i++) {
            char ch = field.charAt(i);
            if (Character.isUpperCase(ch)) {
                snake.append('_').append(Character.toLowerCase(ch));
            } else {
                snake.append(Character.toLowerCase(ch));
            }
        }
        return metadata.get(snake.toString());
    }

    private static String fieldName(Map<String, Object> item, AuditFieldDiff.FieldMeta meta) {
        String name = text(item.get("fieldName"));
        if (name != null) {
            return name;
        }
        return meta != null && meta.label() != null && !meta.label().trim().isEmpty()
                ? meta.label() : text(item.get("field"));
    }

    private static String changeType(Map<String, Object> item, String actionCode, boolean masked) {
        if (masked) {
            return "updated";
        }
        String explicit = text(item.get("changeType"));
        if ("created".equals(explicit) || "updated".equals(explicit) || "deleted".equals(explicit)) {
            return explicit;
        }
        if (actionCode != null && actionCode.toUpperCase(Locale.ROOT).contains("DELETE")) {
            return "deleted";
        }
        Object type = item.get("type");
        return type != null && "0".equals(String.valueOf(type)) ? "created" : "updated";
    }

    private static String inferValueType(String component) {
        if (component == null) {
            return "text";
        }
        String key = component.toLowerCase(Locale.ROOT);
        if (key.contains("time")) {
            return "datetime";
        }
        if (key.contains("date")) {
            return "date";
        }
        if (key.contains("number") || "slider".equals(key) || "rate".equals(key)) {
            return "number";
        }
        if ("switch".equals(key)) {
            return "boolean";
        }
        if ("checkbox".equals(key)) {
            return "multiEnum";
        }
        if (key.contains("select") || "radio".equals(key)) {
            return "enum";
        }
        if ("table".equals(key) || key.contains("upload")) {
            return "json";
        }
        return "text";
    }

    private static boolean isTemporalComponent(String component) {
        if (component == null) {
            return false;
        }
        String key = component.toLowerCase(Locale.ROOT);
        return key.contains("date") || key.contains("time");
    }

    private static List<AuditFieldDiffViewVO> copyViews(List<AuditFieldDiffViewVO> source) {
        List<AuditFieldDiffViewVO> copy = new ArrayList<>(source.size());
        for (AuditFieldDiffViewVO value : source) {
            AuditFieldDiffViewVO item = new AuditFieldDiffViewVO();
            item.setField(value.getField());
            item.setTargetTable(value.getTargetTable());
            item.setFieldName(value.getFieldName());
            item.setChangeType(value.getChangeType());
            item.setValueType(value.getValueType());
            item.setComponentType(value.getComponentType());
            item.setJnpfKey(value.getJnpfKey());
            item.setNameModified(value.getNameModified());
            item.setType(value.getType());
            item.setChidData(value.getChidData());
            item.setChidField(value.getChidField());
            item.setOldData(value.getOldData());
            item.setNewData(value.getNewData());
            item.setOldDisplay(value.getOldDisplay());
            item.setNewDisplay(value.getNewDisplay());
            item.setMasked(value.getMasked());
            item.setTechnical(value.getTechnical());
            copy.add(item);
        }
        return copy;
    }

    private static ZoneId parseZone(String zone) {
        try {
            return ZoneId.of(zone == null || zone.trim().isEmpty() ? "Asia/Shanghai" : zone.trim());
        } catch (RuntimeException ignored) {
            return ZoneId.of("Asia/Shanghai");
        }
    }

    private static boolean bool(Object value) {
        return value instanceof Boolean ? (Boolean) value
                : value != null && "true".equalsIgnoreCase(String.valueOf(value));
    }

    private static Integer integer(Object value) {
        if (value instanceof Number) {
            return ((Number) value).intValue();
        }
        try {
            return value == null ? null : Integer.valueOf(String.valueOf(value));
        } catch (NumberFormatException ignored) {
            return null;
        }
    }

    @SuppressWarnings("unchecked")
    private static List<Map<String, Object>> mapList(Object value) {
        if (!(value instanceof List)) {
            return null;
        }
        List<Map<String, Object>> result = new ArrayList<>();
        for (Object item : (List<?>) value) {
            if (item instanceof Map) {
                result.add(new LinkedHashMap<>((Map<String, Object>) item));
            }
        }
        return result.isEmpty() ? null : result;
    }

    private static String rawText(Object value) {
        return value == null ? "" : String.valueOf(value);
    }

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

    private static String firstText(Object... values) {
        if (values != null) {
            for (Object value : values) {
                String result = text(value);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }

    private static String firstTextPreserveEmpty(Object... values) {
        if (values != null) {
            for (Object value : values) {
                if (value != null) {
                    return String.valueOf(value);
                }
            }
        }
        return null;
    }
}