package gudusoft.gsqlparser.util;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TGSqlParser;
import gudusoft.gsqlparser.dlineage.dataflow.model.ModelBindingManager;
import gudusoft.gsqlparser.dlineage.dataflow.model.SubType;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.table;
import gudusoft.gsqlparser.pp.para.GFmtOpt;
import gudusoft.gsqlparser.pp.para.GFmtOptFactory;
import gudusoft.gsqlparser.pp.para.styleenums.TCaseOption;
import gudusoft.gsqlparser.pp.stmtformatter.FormatterFactory;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierCodec;
import gudusoft.gsqlparser.sqlenv.IdentifierProfile;
import gudusoft.gsqlparser.sqlenv.IdentifierService;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;

import java.io.*;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.util.*;
import java.util.stream.Collectors;

public class SQLUtil {
    private static final Logger logger = LoggerFactory.getLogger(SQLUtil.class);


    public static String formatSql( EDbVendor dbVendor, String inputQuery )
    {
        String Result = inputQuery;
        TGSqlParser sqlparser = new TGSqlParser( dbVendor );
        sqlparser.sqltext = inputQuery;
        int ret = sqlparser.parse( );
        if ( ret == 0 )
        {
            GFmtOpt option = GFmtOptFactory.newInstance();
            option.caseFuncname = TCaseOption.CoNoChange;
            Result = FormatterFactory.pp(sqlparser, option);
        }
        return Result;
    }

    public static boolean isEmpty(String value) {
        return value == null || value.trim().length() == 0;
    }

    public static String getFileContent(File file) {
        String charset = null;
        String sqlfilename = file.getAbsolutePath();
        int read = 0;
        try {
            FileInputStream fr = new FileInputStream(sqlfilename);
            byte[] bom = new byte[4];
            fr.read(bom, 0, bom.length);

            if ((bom[0] == (byte) 0x00) && (bom[1] == (byte) 0x00) && (bom[2] == (byte) 0xFE)
                    && (bom[3] == (byte) 0xFF)) {
                charset = "UTF-32BE";
                read = 4;
            } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE) && (bom[2] == (byte) 0x00)
                    && (bom[3] == (byte) 0x00)) {
                charset = "UTF-32LE";
                read = 4;
            } else if ((bom[0] == (byte) 0xEF) && (bom[1] == (byte) 0xBB) && (bom[2] == (byte) 0xBF)) {
                charset = "UTF-8";
                read = 3;
            } else if ((bom[0] == (byte) 0xFE) && (bom[1] == (byte) 0xFF)) {
                charset = "UTF-16BE";
                read = 2;
            } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE)) {
                charset = "UTF-16LE";
                read = 2;
            } else {
                charset = "UTF-8";
                read = 0;
            }

            fr.close();
        } catch (IOException e) {
            logger.error("Check file encoding failed.", e);
        }

        Long filelength = file.length();
        byte[] filecontent = new byte[filelength.intValue()];
        try {
            InputStream in = new BufferedInputStream(new FileInputStream(sqlfilename));
            in.read(filecontent);
            in.close();
        } catch (IOException e) {
            logger.error("read file content failed.", e);
        }

        byte[] content = new byte[filelength.intValue() - read];
        System.arraycopy(filecontent, read, content, 0, content.length);

        try {
            String fileContent = new String(content, charset == null ? Charset.defaultCharset().name() : charset);
            return fileContent.replace((char) 160, (char) 32);
        } catch (UnsupportedEncodingException e) {
            logger.error("The OS does not support " + charset == null ? Charset.defaultCharset().name() : charset, e);
            return null;
        }
    }

    public static String getInputStreamContent(InputStream is, boolean close) {
        try {
            ByteArrayOutputStream out = new ByteArrayOutputStream(4096);
            byte[] tmp = new byte[4096];
            while (true) {
                int r = is.read(tmp);
                if (r == -1)
                    break;
                out.write(tmp, 0, r);
            }
            byte[] bytes = out.toByteArray();
            if (close) {
                is.close();
            }
            out.close();
            String content = new String(bytes);
            return content;
        } catch (IOException e) {
            logger.error("read inputStream failed.", e);
        }
        return null;
    }

    public static String getFileContent(String filePath) {
        if (filePath == null)
            return "";
        File file = new File(filePath);
        if (!file.exists() || file.isDirectory())
            return "";
        return getFileContent(file);
    }

    // Per-vendor default-flags profiles for quoteDottedName; profiles are
    // immutable, so sharing one instance per vendor is safe.
    private static final java.util.concurrent.ConcurrentHashMap<EDbVendor, IdentifierProfile>
            DEFAULT_PROFILES = new java.util.concurrent.ConcurrentHashMap<EDbVendor, IdentifierProfile>();

    private static IdentifierProfile defaultProfile(EDbVendor vendor) {
        IdentifierProfile profile = DEFAULT_PROFILES.get(vendor);
        if (profile == null) {
            profile = IdentifierProfile.forVendor(vendor, IdentifierProfile.VendorFlags.defaults());
            DEFAULT_PROFILES.putIfAbsent(vendor, profile);
        }
        return profile;
    }

    /**
     * Quote one name segment so its dots survive qualified-name splitting
     * ({@link #parseNames}), using the vendor's REAL quoted-identifier form.
     *
     * <p>This replaces the legacy
     * {@code delimitedChar + trimColumnStringQuote(x) + delimitedChar}
     * pattern, which used the OPEN delimiter on both ends and therefore
     * produced malformed spellings for open≠close vendors — MSSQL's
     * {@code [a.b[} — that only survived via lenient first/last-char
     * stripping and broke {@link #parseNames} segmentation
     * ({@code [a.b[.dbo} reads as ONE unterminated segment; the repaired
     * {@code [a.b].dbo} reads as two).
     *
     * <p>Existing quoting on the input is removed by a REAL decode where
     * possible: input the vendor's codec recognizes as quoted goes through
     * {@link IdentifierCodec#decodeLexical} (so embedded escaped delimiters
     * like {@code [a]]b.c]} decode to {@code a]b.c} and are not re-escaped
     * twice); malformed or vendor-foreign wrappers fall back to the lenient
     * legacy strip ({@link #trimColumnStringQuote}). The stored text is then
     * re-encoded with {@link IdentifierCodec#encodeStored} (proper close
     * delimiter and escaping).
     *
     * <p>A vendor with no quoted-identifier syntax at all (SOQL) gets the
     * stored text back UNCHANGED — the vendor cannot express a quoted
     * spelling, and manufacturing one here would plant strings the codec
     * itself refuses to recognize (a trap for the U5 recognition swap). A
     * dotted name for such a vendor is unrepresentable vendor-side; how it
     * segments internally is not this helper's contract.
     *
     * @param vendor database vendor
     * @param objectType syntactic role of the segment (catalog/schema/table/column)
     * @param name the possibly-quoted, possibly-dotted name segment
     * @return a quoted spelling whose interior dots are protected
     */
    public static String quoteDottedName(EDbVendor vendor, ESQLDataObjectType objectType, String name) {
        if (name == null) {
            return null;
        }
        IdentifierProfile profile = defaultProfile(vendor);
        String stored;
        if ((vendor == EDbVendor.dbvmssql || vendor == EDbVendor.dbvazuresql)
                && name.length() >= 2 && name.charAt(0) == '[' && name.charAt(name.length() - 1) == '[') {
            // the legacy synthetic spelling this program eradicates ([a.b[,
            // open delimiter on both ends, content raw and NEVER escaped —
            // it may contain literal ]): its stored text is the raw content.
            // Only the MSSQL/Azure producers ever emitted this shape; for
            // any other vendor brackets are ordinary characters.
            stored = name.substring(1, name.length() - 1);
        } else if (IdentifierCodec.isQuoted(profile, objectType, name)) {
            try {
                stored = IdentifierCodec.decodeLexical(profile, objectType, name);
            } catch (IllegalArgumentException e) {
                // other malformed quoted spellings: lenient legacy strip
                stored = trimColumnStringQuote(name);
            }
        } else {
            // bare, or wrapped in a quote form this vendor does not use
            // (metadata sources are sloppy): legacy strip handles both
            stored = trimColumnStringQuote(name);
        }
        if (vendor == EDbVendor.dbvbigquery) {
            // These strings are INTERNAL qualified-name keys in the
            // parseNames domain, whose backtick grammar is doubling-based.
            // BigQuery's VENDOR-lexical escape is backslash-style
            // (IdentifierCodec), which parseNames must not adopt — the same
            // bytes mean something else for MySQL backticks. Encode BigQuery
            // internal keys with parseNames-domain doubling instead (for the
            // dot-protection case this equals the legacy backtick wrap;
            // BigQuery object IDs cannot contain backticks, so the escape
            // divergence is unreachable in vendor-valid data).
            return "`" + stored.replace("`", "``") + "`";
        }
        if (IdentifierCodec.hasQuotedForm(profile, objectType)) {
            return IdentifierCodec.encodeStored(profile, objectType, stored);
        }
        return stored;
    }

    /**
     * Decode a delimited identifier spelling to the undelimited name a catalog
     * stores, WITHOUT case folding: {@code [Volgorde]}, {@code "Volgorde"},
     * {@code `Volgorde`} and the SQL Server legacy column-alias form
     * {@code 'Volgorde'} all decode to {@code Volgorde}, and escaped delimiters
     * resolve ({@code [Esc]]aped]} → {@code Esc]aped}).
     *
     * <p>This is the decode half of {@link #normalizeIdentifier}, split out for
     * callers that publish a DISPLAY name and must therefore preserve the
     * author's letter case — dlineage's column names, whose consumers match
     * them against {@code sys.columns} and other catalog assets. Recognition is
     * vendor- and role-aware, so a form that is not a delimiter for the vendor
     * is left alone (brackets are array subscripts, not delimiters, in
     * BigQuery).
     *
     * <p>Input that the vendor's codec does not recognize as quoted, or that
     * starts with a delimiter but is malformed ({@code [a.b[}), is returned
     * UNCHANGED — guessing a payload by stripping the first and last code units
     * is the fabrication this program removed.
     *
     * <p><b>The caller owns identifier provenance.</b> Only pass a string that
     * came from an identifier token (a {@code TObjectName} part token or a
     * {@code TAliasClause} alias name). A SQL string literal renders as quoted
     * text too, and decoding one would silently corrupt the VALUE — for SQL
     * Server, {@code 'literal value'} is a legal column alias spelling AND a
     * legal string constant, and nothing in the string itself tells them apart.
     *
     * @param vendor     database vendor
     * @param objectType syntactic role of the name (quote rules are per-role:
     *                   the SQL Server apostrophe form is recognized for
     *                   {@code dotColumn} only)
     * @param name       a single, possibly-delimited name segment
     * @return the decoded name, or {@code name} unchanged when it is not a
     *         well-formed delimited spelling for this vendor and role
     */
    public static String decodeDelimitedName(EDbVendor vendor, ESQLDataObjectType objectType, String name) {
        if (name == null || name.isEmpty()) {
            return name;
        }
        IdentifierProfile profile = defaultProfile(vendor);
        try {
            return IdentifierCodec.decodeLexical(profile, objectType, name);
        } catch (IllegalArgumentException e) {
            return name;
        }
    }

    public static String trimColumnStringQuote(String string) {
        try {
            if (string == null)
                return string;

            if (string.indexOf('.') != -1) {
                List<String> splits = parseNames(string);
                if (splits.size() > 1) {
                    StringBuilder buffer = new StringBuilder();
                    for (int i = 0; i < splits.size(); i++) {
                        String segment = splits.get(i);
                        if (parseNames(trimColumnStringQuote(segment)).size() > 1) {
                            buffer.append(segment);
                        } else {
                            buffer.append(trimColumnStringQuote(segment));
                        }
                        if (i < splits.size() - 1) {
                            buffer.append(".");
                        }
                    }
                    string = buffer.toString();
                    return string;
                }
            }
            if (string.length() < 2) {
                return string;
            }
            if (string.startsWith("'") && string.endsWith("'"))
                return string.substring(1, string.length() - 1);
            else if (string.startsWith("\"") && string.endsWith("\""))
                return string.substring(1, string.length() - 1);
            else if (string.startsWith("`") && string.endsWith("`"))
                return string.substring(1, string.length() - 1);
            else if (string.startsWith("[") && string.endsWith("]"))
                return string.substring(1, string.length() - 1);
            return string;
        }catch (Exception e){
            return string;
        }
    }

