package gudusoft.gsqlparser.lineage.v2.model;

import gudusoft.gsqlparser.lineage.v2.json.CanonicalJson;
import gudusoft.gsqlparser.lineage.v2.validation.DocumentIndex;

import java.math.BigInteger;
import java.util.AbstractList;
import java.util.AbstractMap;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Deque;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.RandomAccess;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * An object of a lineage document: its members as JSON values, with typed accessors in each generated subclass.
 *
 * <p><b>Values.</b> A member holds a JSON value: a {@code Map} with string keys, a {@code List}, a {@code String}, a
 * {@code Long} (or a {@code BigInteger} outside the range of {@code long}), a {@code Boolean}, or JSON null. Integers
 * given as {@code Integer}, {@code Short}, {@code Byte} or a {@code BigInteger} that fits are stored as {@code Long},
 * so two objects with the same JSON are equal however they were built. Every member is kept, including members the
 * model does not type (extensions, module content, members of a later minor version): reading a document and
 * writing it again loses nothing.</p>
 *
 * <p><b>Absence and null.</b> A typed getter returns null when the member is absent and throws
 * {@link IllegalStateException} when the member holds JSON of another type, JSON null included. A getter typed
 * {@code Object} (any JSON value) returns {@link #JSON_NULL} for a member that is present with JSON null. A builder
 * setter given null removes the member; given {@link #JSON_NULL} it sets JSON null.</p>
 *
 * <p><b>Immutability and cost.</b> Objects are immutable and thread-safe; a {@link Builder} makes a changed copy.
 * Values are frozen once, without recursion, so any depth the strict reader accepts is supported. A typed getter
 * computes its view once and returns the same object afterwards. Equality compares the canonical JSON
 * (RFC 8785) of the members.</p>
 *
 * <p>The model checks shapes only when a typed accessor reads a member; it does not validate. Use
 * {@link gudusoft.gsqlparser.lineage.v2.validation.LineageValidator} for that.</p>
 *
 * @since 4.2.17
 */
public abstract class SqllrObject {

    /** JSON null as a member value, distinct from an absent member; see the class description. */
    public static final Object JSON_NULL = new Object() {
        @Override
        public String toString() {
            return "null";
        }
    };

    /** Converts one JSON value to a typed value. */
    public interface Reader<T> {
        T read(Object json);
    }

    private static final Object NO_VALUE = new Object();

    private final Map<String, Object> members;
    private final ConcurrentHashMap<String, Object> views = new ConcurrentHashMap<String, Object>();
    private volatile String canonical;

    protected SqllrObject(Map<String, Object> members) {
        this.members = members;
    }

    /** The members of a JSON object as frozen JSON values (a frozen tree is used as it is, not copied). */
    @SuppressWarnings("unchecked")
    protected static Map<String, Object> members(Object json, String type) {
        if (json instanceof SqllrObject) {
            return ((SqllrObject) json).members;
        }
        if (!(json instanceof Map<?, ?>)) {
            throw new IllegalArgumentException(type + ": expected a JSON object, got " + describe(json));
        }
        return (Map<String, Object>) freeze(json);
    }

    private static String describe(Object json) {
        return json == null || json == JSON_NULL ? "null" : json.getClass().getSimpleName();
    }

    /** The raw JSON value of a member: null when absent or JSON null (see {@link #has}). */
    public final Object get(String member) {
        return members.get(member);
    }

    public final boolean has(String member) {
        return members.containsKey(member);
    }

    /** The members as a frozen JSON object, in the order they were set. */
    public final Map<String, Object> toJson() {
        return members;
    }

    private IllegalStateException wrongType(String member, String expected, Throwable cause) {
        IllegalStateException e = new IllegalStateException(getClass().getSimpleName() + "." + member + " is not "
                + expected + ": " + describe(members.get(member)) + (cause == null ? "" : " (" + cause.getMessage() + ")"));
        if (cause != null) {
            e.initCause(cause);
        }
        return e;
    }

    @SuppressWarnings("unchecked")
    private <T> T view(String member, String expected, Reader<T> reader) {
        Object cached = views.get(member);
        if (cached != null) {
            return cached == NO_VALUE ? null : (T) cached;
        }
        T value;
        if (!members.containsKey(member)) {
            value = null;
        } else if (members.get(member) == null) {
            throw wrongType(member, expected, null);
        } else {
            try {
                value = reader.read(members.get(member));
            } catch (IllegalArgumentException e) {
                throw wrongType(member, expected, e);
            } catch (IllegalStateException e) {
                throw wrongType(member, expected, e);
            }
        }
        Object previous = views.putIfAbsent(member, value == null ? NO_VALUE : value);
        return previous == null || previous == NO_VALUE ? value : (T) previous;
    }

    protected final String string(String member) {
        return view(member, "a string", STRING);
    }

    protected final Long integer(String member) {
        return view(member, "an integer", INTEGER);
    }

    protected final Boolean bool(String member) {
        return view(member, "a boolean", BOOLEAN);
    }

    protected final Map<String, Object> object(String member) {
        return view(member, "an object", OBJECT);
    }

    /** Any JSON value: null when absent, {@link #JSON_NULL} when present with JSON null. */
    protected final Object anyMember(String member) {
        if (!members.containsKey(member)) {
            return null;
        }
        Object value = members.get(member);
        return value == null ? JSON_NULL : value;
    }

    protected final <T> T typed(String member, Reader<T> reader) {
        return view(member, "an object of the expected shape", reader);
    }

    protected final <T> List<T> list(String member, Reader<T> reader) {
        return view(member, "an array of the expected items", listOf(reader));
    }

    protected final <T> Map<String, T> map(String member, Reader<T> reader) {
        return view(member, "an object of the expected members", mapOf(reader));
    }

    /** Reads a JSON array, each item with a reader, as an unmodifiable list. */
    protected static <T> Reader<List<T>> listOf(final Reader<T> item) {
        return new Reader<List<T>>() {
            @Override
            public List<T> read(Object json) {
                if (!(json instanceof List<?>)) {
                    throw new IllegalStateException("not an array: " + describe(json));
                }
                List<T> out = new ArrayList<T>();
                int index = 0;
                for (Object element : (List<?>) json) {
                    if (element == null && item != ANY) {
                        throw new IllegalStateException("item " + index + " is null");
                    }
                    try {
                        out.add(item.read(element));
                    } catch (IllegalArgumentException e) {
                        throw new IllegalStateException("item " + index + ": " + e.getMessage(), e);
                    }
                    index++;
                }
                return Collections.unmodifiableList(out);
            }
        };
    }

    /** Reads a JSON object, each member with a reader, as an unmodifiable map. */
    protected static <T> Reader<Map<String, T>> mapOf(final Reader<T> item) {
        return new Reader<Map<String, T>>() {
            @Override
            public Map<String, T> read(Object json) {
                if (!(json instanceof Map<?, ?>)) {
                    throw new IllegalStateException("not an object: " + describe(json));
                }
                Map<String, T> out = new LinkedHashMap<String, T>();
                for (Map.Entry<?, ?> entry : ((Map<?, ?>) json).entrySet()) {
                    if (entry.getValue() == null && item != ANY) {
                        throw new IllegalStateException("member " + entry.getKey() + " is null");
                    }
                    try {
                        out.put((String) entry.getKey(), item.read(entry.getValue()));
                    } catch (IllegalArgumentException e) {
                        throw new IllegalStateException("member " + entry.getKey() + ": " + e.getMessage(), e);
                    }
                }
                return Collections.unmodifiableMap(out);
            }
        };
    }

    /** Reads a JSON string. */
    protected static final Reader<String> STRING = new Reader<String>() {
        @Override
        public String read(Object json) {
            if (json instanceof String) {
                return (String) json;
            }
            throw new IllegalStateException("not a string: " + describe(json));
        }
    };

    /** Reads a JSON integer. */
    protected static final Reader<Long> INTEGER = new Reader<Long>() {
        @Override
        public Long read(Object json) {
            Long value = DocumentIndex.intRef(json);
            if (value == null) {
                throw new IllegalStateException("not an integer in the range of long: " + describe(json));
            }
            return value;
        }
    };

    /** Reads a JSON boolean. */
    protected static final Reader<Boolean> BOOLEAN = new Reader<Boolean>() {
        @Override
        public Boolean read(Object json) {
            if (json instanceof Boolean) {
                return (Boolean) json;
            }
            throw new IllegalStateException("not a boolean: " + describe(json));
        }
    };

    /** Reads any JSON value as it is (JSON null as null). */
    protected static final Reader<Object> ANY = new Reader<Object>() {
        @Override
        public Object read(Object json) {
            return json;
        }
    };

    /** Reads a JSON object as a map. */
    protected static final Reader<Map<String, Object>> OBJECT = new Reader<Map<String, Object>>() {
        @Override
        @SuppressWarnings("unchecked")
        public Map<String, Object> read(Object json) {
            if (json instanceof Map<?, ?>) {
                return (Map<String, Object>) json;
            }
            throw new IllegalStateException("not an object: " + describe(json));
        }
    };

    // ---------------------------------------------------------------------------------------------
    // Frozen JSON trees
    // ---------------------------------------------------------------------------------------------

    /** A frozen JSON object. */
    private static final class FrozenMap extends AbstractMap<String, Object> {
        private final Map<String, Object> map;

        FrozenMap(LinkedHashMap<String, Object> map) {
            this.map = Collections.unmodifiableMap(map);
        }

        @Override
        public Set<Map.Entry<String, Object>> entrySet() {
            return map.entrySet();
        }

        @Override
        public Object get(Object key) {
            return map.get(key);
        }

        @Override
        public boolean containsKey(Object key) {
            return map.containsKey(key);
        }

        @Override
        public int size() {
            return map.size();
        }
    }

    /** A frozen JSON array. */
    private static final class FrozenList extends AbstractList<Object> implements RandomAccess {
        private final Object[] items;

        FrozenList(List<Object> items) {
            this.items = items.toArray();
        }

        @Override
        public Object get(int index) {
            return items[index];
        }

        @Override
        public int size() {
            return items.length;
        }
    }

    private static boolean unfrozen(Object value) {
        return (value instanceof Map<?, ?> && !(value instanceof FrozenMap))
                || (value instanceof List<?> && !(value instanceof FrozenList));
    }

    /** A JSON scalar in its stored form, or a container to freeze, or a frozen tree to use as it is. */
    private static Object normalize(Object value) {
        if (value instanceof SqllrObject) {
            return ((SqllrObject) value).members;
        }
        if (value == null || value == JSON_NULL) {
            return null;
        }
        if (value instanceof Long || value instanceof String || value instanceof Boolean || value instanceof Map<?, ?>
                || value instanceof List<?>) {
            return value;
        }
        if (value instanceof Integer || value instanceof Short || value instanceof Byte) {
            return Long.valueOf(((Number) value).longValue());
        }
        if (value instanceof BigInteger) {
            return ((BigInteger) value).bitLength() < 64 ? Long.valueOf(((BigInteger) value).longValue()) : value;
        }
        throw new IllegalArgumentException("not a JSON value of the model: " + value.getClass().getName());
    }

    /** One container being frozen. */
    private static final class Frame {
        final Iterator<?> items;
        final LinkedHashMap<String, Object> map;
        final List<Object> list;
        String key;

        Frame(Object container) {
            if (container instanceof Map<?, ?>) {
                items = ((Map<?, ?>) container).entrySet().iterator();
                map = new LinkedHashMap<String, Object>();
                list = null;
            } else {
                items = ((List<?>) container).iterator();
                map = null;
                list = new ArrayList<Object>();
            }
        }

        /** The next value to freeze; for an object, its member name is kept until the value is added. */
        Object next() {
            Object item = items.next();
            if (map != null) {
                Map.Entry<?, ?> entry = (Map.Entry<?, ?>) item;
                if (!(entry.getKey() instanceof String)) {
                    throw new IllegalArgumentException("member name " + entry.getKey() + " is not a string");
                }
                key = (String) entry.getKey();
                return entry.getValue();
            }
            return item;
        }

        void add(Object value) {
            if (map != null) {
                map.put(key, value);
            } else {
                list.add(value);
            }
        }

        Object build() {
            return map != null ? new FrozenMap(map) : new FrozenList(list);
        }
    }

    /** A frozen copy of a JSON value, made with an explicit stack; frozen subtrees are shared, not copied. */
    static Object freeze(Object value) {
        Object root = normalize(value);
        if (!unfrozen(root)) {
            return root;
        }
        Deque<Frame> stack = new ArrayDeque<Frame>();
        stack.push(new Frame(root));
        Object result = null;
        while (!stack.isEmpty()) {
            Frame frame = stack.peek();
            if (frame.items.hasNext()) {
                Object child = normalize(frame.next());
                if (unfrozen(child)) {
                    stack.push(new Frame(child));
                } else {
                    frame.add(child);
                }
            } else {
                stack.pop();
                Object frozen = frame.build();
                if (stack.isEmpty()) {
                    result = frozen;
                } else {
                    stack.peek().add(frozen);
                }
            }
        }
        return result;
    }

    /** The RFC 8785 text of the members, computed once. */
    private String canonical() {
        String text = canonical;
        if (text == null) {
            text = CanonicalJson.jcsText(members);
            canonical = text;
        }
        return text;
    }

    @Override
    public final boolean equals(Object other) {
        return other != null && other.getClass() == getClass() && canonical().equals(((SqllrObject) other).canonical());
    }

    @Override
    public final int hashCode() {
        return canonical().hashCode();
    }

    /** The RFC 8785 text of the object. */
    @Override
    public final String toString() {
        return canonical();
    }

    /**
     * Collects the members of a new object. A setter given null removes the member; given {@link #JSON_NULL} it sets
     * JSON null; a typed value, list or map of typed values is stored as its JSON.
     */
    public abstract static class Builder<T extends SqllrObject, B extends Builder<T, B>> {
        private final LinkedHashMap<String, Object> members = new LinkedHashMap<String, Object>();

        protected Builder(Map<String, Object> from) {
            if (from != null) {
                members.putAll(from);
            }
        }

        @SuppressWarnings("unchecked")
        private B self() {
            return (B) this;
        }

        /** Sets a member the model may not type, such as module content; null removes it. */
        public final B set(String member, Object value) {
            if (value == null) {
                members.remove(member);
            } else {
                members.put(member, value);
            }
            return self();
        }

        public final B remove(String member) {
            members.remove(member);
            return self();
        }

        /** The frozen members collected so far. */
        @SuppressWarnings("unchecked")
        protected final Map<String, Object> frozenMembers() {
            return (Map<String, Object>) freeze(members);
        }

        public abstract T build();
    }
}