package gudusoft.gsqlparser.lineage.v2.shape;

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

/**
 * Mirror of {@code gudusoft.gsqlparser.dlineage.dataflow.model.SqllrObservations}, the recorder, as it stood when the
 * analysis froze: the root of the shape (plan 09, slice 1b). Hand-written, with its record mirrors, because two of its
 * members take an argument: they are answered from tables the projection precomputed for every possible argument.
 *
 * <p>Internal API of the SQL-LR producer.</p>
 *
 * @since 4.2.17
 */
public final class SqllrObservations extends ShapeObject {

    private final Object vUnits;
    private final Object vElements;
    private final Object vReferences;
    private final Object vFrozenRelations;
    private final Object vFrozenResultSets;
    private final Object vDerived;
    private final Object vStatements;
    private final Map<Integer, Object> frozenColumns;
    private final Map<Integer, Integer> structItems;

    SqllrObservations(Shape shape, int handle, Object[] v, Map<Integer, Object> frozenColumns,
            Map<Integer, Integer> structItems) {
        super(shape, handle);
        this.vUnits = v[0];
        this.vElements = v[1];
        this.vReferences = v[2];
        this.vFrozenRelations = v[3];
        this.vFrozenResultSets = v[4];
        this.vDerived = v[5];
        this.vStatements = v[6];
        this.frozenColumns = Collections.unmodifiableMap(frozenColumns);
        this.structItems = Collections.unmodifiableMap(structItems);
    }

    public List<UnitRecord> getUnits() {
        return slot(vUnits);
    }

    public List<ElementRecord> getElements() {
        return slot(vElements);
    }

    public List<ReferenceRecord> getReferences() {
        return slot(vReferences);
    }

    public List<FrozenRelation> getFrozenRelations() {
        return slot(vFrozenRelations);
    }

    public List<ResultSet> getFrozenResultSets() {
        return slot(vFrozenResultSets);
    }

    public List<DerivedRecord> getDerived() {
        return slot(vDerived);
    }

    public List<StatementRecord> getStatements() {
        return slot(vStatements);
    }

    /** The columns of a result set at the freeze, or {@code null} when no frozen relationship reaches it. */
    public List<ResultColumn> getFrozenColumns(ResultSet resultSet) {
        Object columns = resultSet == null ? null : frozenColumns.get(Integer.valueOf(resultSet.shapeHandle()));
        return columns == null ? null : this.<List<ResultColumn>>slot(columns);
    }

    /** The select item whose STRUCT a field column belongs to, or null. */
    public TResultColumn getStructItem(Object column) {
        if (!(column instanceof ShapeObject)) {
            return null;
        }
        Integer item = structItems.get(Integer.valueOf(((ShapeObject) column).shapeHandle()));
        return item == null ? null : (TResultColumn) shape.at(item.intValue());
    }

    /** Mirror of the recorder's element record. */
    public static final class ElementRecord extends ShapeObject {
        private final Object vRelation;
        private final Object vElement;
        private final boolean target;
        private final Object vReference;
        private final Object vStatement;
        private final long sequence;

        ElementRecord(Shape shape, int handle, Object[] v) {
            super(shape, handle);
            this.vRelation = v[0];
            this.vElement = v[1];
            this.target = ((Boolean) v[2]).booleanValue();
            this.vReference = v[3];
            this.vStatement = v[4];
            this.sequence = ((Long) v[5]).longValue();
        }

        public AbstractRelationship getRelation() {
            return slot(vRelation);
        }

        public RelationshipElement getElement() {
            return slot(vElement);
        }

        public boolean isTarget() {
            return target;
        }

        public TObjectName getReference() {
            return slot(vReference);
        }

        public TCustomSqlStatement getStatement() {
            return slot(vStatement);
        }

        public long getSequence() {
            return sequence;
        }
    }

    /** Mirror of the recorder's reference record. */
    public static final class ReferenceRecord extends ShapeObject {
        private final Object vReference;
        private final Object vTarget;
        private final Object vStatement;
        private final long sequence;