//    public static List<String> parseNames(String nameString, EDbVendor vendor) {
//        List<String> names = new ArrayList<String>();
//        if (nameString.startsWith("`") && nameString.endsWith("`")){
//            nameString = nameString.substring(1,nameString.length()-1);
//        }
//        String[] splits = nameString.trim().split("\\.");
//
//        for (int i = 0; i < splits.length; i++) {
//            String split = splits[i].trim();
//            if (TSQLEnv.isDelimitedIdentifier(vendor, split) && !TSQLEnv.endsWithDelimitedIdentifier(vendor, split)) {
//                StringBuilder buffer = new StringBuilder();
//                buffer.append(splits[i]);
//                while (i < splits.length - 1
//                        && !TSQLEnv.endsWithDelimitedIdentifier(vendor, split = splits[++i].trim())) {
//                    buffer.append(".");
//                    buffer.append(splits[i]);
//                }
//
//                buffer.append(".");
//                buffer.append(splits[i]);
//
//                names.add(buffer.toString());
//                continue;
//            }
//            names.add(splits[i]);
//        }
//        return names;
//    }

    public static List<String> parseNames(String nameString) {
        return parseNames(nameString, null);
    }

    // Manual dot-split: faster than Pattern.split() for "\\s*\\.\\s*"
    // Only trims whitespace around dots, NOT leading/trailing whitespace of the whole string
    private static String[] dotSplit(String s) {
        java.util.List<String> parts = new java.util.ArrayList<String>(4);
        int segStart = 0;
        int len = s.length();
        for (int i = 0; i < len; i++) {
            if (s.charAt(i) == '.') {
                // Trim whitespace on the left side of the dot
                int end = i;
                while (end > segStart && s.charAt(end - 1) <= ' ') end--;
                parts.add(s.substring(segStart, end));
                // Skip whitespace on the right side of the dot
                segStart = i + 1;
                while (segStart < len && s.charAt(segStart) <= ' ') segStart++;
                i = segStart - 1;
            }
        }
        // Last segment: keep trailing whitespace as-is (matches Pattern.split behavior)
        parts.add(s.substring(segStart, len));
        return parts.toArray(new String[0]);
    }
    
