package gudusoft.gsqlparser.util.json;

import gudusoft.gsqlparser.dlineage.util.BeanUtil;

import java.io.IOException;
import java.io.Serializable;
import java.io.Writer;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * Writes a map or a list as JSON, as a string or into a {@link Writer}. Both entry points share one
 * writer, so they produce the same text (Mantis 4799: two hand-copied paths had drifted apart).
 *
 * <p>A value is written by its type, wherever it sits (map value, list element, array element):
 * a {@code String} or {@code Character} as a string; a {@code Number} as a number, except that a
 * number with no JSON form, such as NaN or an infinity, becomes {@code null}; a
 * {@code Boolean} as {@code true} or {@code false}; a {@code Collection} or a Java array as an array;
 * anything else, a map or a bean, as an object through {@link BeanUtil#bean2Map(Object)}.
 * A {@code null} map value or element is left out, and with {@code ignoreId} every member named
 * {@code id} is left out.
 */
@SuppressWarnings("rawtypes")
public class JSONSerializer implements Serializable {

    private static final long serialVersionUID = -947149613761603468L;

    private static final Pattern JSON_NUMBER = Pattern.compile("-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?(?:[eE][+-]?[0-9]+)?");

    private boolean ignoreId = false;

    public JSONSerializer(boolean ignoreId) {
        this.ignoreId = ignoreId;
    }

    public JSONSerializer() {
    }

    private void check(Object obj) {
        if (obj == null || !(obj instanceof LinkedHashMap || obj instanceof List)) {
            throw new IllegalArgumentException("Invalid JSON structure");
        }
    }

    public String serialize(List list) {
        check(list);
        StringBuilder sb = new StringBuilder();
        try {
            writeArray(list, sb);
        } catch (IOException e) {
            throw new JSONException(e); // a StringBuilder does not throw
        }
        return sb.toString();
    }

    public String serialize(Map map) {
        check(map);
        StringBuilder sb = new StringBuilder();
        try {
            writeObject(map, sb);
        } catch (IOException e) {
            throw new JSONException(e); // a StringBuilder does not throw
        }
        return sb.toString();
    }

    public void serialize(Map map, Writer writer) throws IOException {
        check(map);
        writeObject(map, writer);
    }

    public void serialize(List list, Writer writer) throws IOException {
        check(list);
        writeArray(list, writer);
    }

    private void writeObject(Map map, Appendable out) throws IOException {
        out.append('{');
        boolean first = true;
        for (Object k : map.keySet()) {
            String key = (String) k;
            if (ignoreId && ("id".equals(key))) {
                continue;
            }
            Object val = map.get(key);
            if (val == null) {
                continue; // Skip null values
            }
            if (!first) {
                out.append(',');
            }
            first = false;
            // A key is escaped exactly like a string value: keys can be user data, such as the
            // lineage graph's tooltip map, keyed by node labels that keep their quotes (Mantis 4798).
            writeString(String.valueOf(key), out);
            out.append(':');
            writeValue(val, out);
        }
        out.append('}');
    }

    // The separator goes BEFORE each written element: a skipped null must not leave "a", in front
    // of the closing bracket (Mantis 4798).
    private void writeArray(Collection collection, Appendable out) throws IOException {
        out.append('[');
        boolean first = true;
        for (Object element : collection) {
            if (element == null) {
                continue; // Skip null values
            }
            if (!first) {
                out.append(',');
            }
            first = false;
            writeValue(element, out);
        }
        out.append(']');
    }

    private void writeJavaArray(Object array, Appendable out) throws IOException {
        out.append('[');
        boolean first = true;
        int n = Array.getLength(array);
        for (int i = 0; i < n; i++) {
            Object element = Array.get(array, i);
            if (element == null) {
                continue; // Skip null values
            }
            if (!first) {
                out.append(',');
            }
            first = false;
            writeValue(element, out);
        }
        out.append(']');
    }

    private void writeValue(Object val, Appendable out) throws IOException {
        if (val instanceof String || val instanceof Character) {
            writeString(val.toString(), out);
        } else if (val instanceof Number) {
            out.append(numberText((Number) val));
        } else if (val instanceof Boolean) {
            out.append(val.toString());
        } else if (val instanceof Collection) {
            writeArray((Collection) val, out);
        } else if (val.getClass().isArray()) {
            writeJavaArray(val, out);
        } else {
            writeObject(BeanUtil.bean2Map(val), out);
        }
    }

    /**
     * The JSON text of a number. NaN and the infinities have no JSON form; JSON.stringify and
     * fastjson write them as null, and so does any other number whose text is not a JSON number.
     */
    private static String numberText(Number number) {
        if (number instanceof Double || number instanceof Float) {
            double value = number.doubleValue();
            return Double.isNaN(value) || Double.isInfinite(value) ? "null" : number.toString();
        }
        String text = number.toString();
        if (number instanceof Integer || number instanceof Long || number instanceof Short
                || number instanceof Byte || number instanceof BigInteger || number instanceof BigDecimal) {
            return text;
        }
        // a DoubleAdder, a DoubleAccumulator or any other Number can hold NaN too
        return JSON_NUMBER.matcher(text).matches() ? text : "null";
    }

    private static void writeString(String str, Appendable out) throws IOException {
        out.append('"');
        int unwritten = 0;
        // An index loop, not a StringCharacterIterator: its DONE sentinel is U+FFFF, so a real
        // U+FFFF in the text cut the string short, and two keys differing after it collided.
        for (int i = 0; i < str.length(); i++) {
            String escaped = escapeOf(str.charAt(i));
            if (escaped != null) {
                out.append(str, unwritten, i).append(escaped);
                unwritten = i + 1;
            }
        }
        out.append(str, unwritten, str.length()).append('"');
    }

    /** The escape that stands for {@code ch} inside a JSON string, or null to write it as it is. */
    private static String escapeOf(char ch) {
        switch (ch) {
            case '"':
                return "\\\"";
            case '\\':
                return "\\\\";
            case '/':
                return "\\/";
            case '\b':
                return "\\b";
            case '\f':
                return "\\f";
            case '\n':
                return "\\n";
            case '\r':
                return "\\r";
            case '\t':
                return "\\t";
            default:
                // JSON allows no raw control character inside a string (RFC 8259, section 7)
                return ch < 0x20 ? String.format("\\u%04x", (int) ch) : null;
        }
    }
}