package jnpf.bizcommon.audit.service.listener;

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

import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/** Regression checks for database-before/database-after Layer 0 diffs. */
public final class AuditL0PartialSnapshotProbe {

    private AuditL0PartialSnapshotProbe() {
    }

    public static void main(String[] args) {
        Map<String, Object> before = row(
                "yangpin_mingcheng", "旧名称",
                "beizhu", "待清空",
                "biz_sign", "old-sign",
                "f_version", "0",
                "child_table", "old-child");
        Map<String, Object> after = row(
                "yangpin_mingcheng", "红细胞",
                "jieshou_shuliang", "6",
                "biz_sign", "new-sign",
                "f_version", "1",
                "child_table", "new-child");
        Set<String> masked = new LinkedHashSet<String>(Collections.singletonList("biz_sign"));
        Set<String> childFields = new LinkedHashSet<String>(Collections.singletonList("child_table"));

        String diff = AuditVisualLogListener.databaseBoundaryDiff(
                before, after, masked, Collections.emptyMap(), childFields);
        List<Map<String, Object>> items = parse(diff);
        check("changed field", item(items, "yangpin_mingcheng", "旧名称", "红细胞", 1));
        check("new field is addition", item(items, "jieshou_shuliang", "", "6", 0));
        check("missing after field is clear", item(items, "beizhu", "待清空", "", 1));
        check("masked field compared without leaking values",
                item(items, "biz_sign", AuditFieldDiff.MASKED, AuditFieldDiff.MASKED, 1));
        check("technical field excluded", find(items, "f_version") == null);
        check("child field excluded", find(items, "child_table") == null);

        String unchanged = AuditVisualLogListener.databaseBoundaryDiff(
                row("name", "same"), row("name", "same"),
                Collections.emptySet(), Collections.emptyMap(), Collections.emptySet());
        check("unchanged row", parse(unchanged).isEmpty());
    }

    @SuppressWarnings("unchecked")
    private static List<Map<String, Object>> parse(String json) {
        return (List<Map<String, Object>>) (List<?>) JSON.parseArray(json, Map.class);
    }

    private static boolean item(List<Map<String, Object>> items, String field,
                                String oldData, String newData, int type) {
        Map<String, Object> item = find(items, field);
        return item != null
                && oldData.equals(String.valueOf(item.get("oldData")))
                && newData.equals(String.valueOf(item.get("newData")))
                && type == ((Number) item.get("type")).intValue();
    }

    private static Map<String, Object> find(List<Map<String, Object>> items, String field) {
        for (Map<String, Object> item : items) {
            if (field.equals(item.get("field"))) {
                return item;
            }
        }
        return null;
    }

    private static Map<String, Object> row(Object... values) {
        Map<String, Object> row = new LinkedHashMap<String, Object>();
        for (int i = 0; i < values.length; i += 2) {
            row.put(String.valueOf(values[i]), values[i + 1]);
        }
        return row;
    }

    private static void check(String label, boolean condition) {
        if (!condition) {
            throw new AssertionError(label);
        }
    }
}