package gudusoft.gsqlparser.ir.semantic;

import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.nodes.TParseTreeNode;

import java.util.Objects;

/**
 * Half-open source-text range, {@code [startLine:startColumn,
 * endLine:endColumn)}. Used by {@link Diagnostic} to point at the
 * offending AST node when a reject site has one in scope.
 *
 * <p>{@code startLine} / {@code startColumn} mark the first character
 * of the anchor (1-based as populated by GSP's lexer via
 * {@link TSourceToken#lineNo} / {@link TSourceToken#columnNo}).
 * {@code endLine} / {@code endColumn} mark the position
 * <strong>one past</strong> the last character. For a single-line
 * single-token anchor of length {@code L}, {@code endColumn ==
 * startColumn + L}. Multi-line tokens (e.g. triple-quoted strings)
 * are handled by counting newlines in the end token's text.
 *
 * <p>The class is intentionally null-tolerant at the factory level:
 * {@link #of(TParseTreeNode)} returns {@code null} when the node or
 * either of its boundary tokens is {@code null}. Diagnostic factories
 * pass this {@code null} through to {@link Diagnostic#getSpan()}
 * unchanged.
 *
 * <p><b>API status:</b> read-only consumption of analyzer-produced spans is
 * part of Join Analysis Consumption Profile v1. Factories are
 * producer-oriented and are outside that profile.
 */
public final class SourceSpan {

    private final long startLine;
    private final long startColumn;
    private final long endLine;
    private final long endColumn;

    private SourceSpan(long startLine, long startColumn,
                       long endLine, long endColumn) {
        this.startLine = startLine;
        this.startColumn = startColumn;
        this.endLine = endLine;
        this.endColumn = endColumn;
    }

    /**
     * Construct an explicit half-open source span. Coordinates are 1-based,
     * and the end must not precede the start.
     */
    public static SourceSpan of(long startLine, long startColumn,
                                long endLine, long endColumn) {
        if (startLine < 1 || startColumn < 1 || endLine < 1 || endColumn < 1) {
            throw new IllegalArgumentException("source coordinates must be positive");
        }
        if (endLine < startLine
                || (endLine == startLine && endColumn < startColumn)) {
            throw new IllegalArgumentException("span end must not precede span start");
        }
        return new SourceSpan(startLine, startColumn, endLine, endColumn);
    }

    /**
     * Derive a span from the AST node's start and end tokens.
     * Null-safe: returns {@code null} when {@code node} is {@code null}
     * or either boundary token is {@code null}.
     */
    public static SourceSpan of(TParseTreeNode node) {
        if (node == null) return null;
        return of(node.getStartToken(), node.getEndToken());
    }

    /**
     * Derive a span from explicit start / end tokens. End position is
     * computed as one past the last character of {@code end} so the
     * resulting interval is half-open {@code [start, end)}.
     *
     * <p>Null-safe: returns {@code null} when either token is
     * {@code null}.
     */
    public static SourceSpan of(TSourceToken start, TSourceToken end) {
        if (start == null || end == null) return null;
        String endText = end.getAstext();
        if (endText == null) endText = "";
        long endLine = end.lineNo;
        long endColumn = end.columnNo + endText.length();
        // Multi-line token: advance the line count and recompute the
        // trailing column from the last newline.
        int lastNl = endText.lastIndexOf('\n');
        if (lastNl >= 0) {
            long extraLines = 0;
            for (int i = 0; i < endText.length(); i++) {
                if (endText.charAt(i) == '\n') extraLines++;
            }
            endLine = end.lineNo + extraLines;
            endColumn = endText.length() - lastNl - 1 + 1;
            // +1 keeps the half-open convention (column index of the
            // position one past the last char on the final line; the
            // final line starts at column 1 by GSP convention).
        }
        return new SourceSpan(start.lineNo, start.columnNo, endLine, endColumn);
    }

    public long getStartLine() {
        return startLine;
    }

    public long getStartColumn() {
        return startColumn;
    }

    public long getEndLine() {
        return endLine;
    }

    public long getEndColumn() {
        return endColumn;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof SourceSpan)) return false;
        SourceSpan that = (SourceSpan) o;
        return startLine == that.startLine
                && startColumn == that.startColumn
                && endLine == that.endLine
                && endColumn == that.endColumn;
    }

    @Override
    public int hashCode() {
        return Objects.hash(startLine, startColumn, endLine, endColumn);
    }

    @Override
    public String toString() {
        return startLine + ":" + startColumn + "-" + endLine + ":" + endColumn;
    }
}