package jnpf.bizcommon.audit.service.support;

import com.alibaba.fastjson.JSON;
import jnpf.audit.diff.AuditFieldDiff;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

/** Removes fields hidden by the published form from persisted field diffs only. */
public final class AuditHiddenFieldDiffFilter {

    private AuditHiddenFieldDiffFilter() {
    }

    @SuppressWarnings("unchecked")
    public static String filter(String json, Map<String, AuditFieldDiff.FieldMeta> metadata) {
        if (json == null || json.trim().isEmpty()) {
            return json;
        }
        Object parsed;
        try {
            parsed = JSON.parse(json);
        } catch (RuntimeException ex) {
            return null;
        }
        if (!(parsed instanceof List)) {
            return null;
        }
        List<Object> visible = new ArrayList<>();
        for (Object raw : (List<?>) parsed) {
            if (!(raw instanceof Map)) {
                continue;
            }
            Map<String, Object> item = new LinkedHashMap<>((Map<String, Object>) raw);
            String field = string(item.get("field"));
            if (hidden(metadata, field)) {
                continue;
            }
            Object childFields = item.get("chidField");
            Object childData = item.get("chidData");
            if (childFields instanceof List && childData instanceof List) {
                List<Object> fields = new ArrayList<>();
                List<String> hiddenProps = new ArrayList<>();
                for (Object rawChild : (List<?>) childFields) {
                    if (!(rawChild instanceof Map)) {
                        continue;
                    }
                    String prop = string(((Map<?, ?>) rawChild).get("prop"));
                    if (hidden(metadata, prop)) {
                        hiddenProps.add(prop);
                    } else {
                        fields.add(rawChild);
                    }
                }
                if (fields.isEmpty()) {
                    continue;
                }
                List<Object> rows = new ArrayList<>();
                for (Object rawRow : (List<?>) childData) {
                    if (!(rawRow instanceof Map)) {
                        continue;
                    }
                    Map<String, Object> row = new LinkedHashMap<>((Map<String, Object>) rawRow);
                    for (String prop : hiddenProps) {
                        row.remove(prop);
                        row.remove("jnpf_old_" + prop);
                    }
                    boolean hasVisibleValue = false;
                    for (Object rawField : fields) {
                        String prop = string(((Map<?, ?>) rawField).get("prop"));
                        if (prop != null && (row.containsKey(prop)
                                || row.containsKey("jnpf_old_" + prop))) {
                            hasVisibleValue = true;
                            break;
                        }
                    }
                    if (hasVisibleValue) {
                        rows.add(row);
                    }
                }
                if (rows.isEmpty()) {
                    continue;
                }
                item.put("chidField", fields);
                item.put("chidData", rows);
            }
            visible.add(item);
        }
        return JSON.toJSONString(visible);
    }

    private static boolean hidden(Map<String, AuditFieldDiff.FieldMeta> metadata, String field) {
        if (metadata == null || field == null) {
            return false;
        }
        AuditFieldDiff.FieldMeta meta = metadata.get(field.toLowerCase(Locale.ROOT));
        return meta != null && Boolean.TRUE.equals(meta.hidden());
    }

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