package gudusoft.gsqlparser.dlineage.dataflow.model;

import gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment;

/**
 * One unresolved fragment ("hole") of a dynamic-SQL site's argument: a value the
 * abstract evaluator could not fold to exact text. Exposed by
 * {@link DynamicSqlSite#getUnresolvedFragments()} so a consumer can say WHICH
 * value stopped the rebuild and where that value comes from, rather than only
 * that the site was not rebuilt.
 *
 * <p>{@link #getName()} is the variable / parameter / function the hole stands
 * for ({@code @Where}, {@code @HuidigOutboundRunID}, {@code CAST}); it is null
 * only when the producer had no name. {@link #getText()} is how the hole is
 * rendered inside {@link DynamicSqlSite#getMaterializedText()}.
 * {@link #getValueOrigin()} describes the data source the runtime value would be
 * read from when the evaluator saw it — {@code dbo.SSF_Entity.Entity} for a
 * variable assigned by {@code SELECT @entity = Entity FROM dbo.SSF_Entity}.
 *
 * <p>The span is the fragment's <em>origin</em> in the analyzed text — the
 * assignment target of a query-assigned or flow-dependent variable, the
 * declaration of an unbound parameter or of a declared-but-unassigned
 * variable, otherwise the reference that produced the hole — so a consumer can
 * highlight it with the same locate-in-source control it uses for the site.
 * Positions are 1-based with an end-exclusive end column, the convention of
 * {@link DynamicSqlSite#getStartPosition()}; {@code -1} when the origin is not
 * in the analyzed text.
 */
public final class UnresolvedFragment {

        private final SqlFragment.HoleOrigin kind;
        private final String name;
        private final String text;
        private final String reason;
        private final boolean valueUnknown;
        private final String valueOrigin;
        private final int startLine;
        private final int startColumn;
        private final int endLine;
        private final int endColumn;

        public UnresolvedFragment(SqlFragment.HoleOrigin kind, String name, String text, String reason,
                        boolean valueUnknown, String valueOrigin, int startLine, int startColumn,
                        int endLine, int endColumn) {
                this.kind = kind == null ? SqlFragment.HoleOrigin.UNSUPPORTED_EXPR : kind;
                this.name = name;
                this.text = text == null ? "" : text;
                this.reason = reason;
                this.valueUnknown = valueUnknown;
                this.valueOrigin = valueOrigin;
                this.startLine = startLine;
                this.startColumn = startColumn;
                this.endLine = endLine;
                this.endColumn = endColumn;
        }

        /** The fragment view of a non-literal {@link SqlFragment}; {@code null} for a literal. */
        public static UnresolvedFragment of(SqlFragment fragment) {
                if (fragment == null || fragment.isLiteral()) {
                        return null;
                }
                return new UnresolvedFragment(fragment.origin, fragment.originName, fragment.text,
                                fragment.reason, fragment.valueUnknown, fragment.valueOrigin,
                                fragment.sourceStartLine, fragment.sourceStartColumn,
                                fragment.sourceEndLine, fragment.sourceEndColumn);
        }

        /** Why the hole exists: which producer limitation created it. */
        public SqlFragment.HoleOrigin getKind() {
                return kind;
        }

        /** The variable / parameter / function / expression the hole stands for; may be null. */
        public String getName() {
                return name;
        }

        /** The hole's rendering inside {@link DynamicSqlSite#getMaterializedText()}. Never null. */
        public String getText() {
                return text;
        }

        /** Human-readable cause: why the value was not folded. */
        public String getReason() {
                return reason;
        }

        /**
         * True when the runtime VALUE is unknown; false for an inexact transform computed
         * entirely from literals, whose value is known and only its byte-exact rendering is
         * unproven (see {@link SqlFragment#valueUnknown}).
         */
        public boolean isValueUnknown() {
                return valueUnknown;
        }

        /** Where the runtime value would come from, when known; otherwise null. */
        public String getValueOrigin() {
                return valueOrigin;
        }

        public int getStartLine() {
                return startLine;
        }

        public int getStartColumn() {
                return startColumn;
        }

        public int getEndLine() {
                return endLine;
        }

        /** End-exclusive. */
        public int getEndColumn() {
                return endColumn;
        }

        /** True when the origin span is known. */
        public boolean hasSpan() {
                return startLine > 0 && startColumn > 0;
        }

        @Override
        public String toString() {
                StringBuilder sb = new StringBuilder();
                sb.append(name != null ? name : (text.isEmpty() ? "<" + kind + ">" : text))
                                .append(" kind=").append(kind);
                if (reason != null) {
                        sb.append(" reason=").append(reason);
                }
                if (valueOrigin != null) {
                        sb.append(" origin=").append(valueOrigin);
                }
                if (hasSpan()) {
                        sb.append(" span=[").append(startLine).append(',').append(startColumn).append("]-[")
                                        .append(endLine).append(',').append(endColumn).append(']');
                }
                return sb.toString();
        }
}