package jnpf.flowable.util;

import jnpf.util.JsonUtil;

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

/** Renders the selected audit fields of the current form for a flow notification. */
final class FlowAuditTitleUtil {

    interface ValueResolver {
        String resolve(Map<String, Object> field, Map<String, Object> config, Object value, Map<String, Object> row);
    }

    private static final int MAX_SUFFIX_LENGTH = 200;

    private FlowAuditTitleUtil() {
    }

    static String append(String title, String suffix) {
        if (title == null || title.trim().isEmpty() || suffix == null || suffix.trim().isEmpty()
                || title.endsWith("/" + suffix)) {
            return title;
        }
        return title + "/" + suffix;
    }

    static String suffix(String formDataJson, Map<String, Object> data) {
        return suffix(formDataJson, data, (field, config, value, row) -> display(value));
    }

    static String suffix(String formDataJson, Map<String, Object> data, ValueResolver resolver) {
        if (formDataJson == null || data == null || data.isEmpty()) {
            return null;
        }
        try {
            Map<String, Object> form = JsonUtil.stringToMap(formDataJson);
            if (form == null) {
                return null;
            }
            List<String> values = new ArrayList<>();
            collect(list(form.get("fields")), data, values, resolver);
            if (values.isEmpty()) {
                return null;
            }
            String suffix = String.join("/", values);
            return suffix.length() > MAX_SUFFIX_LENGTH ? suffix.substring(0, MAX_SUFFIX_LENGTH) : suffix;
        } catch (RuntimeException ignored) {
            return null;
        }
    }

    @SuppressWarnings("unchecked")
    private static void collect(List<?> fields, Map<String, Object> row, List<String> values,
                                ValueResolver resolver) {
        for (Object raw : fields) {
            if (!(raw instanceof Map)) {
                continue;
            }
            Map<String, Object> field = (Map<String, Object>) raw;
            Object rawConfig = field.containsKey("config") ? field.get("config") : field.get("__config__");
            if (!(rawConfig instanceof Map)) {
                continue;
            }
            Map<String, Object> config = (Map<String, Object>) rawConfig;
            List<?> children = list(config.get("children"));
            if ("table".equals(config.get("jnpfKey"))) {
                Object tableData = value(row, model(field));
                List<?> rows = list(tableData);
                // A configured child table contributes values from its actual first row only.
                if (!rows.isEmpty() && rows.get(0) instanceof Map) {
                    collect(children, (Map<String, Object>) rows.get(0), values, resolver);
                }
                continue;
            }
            String model = model(field);
            if (model != null && Boolean.parseBoolean(String.valueOf(config.get("biz_log_enabled")))
                    && !sensitive(model, config)) {
                String display;
                try {
                    display = resolver.resolve(field, config, value(row, model), row);
                } catch (RuntimeException ignored) {
                    display = null;
                }
                if (display != null) {
                    values.add(display);
                }
            }
            if (!children.isEmpty()) {
                collect(children, row, values, resolver);
            }
        }
    }

    private static String model(Map<String, Object> field) {
        Object raw = field.containsKey("vModel") ? field.get("vModel") : field.get("__vModel__");
        return raw == null || String.valueOf(raw).trim().isEmpty() ? null : String.valueOf(raw).trim();
    }

    private static Object value(Map<String, Object> row, String model) {
        if (model == null) {
            return null;
        }
        Object direct = row.get(model);
        if (direct != null) {
            return direct;
        }
        for (Map.Entry<String, Object> entry : row.entrySet()) {
            if (entry.getKey() != null && model.equalsIgnoreCase(entry.getKey())) {
                return entry.getValue();
            }
        }
        return null;
    }

    static String display(Object raw) {
        if (raw == null || raw instanceof Map) {
            return null;
        }
        if (raw instanceof List) {
            List<String> parts = new ArrayList<>();
            for (Object item : (List<?>) raw) {
                if (item != null && !(item instanceof Map) && !String.valueOf(item).trim().isEmpty()) {
                    parts.add(String.valueOf(item).trim());
                }
            }
            return parts.isEmpty() ? null : String.join(",", parts);
        }
        String value = String.valueOf(raw).trim();
        return value.isEmpty() || "***".equals(value) ? null : value;
    }

    private static boolean sensitive(String model, Map<String, Object> config) {
        String name = model.toLowerCase(Locale.ROOT);
        String key = String.valueOf(config.get("jnpfKey")).toLowerCase(Locale.ROOT);
        return name.equals("biz_sign") || name.equals("bizsign") || name.equals("sign_id")
                || name.equals("signid") || name.endsWith("sign") || name.endsWith("signid")
                || name.contains("password") || name.contains("mima") || key.contains("password")
                || key.contains("signature");
    }

    @SuppressWarnings("unchecked")
    private static List<?> list(Object raw) {
        if (raw instanceof List) {
            return (List<?>) raw;
        }
        if (raw instanceof String && !((String) raw).trim().isEmpty()) {
            List<?> parsed = JsonUtil.getJsonToList((String) raw, Map.class);
            return parsed == null ? Collections.emptyList() : parsed;
        }
        return Collections.emptyList();
    }
}