// Cache for parseNames results - uses ConcurrentHashMap for high concurrency
    private static final java.util.concurrent.ConcurrentHashMap<String, List<String>> PARSE_NAMES_CACHE =
        new java.util.concurrent.ConcurrentHashMap<String, List<String>>(256);
    private static final int MAX_CACHE_SIZE = 10000;
    private static final int CACHE_EVICT_BATCH = 1000;

    /**
     * 解析以点号分隔的 SQL 标识符或表达式，并返回各层级片段。
     * <p>
     * 用途：
     * <ul>
     *   <li>将类似 catalog.schema.table.column 的全限定名拆分为有序片段；</li>
     *   <li>在拆分时识别并保留引号/括号内的点号，不做误分割；</li>
     *   <li>根据不同数据库厂商（如 BigQuery）的定界符规则进行处理。</li>
     * </ul>
     * 工作机制：
     * <ol>
     *   <li>按「可选空格 + '.' + 可选空格」初步切分；</li>
     *   <li>对以下情况进行片段合并直至遇到闭合符号：
     *     <ul>
     *       <li>单引号字符串：'...'</li>
     *       <li>双引号定界标识符："..."</li>
     *       <li>反引号定界标识符：`...`</li>
     *       <li>方括号定界标识符：[...]</li>
     *       <li>函数/表达式括号：(...)</li>
     *     </ul>
     *   </li>
     *   <li>BigQuery（vendor == dbvbigquery）且包含反引号时，会先去除反引号再进行切分。</li>
     *   <li>入参为 null 返回空列表；发生异常时返回仅包含原始字符串的列表。</li>
     * </ol>
     * 示例：
     * <pre>
     *  "dbo.Employee.Name"                    -> ["dbo", "Employee", "Name"]
     *  "[Sales DB].[Employee].[Name]"        -> ["[Sales DB]", "[Employee]", "[Name]"]
     *  "\"My.Schema\".\"My.Table\""       -> ["\"My.Schema\"", "\"My.Table\""]
     *  "`project.dataset.table`" (BigQuery)  -> ["project", "dataset", "table"]
     *  "OPENJSON(aptd.test.ActiviteTypeIDs)" -> ["OPENJSON(aptd.test.ActiviteTypeIDs)"]
     * </pre>
     *
     * @param nameString 待解析的标识符或表达式字符串
     * @param vendor 数据库厂商（用于处理厂商特定定界符，如 BigQuery 的反引号），可为 null
     * @return 解析后的片段列表；顺序与层级一致
     */
    public static List<String> parseNames(String nameString, EDbVendor vendor) {
        if(nameString == null){
            return Collections.emptyList();
        }
        
        // Cache lookup - use a simple cache key
        String cacheKey = vendor == null ? nameString : (vendor.ordinal() + ":" + nameString);
        List<String> cached = PARSE_NAMES_CACHE.get(cacheKey);
        if (cached != null) {
            return new ArrayList<String>(cached);
        }
        
        // Only trim when necessary (avoid allocation for already-trimmed strings)
        String name = nameString;
        int len = nameString.length();
        if (len > 0 && (nameString.charAt(0) <= ' ' || nameString.charAt(len - 1) <= ' ')) {
            name = nameString.trim();
            len = name.length();
        }
        
        // Fast path: simple names without special characters
        // Check once for all special characters in a single pass, with early exit
        boolean hasSpecialChar = false;
        boolean hasSingleQuote = false;
        boolean hasDoubleQuote = false;
        boolean hasBacktick = false;
        boolean hasParenthesis = false;
        boolean hasBracket = false;
        int flagsRemaining = 5; // singleQuote, doubleQuote, backtick, parenthesis, bracket
        
        for (int i = 0; i < len; i++) {
            char c = name.charAt(i);
            switch (c) {
                case '\'':
                    if (!hasSingleQuote) { hasSingleQuote = true; flagsRemaining--; }
                    hasSpecialChar = true;
                    break;
                case '"':
                    if (!hasDoubleQuote) { hasDoubleQuote = true; flagsRemaining--; }
                    hasSpecialChar = true;
                    break;
                case '`':
                    if (!hasBacktick) { hasBacktick = true; flagsRemaining--; }
                    hasSpecialChar = true;
                    break;
                case '(':
                case ')':
                    if (!hasParenthesis) { hasParenthesis = true; flagsRemaining--; }
                    hasSpecialChar = true;
                    break;
                case '[':
                case ']':
                    if (!hasBracket) { hasBracket = true; flagsRemaining--; }
                    hasSpecialChar = true;
                    break;
            }
            if (flagsRemaining == 0) {
                break;
            }
        }
        
        List<String> names = new ArrayList<String>(4); // Pre-size for typical case
        
        // Handle BigQuery special case
        if (vendor == EDbVendor.dbvbigquery && hasBacktick) {
            String[] parts = dotSplit(name.replace("`", ""));
            for (String part : parts) {
                names.add(part);
            }
            return putCache(cacheKey, names);
        }
        
        try {
            // Fast path: no special characters
            if (!hasSpecialChar) {
                String[] splits = dotSplit(nameString);
                for (String split : splits) {
                    names.add(split);
                }
                return putCache(cacheKey, names);
            }

            // Legacy sentinel: a lone quoted dot means the dot itself
            if ("'.'".equals(name) || "`.`".equals(name)
                    || "\".\"".equals(name) || "[.]".equals(name)) {
                names = Arrays.asList(".");
                return putCache(cacheKey, names);
            }

            names = segmentQualifiedName(nameString);
        } catch (Throwable e) {
            names.clear();
            names.add(nameString);
        }

        return putCache(cacheKey, names);
    }

    /**
     * Single-pass, enclosure-state qualified-name segmenter: splits on dots
     * only at top level, tracking ALL enclosure kinds simultaneously —
     * {@code '…'}, {@code "…"}, {@code `…`}, {@code […]} (a doubled close
     * delimiter inside an enclosure is an escaped literal and does not
     * close it) and parenthesis nesting for expressions. This replaces the
     * old one-delimiter-type-per-string dispatch, which mis-segmented names
     * mixing delimiter characters ({@code [O'Reilly.a].dbo} split at the
     * apostrophe handler before the bracket handler could see it).
     *
     * <p>An unterminated enclosure swallows the rest of the string into the
     * current segment (the historical behavior malformed inputs relied on).
     * A closed enclosure that OPENED the segment may only be followed by
     * optional whitespace and a continuation character
     * ({@link #isQualifiedNameContinuation}: dot, {@code @dblink}, another
     * enclosure) or the end of the string — anything else (operators, bare
     * identifier text) means the input is an EXPRESSION, not a qualified
     * name, and the whole string is returned as one segment. This is
     * historical contract: dlineage names expression pseudo-columns by the
     * full expression text ({@code 'inserted ' || id.*::text}), and
     * segment-splitting such text truncated lineage display names (U5
     * dataflow-golden gate, postgresql/IC8XB0). An enclosure opening
     * MID-segment gets no such check — {@code SCHEMA_NAME(id) + '.' +
     * st.name} splits with every segment quote-balanced, the MantisBT 4496
     * contract. Whitespace around TOP-LEVEL dots is trimmed exactly like
     * {@link #dotSplit}; text inside enclosures is preserved verbatim.
     */
    private static List<String> segmentQualifiedName(String s) {
        List<String> names = new ArrayList<String>(4);
        int len = s.length();
        int segStart = 0;
        int parenDepth = 0;
        char enclosing = 0;   // 0 = none; otherwise the OPEN char: ' " ` [
        // STICKY per segment: true once an enclosure opens with nothing but
        // whitespace before it in the segment. Leading whitespace must not
        // defeat the check (the input arrives untrimmed), and a later
        // mid-segment opening must not clear it ("q" "r"x.s is still a
        // quote-led segment gone wrong) — Codex U5 round-2 finding 1.
        boolean segmentQuoteLed = false;
        for (int i = 0; i < len; i++) {
            char c = s.charAt(i);
            if (enclosing != 0) {
                char close = enclosing == '[' ? ']' : enclosing;
                if (c == close) {
                    if (i + 1 < len && s.charAt(i + 1) == close) {
                        i++;   // doubled close delimiter: escaped literal
                    } else {
                        enclosing = 0;
                        if (parenDepth == 0 && segmentQuoteLed) {
                            int j = i + 1;
                            while (j < len && s.charAt(j) <= ' ') {
                                j++;
                            }
                            if (j < len && !isQualifiedNameContinuation(s.charAt(j))) {
                                // A segment that IS a quoted form, followed by
                                // operator or bare identifier text: the input
                                // is an expression, not a qualified name.
                                names.clear();
                                names.add(s);
                                return names;
                            }
                        }
                    }
                }
                continue;
            }
            switch (c) {
                case '\'':
                case '"':
                case '`':
                case '[':
                    enclosing = c;
                    // A quote opening MID-segment (after non-whitespace
                    // content, e.g. the '.' literal in SCHEMA_NAME(id) + '.'
                    // + st.name, MantisBT 4496) keeps the historical
                    // split-and-merge behavior; only a segment whose first
                    // non-whitespace text IS a quoted form claims the whole
                    // input when followed by expression text. That includes
                    // the vendor-prefixed openers — PostgreSQL U&"…"/u&"…"
                    // and Power Query #"…" — whose quote char sits 1-2 chars
                    // after the segment start (Codex U5 round-3 finding 1).
                    if (!segmentQuoteLed && parenDepth == 0) {
                        int k = segStart;
                        while (k < i && s.charAt(k) <= ' ') {
                            k++;
                        }
                        segmentQuoteLed = (k == i)
                                || (c == '"' && i - k == 2
                                    && (s.charAt(k) == 'U' || s.charAt(k) == 'u')
                                    && s.charAt(k + 1) == '&')
                                || (c == '"' && i - k == 1 && s.charAt(k) == '#');
                    }
                    break;
                case '(':
                    parenDepth++;
                    break;
                case ')':
                    if (parenDepth > 0) {
                        parenDepth--;
                    }
                    break;
                case '.':
                    if (parenDepth == 0) {
                        // trim whitespace on the left side of the dot
                        int end = i;
                        while (end > segStart && s.charAt(end - 1) <= ' ') {
                            end--;
                        }
                        names.add(s.substring(segStart, end));
                        // skip whitespace on the right side of the dot
                        segStart = i + 1;
                        while (segStart < len && s.charAt(segStart) <= ' ') {
                            segStart++;
                        }
                        i = segStart - 1;
                        segmentQuoteLed = false; // new segment, new state
                    }
                    break;
                default:
                    break;
            }
        }
        names.add(s.substring(segStart, len));
        return names;
    }

    /**
     * May this character follow a CLOSED enclosure inside a well-formed
     * qualified name (after optional whitespace)? The set is the historical
     * contract measured against the pre-U2b segmenter: a top-level dot
     * (segment boundary), an Oracle {@code @dblink} continuation
     * ({@code HR."EMPLOYEES"@"LD_PDB1.LOCALDOMAIN"}), or another enclosure
     * opening ({@code "q" "r".s}). Operators and bare identifier text
     * ({@code 'a'||b}, {@code "a"x}, {@code [a]b}) mean the whole input is an
     * expression, which callers expect back as ONE unsplit segment.
     */
    private static boolean isQualifiedNameContinuation(char c) {
        return c == '.' || c == '@' || c == '\'' || c == '"' || c == '`' || c == '[';
    }

    /**
     * Return the cached parse result for internal read-only consumers.
     *
     * <p>{@link #parseNames(String, EDbVendor)} intentionally returns a copy on
     * a cache hit because callers have historically been free to mutate the
     * returned list. Identifier normalization only reads the segments, so
     * copying the same cached list for every column is unnecessary.</p>
     *
     * <p>To make skipping the copy provably safe, this method always returns an
     * <b>unmodifiable</b> list. On a cache hit that is a zero-copy read-only
     * <i>view</i> over the shared cached list, so callers cannot corrupt the
     * cache (any mutating call throws) while still avoiding the defensive copy.
     * This is why the method is restricted to read-only internal consumers.</p>
     */
    private static List<String> parseNamesReadOnly(String nameString, EDbVendor vendor) {
        if (nameString == null) {
            return Collections.emptyList();
        }

        String cacheKey = vendor == null ? nameString : (vendor.ordinal() + ":" + nameString);
        List<String> cached = PARSE_NAMES_CACHE.get(cacheKey);
        if (cached != null) {
            return Collections.unmodifiableList(cached);
        }

        List<String> parsed = parseNames(nameString, vendor);
        cached = PARSE_NAMES_CACHE.get(cacheKey);
        return Collections.unmodifiableList(cached != null ? cached : new ArrayList<String>(parsed));
    }

        protected static List<String> putCache(String cacheKey, List<String> names) {
            // Simple eviction: when cache exceeds limit, remove a batch of entries
            if (PARSE_NAMES_CACHE.size() >= MAX_CACHE_SIZE) {
                java.util.Iterator<String> it = PARSE_NAMES_CACHE.keySet().iterator();
                for (int i = 0; i < CACHE_EVICT_BATCH && it.hasNext(); i++) {
                    it.next();
                    it.remove();
                }
            }
            // Store immutable copy in cache, but return a mutable copy to the caller
            PARSE_NAMES_CACHE.put(cacheKey, Collections.unmodifiableList(new ArrayList<String>(names)));
            return new ArrayList<String>(names);
        }
    
    
    /**
     * A delimited segment is truly CLOSED only when it ends with an ODD run
     * of the close delimiter: every vendor whose quoted identifiers this
     * splitter merges escapes the close delimiter by doubling it, so a
     * trailing even run is escaped literal content and the segment
     * continues ({@code [a]]} is an open bracket segment whose content so
     * far is {@code a]}; {@code [a]]]} is closed with content {@code a]}).
     *
     * @param seg the (trimmed) piece to examine
     * @param contentFrom index where content starts (1 for the piece that
     *                    carries the opening delimiter, 0 for merge pieces)
     * @param endDelim the close delimiter
     */
    
        
        
        public static void main(String[] args) {
                SQLUtil.parseNames("OPENJSON(aptd.test.ActiviteTypeIDs)");
        }

    public static void writeToFile(File file, InputStream source, boolean close) {
        BufferedInputStream bis = null;
        BufferedOutputStream fouts = null;
        try {
            bis = new BufferedInputStream(source);
            if (!file.exists()) {
                if (!file.getParentFile().exists()) {
                    file.getParentFile().mkdirs();
                }
                file.createNewFile();
            }
            fouts = new BufferedOutputStream(new FileOutputStream(file));
            byte b[] = new byte[1024];
            int i = 0;
            while ((i = bis.read(b)) != -1) {
                fouts.write(b, 0, i);
            }
            fouts.flush();
            fouts.close();
            if (close)
                bis.close();
        } catch (IOException e) {
            logger.error("Write file failed.", e);
            try {
                if (fouts != null)
                    fouts.close();
            } catch (IOException f) {
                logger.error("Close output stream failed.", f);
            }
            if (close) {
                try {
                    if (bis != null)
                        bis.close();
                } catch (IOException f) {
                    logger.error("Close input stream failed.", f);
                }
            }
        }
    }

    public static void writeToFile(File file, String string) throws IOException {

        if (!file.exists()) {
            if (!file.getParentFile().exists()) {
                file.getParentFile().mkdirs();
            }
            file.createNewFile();
        }
        PrintWriter out = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file)));
        if (string != null)
            out.print(string);
        out.close();
    }

    public static void appendToFile(File file, String string) throws IOException {

        if (!file.exists()) {
            if (!file.getParentFile().exists()) {
                file.getParentFile().mkdirs();
            }
            file.createNewFile();
        }
        PrintWriter out = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file, true)));
        if (string != null)
            out.println(string);
        out.close();
    }

    public static void deltree(File root) {
        if (root == null || !root.exists()) {
            return;
        }

        if (root.isFile()) {
            root.delete();
            return;
        }

        File[] children = root.listFiles();
        if (children != null) {
            for (int i = 0; i < children.length; i++) {
                deltree(children[i]);
            }
        }

        root.delete();
    }

    public static InputStream getInputStreamWithoutBom(String file) throws IOException {
        UnicodeInputStream stream = null;
        FileInputStream fis = new FileInputStream(file);
        stream = new UnicodeInputStream(fis, null);
        return stream;
    }

    public static class UnicodeInputStream extends InputStream {
        PushbackInputStream internalIn;
        boolean isInited = false;
        String defaultEnc;
        String encoding;

        private static final int BOM_SIZE = 4;

        public UnicodeInputStream(InputStream in, String defaultEnc) {
            internalIn = new PushbackInputStream(in, BOM_SIZE);
            this.defaultEnc = defaultEnc;
        }

        public String getDefaultEncoding() {
            return defaultEnc;
        }

        public String getEncoding() {
            if (!isInited) {
                try {
                    init();
                } catch (IOException ex) {
                    IllegalStateException ise = new IllegalStateException("Init method failed.");
                    ise.initCause(ise);
                    throw ise;
                }
            }
            return encoding;
        }

        protected void init() throws IOException {
            if (isInited)
                return;

            byte bom[] = new byte[BOM_SIZE];
            int n, unread;
            n = internalIn.read(bom, 0, bom.length);

            if ((bom[0] == (byte) 0x00) && (bom[1] == (byte) 0x00) && (bom[2] == (byte) 0xFE)
                    && (bom[3] == (byte) 0xFF)) {
                encoding = "UTF-32BE";
                unread = n - 4;
            } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE) && (bom[2] == (byte) 0x00)
                    && (bom[3] == (byte) 0x00)) {
                encoding = "UTF-32LE";
                unread = n - 4;
            } else if ((bom[0] == (byte) 0xEF) && (bom[1] == (byte) 0xBB) && (bom[2] == (byte) 0xBF)) {
                encoding = "UTF-8";
                unread = n - 3;
            } else if ((bom[0] == (byte) 0xFE) && (bom[1] == (byte) 0xFF)) {
                encoding = "UTF-16BE";
                unread = n - 2;
            } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE)) {
                encoding = "UTF-16LE";
                unread = n - 2;
            } else {
                encoding = defaultEnc;
                unread = n;
            }

            if (unread > 0)
                internalIn.unread(bom, (n - unread), unread);

            isInited = true;
        }

        public void close() throws IOException {
            internalIn.close();
        }

        public int read() throws IOException {
            return internalIn.read();
        }
    }

    /**
     * Single-segment SQL identifier equality — the unified façade for
     * identifier-vs-identifier name comparisons (see
     * docs/refactor/identifier_normalization_unification_plan.md).
     *
     * <p>Both arguments must be a single name segment (no {@code a.b} qualification);
     * qualified names are segmented by {@link #compareIdentifier(EDbVendor,
     * ESQLDataObjectType, String, String)}, which compares segment by segment.
     *
     * <p><strong>POLICY: CANONICAL (since P0d.2).</strong> Equality is canonical-key
     * equality ({@link #canonKey}): each operand is quote-stripped and folded by its own
     * quote state under the vendor's identifier rules, then compared exactly. The
     * relation is an equivalence relation, safe as a map-key contract, and matches how
     * names are stored (Oracle unquoted {@code foo} ≡ quoted {@code "FOO"}, never
     * {@code "foo"}).
     *
     * @param dbVendor   database vendor whose identifier rules apply
     * @param objectType kind of database object the names refer to
     * @param ident1     first identifier segment (may be quoted)
     * @param ident2     second identifier segment (may be quoted)
     * @return true if the two names refer to the same object under the vendor's
     *         canonical comparison rules
     */
    public static boolean sameName(EDbVendor dbVendor, ESQLDataObjectType objectType,
                                   String ident1, String ident2) {
        return TSQLEnv.compareIdentifier(dbVendor, objectType, ident1, ident2);
    }

    /**
     * Canonical identity key of a single identifier segment — key equality is exactly
     * {@link #sameName} (see {@link gudusoft.gsqlparser.sqlenv.CanonKey}; in-process
     * only, never persist).
     */
    public static gudusoft.gsqlparser.sqlenv.CanonKey canonKey(EDbVendor dbVendor,
            ESQLDataObjectType objectType, String identifier) {
        return IdentifierService.canonKeyStatic(dbVendor, objectType, identifier);
    }

    public static boolean compareIdentifier(EDbVendor dbVendor, ESQLDataObjectType sqlDataObjectType,
                                            String identifier1, String identifier2) {
        List<String> segments1 = parseNames(identifier1);
        List<String> segments2 = parseNames(identifier2);

        if (segments1.size() != segments2.size())
            return false;

        boolean supportCatalog = TSQLEnv.supportCatalog(dbVendor);
        boolean supportSchema = TSQLEnv.supportSchema(dbVendor);

        if(supportCatalog && supportSchema) {
            if (sqlDataObjectType == ESQLDataObjectType.dotColumn) {
                if (segments1.size() > 4) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(2),
                            segments2.get(2))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, mergeSegments(segments1, 3),
                            mergeSegments(segments2, 3));
                } else if (segments1.size() == 4) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(2),
                            segments2.get(2))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(3),
                            segments2.get(3));
                } else if (segments1.size() == 3) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(2),
                            segments2.get(2));
                } else if (segments1.size() == 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(1),
                            segments2.get(1));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(0),
                            segments2.get(0));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotTable
                        || sqlDataObjectType == ESQLDataObjectType.dotSynonyms
                    || sqlDataObjectType == ESQLDataObjectType.dotOraclePackage
                    || sqlDataObjectType == ESQLDataObjectType.dotFunction
                    || sqlDataObjectType == ESQLDataObjectType.dotProcedure
                    || sqlDataObjectType == ESQLDataObjectType.dotTrigger) {
                if (segments1.size() > 3) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments1, 2), mergeSegments(segments2, 2));
                } else if (segments1.size() == 3) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(2), segments2.get(2));
                } else if (segments1.size() == 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(1), segments2.get(1));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(0), segments2.get(0));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotSchema) {
                if (segments1.size() > 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments1, 1), mergeSegments(segments2, 1));
                } else if (segments1.size() == 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(1), segments2.get(1));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(0), segments2.get(0));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotCatalog) {
                if (segments1.size() > 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments1, 0), mergeSegments(segments2, 0));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(0), segments2.get(0));
                }
            }
        }
        else if(supportCatalog){
            if (sqlDataObjectType == ESQLDataObjectType.dotColumn) {
                if (segments1.size() > 3) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, mergeSegments(segments1, 2),
                            mergeSegments(segments2, 2));
                } else if (segments1.size() == 3) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(2),
                            segments2.get(2));
                } else if (segments1.size() == 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(1),
                            segments2.get(1));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(0),
                            segments2.get(0));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotTable
                        || sqlDataObjectType == ESQLDataObjectType.dotSynonyms
                    || sqlDataObjectType == ESQLDataObjectType.dotOraclePackage
                    || sqlDataObjectType == ESQLDataObjectType.dotFunction
                    || sqlDataObjectType == ESQLDataObjectType.dotProcedure
                    || sqlDataObjectType == ESQLDataObjectType.dotTrigger) {
                if (segments1.size() > 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments1, 1), mergeSegments(segments2, 1));
                } else if (segments1.size() == 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(1), segments2.get(1));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(0), segments2.get(0));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotCatalog || sqlDataObjectType == ESQLDataObjectType.dotSchema) {
                if (segments1.size() > 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, mergeSegments(segments1, 0), mergeSegments(segments2, 0));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0), segments2.get(0));
                }
            }
        }
        else if(supportSchema){
            if (sqlDataObjectType == ESQLDataObjectType.dotColumn) {
                if (segments1.size() > 3) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, mergeSegments(segments1, 2),
                            mergeSegments(segments2, 2));
                } else if (segments1.size() == 3) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(2),
                            segments2.get(2));
                } else if (segments1.size() == 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(1),
                            segments2.get(1));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(0),
                            segments2.get(0));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotTable
                        || sqlDataObjectType == ESQLDataObjectType.dotSynonyms
                    || sqlDataObjectType == ESQLDataObjectType.dotOraclePackage
                    || sqlDataObjectType == ESQLDataObjectType.dotFunction
                    || sqlDataObjectType == ESQLDataObjectType.dotProcedure
                    || sqlDataObjectType == ESQLDataObjectType.dotTrigger) {
                if (segments1.size() > 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments1, 1), mergeSegments(segments2, 1));
                } else if (segments1.size() == 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(1), segments2.get(1));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(0), segments2.get(0));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotCatalog || sqlDataObjectType == ESQLDataObjectType.dotSchema) {
                if (segments1.size() > 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, mergeSegments(segments1, 0), mergeSegments(segments2, 0));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(0), segments2.get(0));
                }
            }
        }
        return false;
    }

    /**
     * Legacy "normal name" builder: canonical normalize, then collapse to UPPER when the
     * (vendor, objectType) domain is case-insensitive — the pre-{@link
     * gudusoft.gsqlparser.sqlenv.CanonKey} map-key convention. Multi-segment inputs are returned in their origin (only case-collapsed)
     * form.
     *
     * @deprecated For equality tests use {@link #sameName(EDbVendor, ESQLDataObjectType,
     * String, String)} / {@link #compareIdentifier(EDbVendor, ESQLDataObjectType, String,
     * String)} — never normalize-then-compare. For map keys use {@link #canonKey(EDbVendor,
     * ESQLDataObjectType, String)} (or {@link IdentifierService#keyForMap(String,
     * ESQLDataObjectType)}); for the stored/display form use
     * {@link IdentifierService#normalizeStatic(EDbVendor, ESQLDataObjectType, String)}.
     * Retained only for callers that persist the legacy normal form (e.g. dlineage
     * display names — see the identifier normalization guide §6).
     */
    @Deprecated
    public static String normalizeIdentifier(EDbVendor dbVendor, ESQLDataObjectType objectType, String identifier) {
        if (identifier == null)
            return null;
        String originIdentifier = identifier;
        identifier = IdentifierService.normalizeStatic(dbVendor, objectType, identifier);
        boolean collationSensitive = false;
        switch (objectType) {
            case dotCatalog:
            case dotSchema:
                collationSensitive = TSQLEnv.catalogCollationCaseSensitive.get(dbVendor);
                break;
            case dotFunction:
            case dotProcedure:
            case dotTrigger:
            case dotTable:
            case dotSynonyms:   
            case dotOraclePackage:
                collationSensitive = TSQLEnv.tableCollationCaseSensitive.get(dbVendor);
                break;
            case dotColumn:
                collationSensitive = TSQLEnv.columnCollationCaseSensitive.get(dbVendor);
                break;
            default:
                collationSensitive = TSQLEnv.defaultCollationCaseSensitive.get(dbVendor);
                break;
        }
        if(parseNamesReadOnly(identifier, null).size()>1) {
            return collationSensitive ? originIdentifier : originIdentifier.toUpperCase(Locale.ROOT);
        }
        else {
            return collationSensitive ? identifier : identifier.toUpperCase(Locale.ROOT);
        }
    }

    /**
     * Legacy display/normal-name form of a column reference. NOT an equality primitive:
     * comparing two normal names with {@code equals}/{@code equalsIgnoreCase} is the
     * pre-P0d bug pattern — use {@link #sameName(EDbVendor, ESQLDataObjectType, String,
     * String)} / {@link #compareIdentifier(EDbVendor, ESQLDataObjectType, String, String)}
     * instead.
     */
    public static String getIdentifierNormalColumnName(EDbVendor dbVendor, String name) {
        return getIdentifierNormalName(dbVendor, name, ESQLDataObjectType.dotColumn);
    }

    /**
     * Legacy display/normal-name form of a table reference (global analysis vendor).
     * NOT an equality primitive — for equality use {@link #sameName(EDbVendor,
     * ESQLDataObjectType, String, String)} / {@link #compareIdentifier(EDbVendor,
     * ESQLDataObjectType, String, String)}, never string compares on this result.
     */
    public static String getIdentifierNormalTableName(String name) {
        return getIdentifierNormalName(ModelBindingManager.getGlobalVendor(), name, ESQLDataObjectType.dotTable);
    }

    /**
     * Legacy display/normal-name form of a table reference. NOT an equality primitive —
     * for equality use {@link #sameName(EDbVendor, ESQLDataObjectType, String, String)} /
     * {@link #compareIdentifier(EDbVendor, ESQLDataObjectType, String, String)}.
     */
    public static String getIdentifierNormalTableName(EDbVendor dbVendor, String name) {
        return getIdentifierNormalName(dbVendor, name, ESQLDataObjectType.dotTable);
    }

  /**
   * 规范化多段限定名（Multi-Segment Qualified Name）并返回规范化后的完整限定名。
   *
   * <h3>核心功能</h3>
   * <p>本方法是 SQL 标识符规范化的<b>多段名处理版本</b>，接受包含多段（catalog.schema.table.column）的限定名，
   * 根据数据库厂商特性、层级支持能力和对象类型，智能解析和规范化每个段，最后返回用点号连接的完整规范化名称。</p>
   *
   * <h3>处理流程</h3>
   * <ol>
   *   <li><b>厂商特定语法展开</b>：
   *       <ul>
   *         <li>MSSQL/Azure SQL: 将 ".." 语法展开为 ".dbo." 或全局配置的 schema</li>
   *         <li>示例：{@code "db..table"} → {@code "db.dbo.table"}</li>
   *       </ul>
   *   </li>
   *   <li><b>解析多段名</b>：使用 {@link #parseNames(String)} 将限定名按点号分割成段列表</li>
   *   <li><b>智能段类型推断</b>：根据以下因素决定每段的实际类型：
   *       <ul>
   *         <li>数据库厂商的层级支持能力（supportCatalog/supportSchema）</li>
   *         <li>目标对象类型（{@code sqlDataObjectType}）</li>
   *         <li>实际段数</li>
   *       </ul>
   *   </li>
   *   <li><b>逐段规范化</b>：对每段调用 {@link #normalizeIdentifier(EDbVendor, ESQLDataObjectType, String)}，
   *       应用厂商特定的大小写规则、引号处理等</li>
   *   <li><b>重组限定名</b>：用点号连接所有规范化后的段，返回完整的规范化限定名</li>
   * </ol>
   *
   * <h3>智能段类型推断示例</h3>
   * <p>假设数据库<b>同时支持 catalog 和 schema</b>，目标类型为 {@code dotTable}：</p>
   * <ul>
   *   <li>3段名 {@code "a.b.c"} → 解析为 {@code catalog.schema.table}</li>
   *   <li>2段名 {@code "a.b"} → 解析为 {@code schema.table}</li>
   *   <li>1段名 {@code "a"} → 解析为 {@code table}</li>
   * </ul>
   *
   * <p>假设数据库<b>仅支持 catalog</b>（如 MySQL），目标类型为 {@code dotTable}：</p>
   * <ul>
   *   <li>2段名 {@code "a.b"} → 解析为 {@code catalog.table}</li>
   *   <li>1段名 {@code "a"} → 解析为 {@code table}</li>
   * </ul>
   *
   * <p>假设数据库<b>仅支持 schema</b>（如 PostgreSQL），目标类型为 {@code dotTable}：</p>
   * <ul>
   *   <li>2段名 {@code "a.b"} → 解析为 {@code schema.table}</li>
   *   <li>1段名 {@code "a"} → 解析为 {@code table}</li>
   * </ul>
   *
   * <h3>对于 dotColumn 类型的特殊处理</h3>
   * <p>列名可能有4段（catalog.schema.table.column），方法会根据实际段数自动调整解析策略：</p>
   * <ul>
   *   <li>4段名 {@code "db.sch.tbl.col"} → {@code catalog.schema.table.column}</li>
   *   <li>3段名 {@code "sch.tbl.col"} → {@code schema.table.column}</li>
   *   <li>2段名 {@code "tbl.col"} → {@code table.column}</li>
   *   <li>1段名 {@code "col"} → {@code column}</li>
   * </ul>
   *
   * <h3>处理超长限定名</h3>
   * <p>当段数超过标准层级时（如表名有4段或更多），方法会使用 {@link #mergeSegments(List, int)}
   * 将多余的尾部段合并为单个段（保留点号），然后作为最后一段进行规范化。</p>
   * <p>示例：5段列名 {@code "db.sch.tbl.nested.col"} → 合并后4段处理：
   * {@code "db.sch.tbl.nested.col"} (最后两段合并为 {@code "nested.col"})</p>
   *
   * <h3>方法目的与使用场景</h3>
   * <ul>
   *   <li><b>目的</b>：为多段限定名提供统一的规范化接口，生成可用于比较、索引和查找的标准化名称</li>
   *   <li><b>输出特性</b>：返回<b>多段名</b>（用点号连接），保留层级结构信息</li>
   *   <li><b>使用场景</b>：
   *       <ul>
   *         <li>环境层（TSQLEnv）处理完整限定名</li>
   *         <li>名称比较和匹配（需要保留层级信息）</li>
   *         <li>快速索引查找（NameKey 构造）</li>
   *       </ul>
   *   </li>
   * </ul>
   *
   * <h3>与相关方法的区别</h3>
   * <ul>
   *   <li><b>{@link #normalizeIdentifier(EDbVendor, ESQLDataObjectType, String)}</b>：
   *       单段规范化，不解析限定名，直接处理引号和大小写，返回单段名</li>
   *   <li><b>{@code IdentifierService.keyForMap(String, ESQLDataObjectType)}</b>：
   *       仅接受单段名，用于生成 Map 的 key，会抛出异常如果输入是多段名</li>
   *   <li><b>{@code IdentifierService.normalizeQualifiedName(String, ESQLDataObjectType)}</b>：
   *       新架构中的等价方法，提供相同的多段名规范化功能</li>
   * </ul>
   *
   * <h3>厂商特定行为</h3>
   * <ul>
   *   <li><b>MySQL</b>: 仅支持 catalog（即 database），反引号引用，大小写根据系统变量决定</li>
   *   <li><b>PostgreSQL</b>: 仅支持 schema，双引号引用，未加引号的标识符转小写</li>
   *   <li><b>SQL Server</b>: 支持 catalog+schema，方括号或双引号引用，".." 展开为 ".dbo."</li>
   *   <li><b>Oracle</b>: 仅支持 schema，双引号引用，未加引号的标识符转大写</li>
   *   <li><b>Snowflake</b>: 支持 catalog+schema，双引号引用，大小写保留但匹配不敏感</li>
   *   <li><b>BigQuery</b>: 支持 catalog+schema（项目+数据集），反引号引用，大小写不敏感，可能内部转小写</li>
   * </ul>
   *
   * @param dbVendor 数据库厂商类型（决定层级支持、引号风格、大小写规则）
   * @param name 原始标识符或多段限定名（可能包含引号/反引号；可能包含 catalog/schema 前缀；
   *             可能包含厂商特定语法如 MSSQL 的 ".."）
   * @param sqlDataObjectType 期望的对象类型（例如 dotTable, dotColumn, dotSchema, dotCatalog），
   *                          用于指导段类型推断和规范化规则应用
   * @return 规范化后的完整限定名，用点号连接各段；如果输入为 {@code null}，返回 {@code null}；
   *         如果输入为空字符串或无法解析，返回空字符串
   *
   * <p><b>等价性警告（equality warning）</b>：本方法产出的是显示/存储用的规范名，
   * <b>不是</b>等价比较原语。判断两个名字是否指向同一数据库对象，请使用
   * {@link #compareIdentifier(EDbVendor, ESQLDataObjectType, String, String)}（多段限定名）
   * 或 {@link #sameName(EDbVendor, ESQLDataObjectType, String, String)}（单段），
   * 不要对两个规范名的返回值做 {@code equals}/{@code equalsIgnoreCase} 比较 —— 那是 P0d
   * 统一化之前的 bug 模式。详见 gsp_java_core/doc/user_guide/identifier_normalization_guide.md。
   *
   * @see #normalizeIdentifier(EDbVendor, ESQLDataObjectType, String) 单段规范化方法
   * @see #parseNames(String) 多段名解析方法
   * @see #mergeSegments(List, int) 段合并工具方法
   * @see TSQLEnv#normalizeIdentifier(EDbVendor, ESQLDataObjectType, String)
   * @see IdentifierService#normalizeQualifiedName(String, ESQLDataObjectType) Phase 0 新架构中的等价方法
   *
   * @since 3.1.0.8
   */
    public static String getIdentifierNormalName(EDbVendor dbVendor, String name,
                                                 ESQLDataObjectType sqlDataObjectType) {
        if (name == null) {
            return null;
        }
        if (dbVendor == EDbVendor.dbvmssql || dbVendor == EDbVendor.dbvazuresql) {
            if (name.indexOf("..") != -1) {
                if (ModelBindingManager.getGlobalSchema() != null) {
                    name = name.replace("..", "." + ModelBindingManager.getGlobalSchema() + ".");
                } else {
                    name = name.replace("..", ".dbo.");
                }
            }
        }
        List<String> segments = parseNamesReadOnly(name, null);
        StringBuilder builder = new StringBuilder();
        boolean supportCatalog = TSQLEnv.supportCatalog(dbVendor);
        boolean supportSchema = TSQLEnv.supportSchema(dbVendor);

        if(supportCatalog && supportSchema) {
            if (sqlDataObjectType == ESQLDataObjectType.dotColumn) {
                if (segments.size() > 4) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(1)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(2)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, mergeSegments(segments, 3)));
                } else if (segments.size() == 4) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(1)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(2)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(3)));
                } else if (segments.size() == 3) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(1)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(2)));
                } else if (segments.size() == 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(1)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(0)));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotTable
                        || sqlDataObjectType == ESQLDataObjectType.dotSynonyms
                    || sqlDataObjectType == ESQLDataObjectType.dotOraclePackage
                    || sqlDataObjectType == ESQLDataObjectType.dotFunction
                    || sqlDataObjectType == ESQLDataObjectType.dotProcedure
                    || sqlDataObjectType == ESQLDataObjectType.dotTrigger) {
                if (segments.size() > 3) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(1)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments, 2)));
                } else if (segments.size() == 3) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(1)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(2)));
                } else if (segments.size() == 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(0)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(1)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(0)));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotSchema) {
                if (segments.size() > 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments, 1)));
                } else if (segments.size() == 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(1)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(0)));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotCatalog) {
                if (segments.size() > 1) {
                    builder.append(normalizeIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments, 0)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(0)));
                }
            }
        }
        else if(supportCatalog){
            if (sqlDataObjectType == ESQLDataObjectType.dotColumn) {
                if (segments.size() > 3) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(1)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, mergeSegments(segments, 2)));
                } else if (segments.size() == 3) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(1)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(2)));
                } else if (segments.size() == 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(1)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(0)));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotTable
                        || sqlDataObjectType == ESQLDataObjectType.dotSynonyms
                    || sqlDataObjectType == ESQLDataObjectType.dotOraclePackage
                    || sqlDataObjectType == ESQLDataObjectType.dotFunction
                    || sqlDataObjectType == ESQLDataObjectType.dotProcedure
                    || sqlDataObjectType == ESQLDataObjectType.dotTrigger) {
                if (segments.size() > 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments, 1)));
                } else if (segments.size() == 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(1)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(0)));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotSchema || sqlDataObjectType == ESQLDataObjectType.dotCatalog) {
                if (segments.size() > 1) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, mergeSegments(segments, 0)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)));
                }
            }
        }
        else if(supportSchema){
            if (sqlDataObjectType == ESQLDataObjectType.dotColumn) {
                if (segments.size() > 3) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(1)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, mergeSegments(segments, 2)));
                } else if (segments.size() == 3) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(1)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(2)));
                } else if (segments.size() == 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(1)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(0)));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotTable
                        || sqlDataObjectType == ESQLDataObjectType.dotSynonyms
                    || sqlDataObjectType == ESQLDataObjectType.dotOraclePackage
                    || sqlDataObjectType == ESQLDataObjectType.dotFunction
                    || sqlDataObjectType == ESQLDataObjectType.dotProcedure
                    || sqlDataObjectType == ESQLDataObjectType.dotTrigger) {
                if (segments.size() > 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(0)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments, 1)));
                } else if (segments.size() == 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(0)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(1)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(0)));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotSchema || sqlDataObjectType == ESQLDataObjectType.dotCatalog) {
                if (segments.size() > 1) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, mergeSegments(segments, 0)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(0)));
                }
            }
        }
        return builder.toString();
    }

    public static String mergeSegments(List<String> segments, int index) {
        StringBuilder buffer = new StringBuilder();
                for (int i = index; i < segments.size(); i++) {
                        buffer.append(segments.get(i));
                        if(i<segments.size()-1) {
                                buffer.append(".");
                        }
                }
                return buffer.toString();
        }