        ReferenceRecord(Shape shape, int handle, Object[] v) {
            super(shape, handle);
            this.vReference = v[0];
            this.vTarget = v[1];
            this.vStatement = v[2];
            this.sequence = ((Long) v[3]).longValue();
        }

        public TObjectName getReference() {
            return slot(vReference);
        }

        public Object getTarget() {
            return slot(vTarget);
        }

        public TCustomSqlStatement getStatement() {
            return slot(vStatement);
        }

        public long getSequence() {
            return sequence;
        }
    }

    /** Mirror of the recorder's statement record. */
    public static final class StatementRecord extends ShapeObject {
        private final Object vStatement;
        private final String failureClass;
        private final String failureMessage;
        private final boolean finished;
        private final String failureSimpleName;

        StatementRecord(Shape shape, int handle, Object[] v) {
            super(shape, handle);
            this.vStatement = v[0];
            this.failureClass = (String) v[1];
            this.failureMessage = (String) v[2];
            this.finished = ((Boolean) v[3]).booleanValue();
            this.failureSimpleName = (String) v[4];
        }

        /** The simple name of the class of the exception that ended the statement's analysis, or {@code null}. */
        public String getFailureSimpleName() {
            return failureSimpleName;
        }

        public TCustomSqlStatement getStatement() {
            return slot(vStatement);
        }

        /**
         * The exception that ended the statement's analysis, made again from its class and message (the snapshot
         * holds no Throwable), or {@code null}.
         */
        public Throwable getFailure() {
            if (failureClass == null) {
                return null;
            }
            try {
                Class<?> c = Class.forName(failureClass);
                try {
                    return (Throwable) c.getConstructor(String.class).newInstance(failureMessage);
                } catch (NoSuchMethodException e) {
                    return (Throwable) c.getConstructor().newInstance();
                }
            } catch (Exception e) {
                return new IllegalStateException(failureClass + ": " + failureMessage);
            }
        }

        public boolean isFinished() {
            return finished;
        }
    }

    /** Mirror of the recorder's unit record. */
    public static final class UnitRecord extends ShapeObject {
        private final int unitIndex;
        private final int parseResult;
        private final Object vStatements;
        private final Object vSyntaxErrors;
        private final Object vRecoveredSyntaxErrors;

        UnitRecord(Shape shape, int handle, Object[] v) {
            super(shape, handle);
            this.unitIndex = ((Integer) v[0]).intValue();
            this.parseResult = ((Integer) v[1]).intValue();
            this.vStatements = v[2];
            this.vSyntaxErrors = v[3];
            this.vRecoveredSyntaxErrors = v[4];
        }

        public int getUnitIndex() {
            return unitIndex;
        }

        public int getParseResult() {
            return parseResult;
        }

        public List<TCustomSqlStatement> getStatements() {
            return slot(vStatements);
        }

        public List<TSyntaxError> getSyntaxErrors() {
            return slot(vSyntaxErrors);
        }

        public List<TSyntaxError> getRecoveredSyntaxErrors() {
            return slot(vRecoveredSyntaxErrors);
        }
    }

    /** Mirror of the recorder's derived record. */
    public static final class DerivedRecord extends ShapeObject {
        private final Object vStatement;
        private final Object vSite;

        DerivedRecord(Shape shape, int handle, Object[] v) {
            super(shape, handle);
            this.vStatement = v[0];
            this.vSite = v[1];
        }

        public TCustomSqlStatement getStatement() {
            return slot(vStatement);
        }

        public TCustomSqlStatement getSite() {
            return slot(vSite);
        }
    }

    /** Mirror of a relationship frozen at the end of the analysis. */
    public static final class FrozenRelation extends ShapeObject {
        private final Object vRelation;
        private final Object vTarget;

        FrozenRelation(Shape shape, int handle, Object[] v) {
            super(shape, handle);
            this.vRelation = v[0];
            this.vTarget = v[1];
        }

        public AbstractRelationship getRelation() {
            return slot(vRelation);
        }

        public RelationshipElement getTarget() {
            return slot(vTarget);
        }
    }
}