package gudusoft.gsqlparser.common.structured;

import java.util.ArrayList;
import java.util.List;

/**
 * Recursive descent parser for vendor-neutral structured type strings.
 * Currently supports {@link StructuredSchemaDialect#SPARK_SQL_TYPE_STRING}:
 *
 * <pre>
 * type       := primitive | array | struct | map
 * array      := ARRAY '&lt;' type '&gt;'
 * struct     := STRUCT '&lt;' field (',' field)* '&gt;'
 * field      := identifier ':' type
 * map        := MAP '&lt;' type ',' type '&gt;'
 * primitive  := STRING | INT | BIGINT | DOUBLE | FLOAT | BOOLEAN | DATE
 *             | TIMESTAMP | DECIMAL ('(' ... ')')? | identifier
 * identifier := backquoted_identifier | bare_identifier
 * </pre>
 *
 * <p>Inputs may include one layer of surrounding single or double quotes
 * (matching the SQL string literal); they are stripped before parsing, and
 * doubled quotes ({@code ''}) inside the literal are unescaped to a single
 * quote.
 */
public final class StructuredSchemaParser {

    private StructuredSchemaParser() {}

    public static StructuredType parse(String schemaText, StructuredSchemaDialect dialect) {
        if (schemaText == null) {
            throw new StructuredSchemaParseException("schema text must not be null");
        }
        if (dialect == null) {
            throw new StructuredSchemaParseException("dialect must not be null");
        }
        String stripped = stripQuotes(schemaText.trim());
        switch (dialect) {
            case SPARK_SQL_TYPE_STRING:
                return new Cursor(stripped).readTypeAndExpectEnd();
            default:
                throw new StructuredSchemaParseException("unsupported dialect: " + dialect);
        }
    }

    private static String stripQuotes(String s) {
        if (s.length() >= 2) {
            char first = s.charAt(0);
            char last = s.charAt(s.length() - 1);
            if ((first == '\'' && last == '\'') || (first == '"' && last == '"')) {
                String inner = s.substring(1, s.length() - 1);
                String doubled = String.valueOf(first) + first;
                return inner.replace(doubled, String.valueOf(first));
            }
        }
        return s;
    }

    private static final class Cursor {
        private final String text;
        private int pos;

        Cursor(String text) {
            this.text = text;
            this.pos = 0;
        }

        StructuredType readTypeAndExpectEnd() {
            StructuredType t = readType();
            skipWs();
            if (pos != text.length()) {
                throw new StructuredSchemaParseException(
                        "unexpected trailing input at position " + pos + ": " + remaining());
            }
            return t;
        }

        StructuredType readType() {
            skipWs();
            if (pos >= text.length()) {
                throw new StructuredSchemaParseException("unexpected end of schema");
            }
            String ident = readIdentifier();
            String upper = ident.toUpperCase();
            switch (upper) {
                case "ARRAY":
                    return readArray();
                case "STRUCT":
                    return readStruct();
                case "MAP":
                    return readMap();
                case "DECIMAL":
                case "NUMERIC":
                    skipOptionalParenArgs();
                    return new StructuredPrimitiveType(upper);
                default:
                    return new StructuredPrimitiveType(upper);
            }
        }

        StructuredArrayType readArray() {
            expect('<');
            StructuredType element = readType();
            skipWs();
            expect('>');
            return new StructuredArrayType(element);
        }

        StructuredStructType readStruct() {
            expect('<');
            List<StructuredStructField> fields = new ArrayList<>();
            skipWs();
            if (peek() != '>') {
                fields.add(readField());
                skipWs();
                while (peek() == ',') {
                    pos++;
                    fields.add(readField());
                    skipWs();
                }
            }
            expect('>');
            return new StructuredStructType(fields);
        }

        StructuredStructField readField() {
            skipWs();
            String name = readIdentifier();
            skipWs();
            expect(':');
            StructuredType t = readType();
            return new StructuredStructField(name, t);
        }

        StructuredMapType readMap() {
            expect('<');
            StructuredType k = readType();
            skipWs();
            expect(',');
            StructuredType v = readType();
            skipWs();
            expect('>');
            return new StructuredMapType(k, v);
        }

        String readIdentifier() {
            skipWs();
            if (pos >= text.length()) {
                throw new StructuredSchemaParseException("expected identifier at end of schema");
            }
            char c = text.charAt(pos);
            if (c == '`') {
                int start = ++pos;
                while (pos < text.length() && text.charAt(pos) != '`') {
                    pos++;
                }
                if (pos >= text.length()) {
                    throw new StructuredSchemaParseException("unterminated backquoted identifier");
                }
                String ident = text.substring(start, pos);
                pos++; // consume closing backtick
                return ident;
            }
            int start = pos;
            while (pos < text.length()) {
                char ch = text.charAt(pos);
                if (Character.isLetterOrDigit(ch) || ch == '_') {
                    pos++;
                } else {
                    break;
                }
            }
            if (start == pos) {
                throw new StructuredSchemaParseException(
                        "expected identifier at position " + pos + ": " + remaining());
            }
            return text.substring(start, pos);
        }

        void skipOptionalParenArgs() {
            skipWs();
            if (pos < text.length() && text.charAt(pos) == '(') {
                int depth = 0;
                while (pos < text.length()) {
                    char c = text.charAt(pos++);
                    if (c == '(') depth++;
                    else if (c == ')') {
                        depth--;
                        if (depth == 0) return;
                    }
                }
                throw new StructuredSchemaParseException("unterminated parenthesized type args");
            }
        }

        void skipWs() {
            while (pos < text.length() && Character.isWhitespace(text.charAt(pos))) {
                pos++;
            }
        }

        char peek() {
            skipWs();
            return pos < text.length() ? text.charAt(pos) : '\0';
        }

        void expect(char ch) {
            skipWs();
            if (pos >= text.length() || text.charAt(pos) != ch) {
                throw new StructuredSchemaParseException(
                        "expected '" + ch + "' at position " + pos + ": " + remaining());
            }
            pos++;
        }

        String remaining() {
            return pos < text.length() ? text.substring(pos) : "<end>";
        }
    }
}