//      public static String getIdentifierNormalName(EDbVendor vendor, String name) {
//              if (isEmpty(name)) {
//                      return null;
//              }
//              name = name.replaceAll("(?i)null\\.", "");
//              switch (vendor) {
//              case dbvbigquery:
//                      return replaceIdentifierNormalName(name, "`.*?`", "`", true).replaceAll("\\.\\s+", ".");
//              case dbvcouchbase:
//              case dbvhive:
//              case dbvimpala:
//              case dbvmysql:
//                      return replaceIdentifierNormalName(name, "`.*?`", "`", true).replaceAll("\\.\\s+", ".");
//              case dbvdax:
//                      return replaceIdentifierNormalName(name, "'.*?'", "'", true).replaceAll("\\.\\s+", ".");
//              case dbvdb2:
//              case dbvhana:
//              case dbvinformix:
//              case dbvnetezza:
//              case dbvoracle:
//              case dbvsnowflake:
//              case dbvsybase:
//              case dbvteradata:
//              case dbvvertica:
//                      return replaceIdentifierNormalName(name, "\".*?\"", "\"", true).replaceAll("\\.\\s+", ".");
//              case dbvpostgresql:
//              case dbvgreenplum:
//              case dbvredshift:
//                      return replaceIdentifierNormalName(name, "\".*?\"", "\"", false).replaceAll("\\.\\s+", ".");
//              case dbvmssql:
//                      return replaceIdentifierNormalName(name, "([\"\\[']).*?([\"\\]'])", "[\"\\[\\]']", true)
//                                      .replaceAll("\\.\\s+", ".");
//              default:
//                      return replaceIdentifierNormalName(name, "\".*?\"", "\"", true).replaceAll("\\.\\s+", ".");
//              }
//      }
//
//      private static String replaceIdentifierNormalName(String content, String match, String replace, boolean toUpper) {
//              Pattern pattern = Pattern.compile(match, Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
//              Matcher matcher = pattern.matcher(content);
//              StringBuilder buffer = new StringBuilder();
//              int start = 0;
//              while (matcher.find()) {
//                      int matchStart = matcher.start();
//                      int macthEnd = matcher.end();
//                      if (start < matchStart) {
//                              if (toUpper) {
//                                      buffer.append(content.substring(start, matchStart).toUpperCase());
//                              } else {
//                                      buffer.append(content.substring(start, matchStart).toLowerCase());
//                              }
//                      }
//                      buffer.append(matcher.group().replaceAll(replace, ""));
//                      start = macthEnd;
//              }
//              if (start < content.length()) {
//                      if (toUpper) {
//                              buffer.append(content.substring(start).toUpperCase());
//                      } else {
//                              buffer.append(content.substring(start).toLowerCase());
//                      }
//              }
//              return buffer.toString();
//      }

    public static boolean isTempTable(table table) {
        if(SubType.temp_table.name().equals(table.getSubType())) {
                return true;
        }
        String tableName = table.getName();
        List<String> segments = parseNames(tableName);
        if (tableName.startsWith("@") || segments.get(segments.size() - 1).startsWith("@")) {
            return true;
        }
        if (tableName.startsWith("#") || segments.get(segments.size() - 1).startsWith("#")) {
            return true;
        }
        return false;
    }
    
