package gudusoft.gsqlparser.lineage.v2.shape;

import java.util.ArrayList;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * The value projection of what the SQL-LR producer reads from one analysis (plan 09, Section 3.1, slice 1b): one
 * immutable mirror ({@link ShapeObject}) per live object it reads, addressed by handle, the traversals its visitors
 * replay, and the text renderings it shows in diagnostics. Built by {@link ShapeBuilder} when the analysis freezes;
 * holds no live object, so the document can be built from it after the analyzer is disposed, on any thread.
 *
 * <p>Two values are taken later than the freeze, when the analysis has finished and before it is disposed, at the
 * moment the producer took them before slice 1b: the text renderings of names, literals and type names
 * ({@code toString()} can mark tokens deleted, so it never runs inside the analysis). {@link #seal()} ends that phase;
 * after it nothing changes.</p>
 *
 * <p>Internal API of the SQL-LR producer.</p>
 *
 * @since 4.2.17
 */
public final class Shape {

    /** A slot holding a handle of another mirror. */
    static final class Ref {
        final int handle;

        Ref(int handle) {
            this.handle = handle;
        }
    }

    /** A slot holding the handles of a list of mirrors, in order. */
    static final class Refs {
        final int[] handles;
        /** The list of mirrors, made at the first read and shared (unmodifiable) by every later one. */
        volatile List<Object> list;

        Refs(int[] handles) {
            this.handles = handles;
        }
    }

    /** A slot whose getter threw when the analysis froze: reading it throws the same kind of exception again. */
    static final class Throw {
        final String className;
        final String message;

        Throw(String className, String message) {
            this.className = className;
            this.message = message;
        }
    }

    /** A slot holding a value the projection does not copy: reading it is an error, never a silent default. */
    static final class Unsupported {
        final String what;

        Unsupported(String what) {
            this.what = what;
        }
    }

    /**
     * A slot holding an identifier service, kept as its profile and whether it collates: each read makes the service
     * again, so the shape holds no collator cache (a {@code ThreadLocal}, plan 09, Section 3.1). The service has no
     * other state.
     */
    static final class Service {
        final gudusoft.gsqlparser.sqlenv.IdentifierProfile profile;
        final boolean collating;

        Service(gudusoft.gsqlparser.sqlenv.IdentifierService service) {
            this.profile = service.getProfile();
            this.collating = service.getCollatorProvider() != null;
        }

        gudusoft.gsqlparser.sqlenv.IdentifierService make() {
            return new gudusoft.gsqlparser.sqlenv.IdentifierService(profile,
                    collating ? new gudusoft.gsqlparser.sqlenv.CollatorProvider() : null);
        }
    }

    final ShapeObject[] objects;
    private final String[] liveClassNames;
    private final String[] liveSimpleNames;
    private final int[][] references;
    /** Per mirror, its traversal as pieces {reference, start, end}... of the recorded references; null for none. */
    private final int[][] traversalPieces;
    private final String[] traversalThrow;
    private final Map<Integer, String> renderings = new HashMap<Integer, String>();
    private final Map<String, String> memberRenderings = new HashMap<String, String>();
    private final int root;
    private final int catalog;
    private volatile boolean sealed;
    private long freezeNanos = -1;
    private long completeNanos = -1;

    Shape(int size, String[] liveClassNames, String[] liveSimpleNames, int[][] references, int[][] traversalPieces,
            String[] traversalThrow, int root, int catalog) {
        this.objects = new ShapeObject[size];
        this.liveClassNames = liveClassNames;
        this.liveSimpleNames = liveSimpleNames;
        this.references = references;
        this.traversalPieces = traversalPieces;
        this.traversalThrow = traversalThrow;
        this.root = root;
        this.catalog = catalog;
    }

    /** The mirror of the recorder, the root of the projection of an analysis. */
    public SqllrObservations observations() {
        return (SqllrObservations) objects[root];
    }

    /** The root of the projection: the recorder of an analysis, or the statement {@link ShapeBuilder#project} took. */
    public ShapeObject root() {
        return objects[root];
    }

    /** The mirror of the catalog the producer reads (its own copy of the supplied one), or null when none. */
    public TSQLEnv catalog() {
        return catalog < 0 ? null : (TSQLEnv) objects[catalog];
    }

    /** The number of mirrors. */
    public int size() {
        return objects.length;
    }

    /** The mirror with handle {@code h}. */
    public ShapeObject at(int h) {
        return objects[h];
    }

    String liveSimpleName(int h) {
        return liveSimpleNames[h];
    }

    String liveClassName(int h) {
        return liveClassNames[h];
    }

    @SuppressWarnings("unchecked")
    <T> T resolve(Object slot) {
        if (slot == null) {
            return null;
        }
        if (slot instanceof Ref) {
            return (T) objects[((Ref) slot).handle];
        }
        if (slot instanceof Refs) {
            Refs refs = (Refs) slot;
            List<Object> made = refs.list;
            if (made == null) {
                List<Object> list = new ArrayList<Object>(refs.handles.length);
                for (int h : refs.handles) {
                    list.add(h < 0 ? null : objects[h]);
                }
                made = Collections.unmodifiableList(list);
                refs.list = made; // a race makes two equal lists; either is right
            }
            return (T) made;
        }
        if (slot instanceof Throw) {
            throw rethrow(((Throw) slot).className, ((Throw) slot).message);
        }
        if (slot instanceof Unsupported) {
            throw new IllegalStateException("not in the shape: " + ((Unsupported) slot).what);
        }
        if (slot instanceof Service) {
            return (T) ((Service) slot).make();
        }
        if (slot instanceof EnumSet) {
            return (T) ((EnumSet<?>) slot).clone();
        }
        return (T) slot;
    }

    /**
     * The exception a live call threw, thrown again: the same class when it can be made, so a caller that catches it
     * or names its class sees what it saw before.
     */
    static RuntimeException rethrow(String className, String message) {
        Throwable t;
        try {
            Class<?> c = Class.forName(className);
            try {
                t = (Throwable) c.getConstructor(String.class).newInstance(message);
            } catch (NoSuchMethodException e) {
                t = (Throwable) c.getConstructor().newInstance();
            }
        } catch (Exception e) {
            t = new IllegalStateException(className + ": " + message);
        }
        if (t instanceof RuntimeException) {
            return (RuntimeException) t;
        }
        if (t instanceof Error) {
            throw (Error) t;
        }
        return new IllegalStateException(className + ": " + message, t);
    }

    /** Replays the live {@code acceptChildren} of mirror {@code h} on a mirror visitor. */
    void replay(int h, TParseTreeVisitor visitor) {
        int[] pieces = traversalPieces[h];
        for (int p = 0; pieces != null && p < pieces.length; p += 3) {
            int[] events = references[pieces[p]];
            for (int i = pieces[p + 1]; i < pieces[p + 2]; i++) {
                visitor.dispatch(events[2 * i], objects[events[2 * i + 1]]);
            }
        }
        if (traversalThrow[h] != null) {
            throw rethrow(traversalThrow[h], null);
        }
    }

    /** The text the live object rendered ({@code toString()}), taken after the analysis finished. */
    String render(int h) {
        String text = renderings.get(Integer.valueOf(h));
        if (text == null && !renderings.containsKey(Integer.valueOf(h))) {
            throw new IllegalStateException("no rendering of " + liveClassNames[h] + " #" + h);
        }
        if (text != null && text.startsWith("\u0000")) {
            throw rethrow(text.substring(1), null);
        }
        return text;
    }

    /** The value a rendering getter returned, taken after the analysis finished. */
    String renderMember(int h, String member) {
        String key = h + "." + member;
        if (!memberRenderings.containsKey(key)) {
            throw new IllegalStateException("no rendering of " + liveClassNames[h] + " #" + h + "." + member);
        }
        String text = memberRenderings.get(key);
        if (text != null && text.startsWith("\u0000")) {
            throw rethrow(text.substring(1), null);
        }
        return text;
    }

    void putRendering(int h, String text) {
        if (sealed) {
            throw new IllegalStateException("the shape is sealed");
        }
        renderings.put(Integer.valueOf(h), text);
    }

    void putMemberRendering(int h, String member, String value) {
        if (sealed) {
            throw new IllegalStateException("the shape is sealed");
        }
        memberRenderings.put(h + "." + member, value);
    }

    /** Ends the rendering phase: from now on the shape never changes. */
    void seal() {
        sealed = true;
    }

    public boolean isSealed() {
        return sealed;
    }

    /** The time the projection took when the analysis froze, in nanoseconds (cost measurement, plan 09 §3.1). */
    public long getFreezeNanos() {
        return freezeNanos;
    }

    /** The time taking the renderings took after the analysis, in nanoseconds; -1 before {@link #seal()}. */
    public long getCompleteNanos() {
        return completeNanos;
    }

    private long[] traversalStats = new long[8];

    /**
     * How the traversals were taken (cost measurement): slices of an enclosing recording taken, slices refused because
     * the node's own traversal differs, own recordings without a slice, and nodes visited while recording.
     */
    public long[] getTraversalStats() {
        return traversalStats.clone();
    }

    void setTraversalStats(long[] stats) {
        traversalStats = stats;
    }

    void setFreezeNanos(long nanos) {
        freezeNanos = nanos;
    }

    void setCompleteNanos(long nanos) {
        completeNanos = nanos;
    }
}