package gudusoft.gsqlparser.lineage.v2.producer;

import java.util.Arrays;

/**
 * The decoded text of one source unit and the two coordinate systems that meet in it.
 *
 * <ul>
 *   <li><b>GSP's lexer</b> numbers lines and columns in UTF-16 code units, and ends a line at LF, CR LF or a
 *   lone CR ({@code TCustomLexer.readln}). Re-parsed text (routine bodies, dynamic SQL) has its token lines and
 *   columns shifted into the parent text while {@code TSourceToken.offset} stays relative to the inner text, so
 *   only the (line, column) pair is trusted: {@link #lexerOffset} turns it into a UTF-16 offset of this text.</li>
 *   <li><b>SQL-LR positions</b> ({@code Position}) count lines from 1 with LF as the line end, columns in code
 *   points from 1, and offsets in UTF-8 bytes from 0, as the reference validator checks them
 *   ({@code conformance/run.py}, M1 {@code SemanticStage.SourceText}). {@link #position} gives that triple for a
 *   UTF-16 offset.</li>
 * </ul>
 *
 * <p>Immutable.</p>
 *
 * @since 4.2.17
 */
public final class SourceText {

    /** A SQL-LR position. */
    public static final class Position {
        private final long line1;
        private final long column1;
        private final long utf8ByteOffset0;

        Position(long line1, long column1, long utf8ByteOffset0) {
            this.line1 = line1;
            this.column1 = column1;
            this.utf8ByteOffset0 = utf8ByteOffset0;
        }

        public long getLine1() {
            return line1;
        }

        public long getColumn1() {
            return column1;
        }

        public long getUtf8ByteOffset0() {
            return utf8ByteOffset0;
        }

        @Override
        public boolean equals(Object other) {
            if (!(other instanceof Position)) {
                return false;
            }
            Position p = (Position) other;
            return line1 == p.line1 && column1 == p.column1 && utf8ByteOffset0 == p.utf8ByteOffset0;
        }

        @Override
        public int hashCode() {
            return (int) (line1 * 31 + column1) * 31 + (int) utf8ByteOffset0;
        }

        @Override
        public String toString() {
            return line1 + "," + column1 + "," + utf8ByteOffset0;
        }
    }

    private final String text;
    /** UTF-16 offset of the start of every line as GSP's lexer counts lines. */
    private final int[] lexerLineStarts;
    /** UTF-16 offset of the start of every SQL-LR line (LF only). */
    private final int[] lineStarts;
    /** UTF-8 byte offset before every UTF-16 offset; length text.length() + 1. */
    private final int[] utf8Before;
    /** Code points before every UTF-16 offset; length text.length() + 1. */
    private final int[] codePointsBefore;

    public SourceText(String text) {
        if (text == null) {
            throw new IllegalArgumentException("no text");
        }
        this.text = text;
        int n = text.length();
        int[] lexer = new int[16];
        int[] sqllr = new int[16];
        int lexerCount = 1;
        int sqllrCount = 1;
        utf8Before = new int[n + 1];
        codePointsBefore = new int[n + 1];
        int bytes = 0;
        int points = 0;
        for (int i = 0; i < n; i++) {
            utf8Before[i] = bytes;
            codePointsBefore[i] = points;
            char c = text.charAt(i);
            if (Character.isHighSurrogate(c) && i + 1 < n && Character.isLowSurrogate(text.charAt(i + 1))) {
                bytes += 4;
                points++;
                utf8Before[i + 1] = bytes; // inside the pair: never a valid boundary, kept monotone
                codePointsBefore[i + 1] = points;
                i++;
                continue;
            }
            if (Character.isSurrogate(c)) {
                throw new IllegalArgumentException("text has an unpaired surrogate at UTF-16 offset " + i);
            }
            bytes += c < 0x80 ? 1 : c < 0x800 ? 2 : 3;
            points++;
            if (c == '\n') {
                if (lexerCount == lexer.length) {
                    lexer = Arrays.copyOf(lexer, lexerCount * 2);
                }
                lexer[lexerCount++] = i + 1;
                if (sqllrCount == sqllr.length) {
                    sqllr = Arrays.copyOf(sqllr, sqllrCount * 2);
                }
                sqllr[sqllrCount++] = i + 1;
            } else if (c == '\r' && (i + 1 >= n || text.charAt(i + 1) != '\n')) {
                if (lexerCount == lexer.length) {
                    lexer = Arrays.copyOf(lexer, lexerCount * 2);
                }
                lexer[lexerCount++] = i + 1;
            }
        }
        utf8Before[n] = bytes;
        codePointsBefore[n] = points;
        lexerLineStarts = Arrays.copyOf(lexer, lexerCount);
        lineStarts = Arrays.copyOf(sqllr, sqllrCount);
    }

    public String getText() {
        return text;
    }

    /** The UTF-8 length of the text. */
    public int utf8Length() {
        return utf8Before[text.length()];
    }

    /**
     * The UTF-16 offset of a lexer (line, column), or -1 when the pair lies outside the text. Column {@code c}
     * of a line is the offset {@code lineStart + c - 1}; a column past the end of its line is outside.
     */
    public int lexerOffset(long line1, long column1) {
        if (line1 < 1 || line1 > lexerLineStarts.length || column1 < 1) {
            return -1;
        }
        int start = lexerLineStarts[(int) line1 - 1];
        int end = line1 < lexerLineStarts.length ? lexerLineStarts[(int) line1] : text.length();
        if (column1 - 1 > end - start) {
            return -1;
        }
        return start + (int) (column1 - 1);
    }

    /**
     * The SQL-LR position of a UTF-16 offset, or {@code null} when the offset is outside the text or inside a
     * surrogate pair.
     */
    public Position position(int utf16Offset) {
        if (utf16Offset < 0 || utf16Offset > text.length()) {
            return null;
        }
        if (utf16Offset > 0 && utf16Offset < text.length() && Character.isLowSurrogate(text.charAt(utf16Offset))
                && Character.isHighSurrogate(text.charAt(utf16Offset - 1))) {
            return null;
        }
        int low = 0;
        int high = lineStarts.length - 1;
        while (low < high) {
            int mid = (low + high + 1) >>> 1;
            if (lineStarts[mid] <= utf16Offset) {
                low = mid;
            } else {
                high = mid - 1;
            }
        }
        return new Position(low + 1, codePointsBefore[utf16Offset] - codePointsBefore[lineStarts[low]] + 1L,
                utf8Before[utf16Offset]);
    }

    /** Whether {@code fragment} occurs in the text at {@code utf16Offset}. */
    public boolean matches(int utf16Offset, String fragment) {
        return fragment != null && utf16Offset >= 0 && text.regionMatches(utf16Offset, fragment, 0, fragment.length());
    }
}