//    public static boolean isTempTable(String tableName) {
//        List<String> segments = parseNames(tableName);
//        if (tableName.startsWith("@") || segments.get(segments.size() - 1).startsWith("@")) {
//            return true;
//        }
//        if (tableName.startsWith("#") || segments.get(segments.size() - 1).startsWith("#")) {
//            return true;
//        }
//        return false;
//    }

//    public static boolean isTempTable(TTable table, EDbVendor vendor) {
//        switch (vendor) {
//            case dbvmssql:
//                return table.getName().startsWith("#");
//            default:
//                return false;
//        }
//    }

    public static File[] listFiles(File sqlFiles) {
        List<File> children = new ArrayList<File>();
        if (sqlFiles != null)
            listFiles(sqlFiles, children);
        Collections.sort(children);
        return children.toArray(new File[0]);
    }

    public static File[] listFiles(File sqlFiles, FileFilter filter) {
        List<File> children = new ArrayList<File>();
        if (sqlFiles != null)
            listFiles(sqlFiles, children, filter);
        Collections.sort(children);
        return children.toArray(new File[0]);
    }

    private static Set<String> extensions = new HashSet<String>(Arrays.asList("java", "class", "php", "c", "cpp", "properties", "iml",
            "yml", "xml", "md", "jpg", "png", "gif", "bmp", "tiff", "tif", "svg", "pdf", "mp3", "mp4", "bak", "jar", "gz",
            "tar", "log", "conf", "dll", "exe", "so", "sh", "bat", "cdr", "docx", "doc", "xps", "xlsx", "xls", "ppt", "pptx",
            "rar", "7z", "ttf", "caj", "dwg", "dwf", "dxf", "ico", "epub", "webp", "heic", "html", "htm", "vsd", "vsdx", "rtf", "ico"));

    public static void listFiles(File rootFile, List<File> children) {
        if (rootFile.isFile())
            children.add(rootFile);
        else {
            File[] files = rootFile.listFiles(t -> {
                int dotIndex = t.getName().lastIndexOf(".");
                if (dotIndex == -1) {
                    return true;
                }
                String extension = t.getName().toLowerCase().substring(dotIndex + 1);
                return !extensions.contains(extension);
            });
            if (files != null) {
                for (int i = 0; i < files.length; i++) {
                    listFiles(files[i], children);
                }
            }
        }
    }

    public static void listFiles(File rootFile, List<File> children, FileFilter filter) {
        if (rootFile.isFile() && filter.accept(rootFile))
            children.add(rootFile);
        else {
            File[] files = rootFile.listFiles(filter);
            if (files != null) {
                for (int i = 0; i < files.length; i++) {
                    listFiles(files[i], children, filter);
                }
            }
        }
    }

    public static String readFile(File file) {
        StringBuilder stringBuilder = new StringBuilder();
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(file));

            String line = null;
            String ls = System.getProperty("line.separator");
            while ((line = reader.readLine()) != null) {
                stringBuilder.append(line);
                stringBuilder.append(ls);
            }
            stringBuilder.deleteCharAt(stringBuilder.length() - 1);
        } catch (IOException e) {
            logger.error("read file failed.", e);
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    logger.error("close reader failed.", e);
                }
            }
        }
        return stringBuilder.toString();
    }

        public static String stringToMD5(String plainText) {
                byte[] secretBytes = null;
                try {
                        secretBytes = MessageDigest.getInstance("md5").digest(plainText.getBytes("UTF-8"));
                        StringBuffer sb = new StringBuffer();
                        for (int i = 0; i < secretBytes.length; ++i) {
                                sb.append(Integer.toHexString((secretBytes[i] & 0xFF) | 0x100).substring(1, 3));
                        }
                        return sb.toString();
                } catch (Exception e) {
                        logger.error("get text md5 value failed.", e);
                }
                return null;
        }

        public static String trimSingleQuote(String columnAlias) {
                if(columnAlias.startsWith("'") && columnAlias.endsWith("'")) {
                        return columnAlias.substring(1, columnAlias.length() - 1);
                }
                return columnAlias;
        }
        
    public static String endTrim(String input) {
        if (input == null) {
            return null;
        }

        int end = input.length();
        while (end > 0 && Character.isWhitespace(input.charAt(end - 1))) {
            end--;
        }

        return input.substring(0, end);
    }
        
    public static void endTrim(StringBuilder buffer) {
        int length = buffer.length();
        while (length > 0 && Character.isWhitespace(buffer.charAt(length - 1))) {
            length--; // 逐步减少长度
        }
        buffer.setLength(length); // 直接截断尾部空白字符
    }

    public static String joinNonEmpty(String... parts) {
        return Arrays.stream(parts)
                .filter(s -> s != null && !s.trim().isEmpty())
                .collect(Collectors.joining("/"));
    }

    public static long hash64(CharSequence cs) {
        long hash = 0xcbf29ce484222325L;
        for (int i = 0, len = cs.length(); i < len; i++) {
            hash ^= cs.charAt(i);
            hash *= 0x100000001b3L;
        }
        return hash;
    }
}