package gudusoft.gsqlparser.ir.builder.mssql;

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

/**
 * Normalizes SQL Server multi-part names.
 * <p>
 * Handles: {@code [brackets]}, {@code "double quotes"}, case normalization,
 * 1-4 part names ({@code server.database.schema.object}), and
 * missing schema defaulting to {@code dbo}.
 */
public final class MssqlNameNormalizer {

    private MssqlNameNormalizer() {}

    /**
     * Normalizes a raw SQL Server object name.
     *
     * @param rawName the raw name (e.g., {@code [dbo].[proc_name]})
     * @return normalized name with parts split, quotes stripped, upper-cased for matching
     */
    public static NormalizedName normalize(String rawName) {
        if (rawName == null || rawName.trim().isEmpty()) {
            return new NormalizedName(null, null, null, "", "", "");
        }
        List<String> rawParts = splitParts(rawName.trim());
        List<String> stripped = new ArrayList<String>();
        for (String part : rawParts) {
            stripped.add(stripQuotes(part));
        }

        String server = null;
        String database = null;
        String schema = null;
        String object;

        switch (stripped.size()) {
            case 1:
                object = stripped.get(0);
                break;
            case 2:
                schema = stripped.get(0);
                object = stripped.get(1);
                break;
            case 3:
                database = stripped.get(0);
                schema = stripped.get(1);
                // Handle db..object (empty schema → default dbo)
                if (schema.isEmpty()) {
                    schema = "dbo";
                }
                object = stripped.get(2);
                break;
            case 4:
                server = stripped.get(0);
                database = stripped.get(1);
                schema = stripped.get(2);
                if (schema.isEmpty()) {
                    schema = "dbo";
                }
                object = stripped.get(3);
                break;
            default:
                object = rawName.trim();
                break;
        }

        String displayText = rawName.trim();

        // Build match key: [schema.]object (uppercase)
        StringBuilder matchKeyBuilder = new StringBuilder();
        if (schema != null && !schema.isEmpty()) {
            matchKeyBuilder.append(schema.toUpperCase()).append('.');
        }
        matchKeyBuilder.append(object.toUpperCase());
        String matchKey = matchKeyBuilder.toString();

        return new NormalizedName(server, database, schema, object, displayText, matchKey);
    }

    /**
     * Splits a multi-part name by dots, respecting bracket and quote delimiters.
     */
    public static List<String> splitParts(String rawName) {
        List<String> parts = new ArrayList<String>();
        StringBuilder current = new StringBuilder();
        boolean inBracket = false;
        boolean inQuote = false;

        for (int i = 0; i < rawName.length(); i++) {
            char c = rawName.charAt(i);
            if (c == '[' && !inQuote) {
                inBracket = true;
                current.append(c);
            } else if (c == ']' && inBracket) {
                inBracket = false;
                current.append(c);
            } else if (c == '"' && !inBracket) {
                inQuote = !inQuote;
                current.append(c);
            } else if (c == '.' && !inBracket && !inQuote) {
                parts.add(current.toString());
                current.setLength(0);
            } else {
                current.append(c);
            }
        }
        parts.add(current.toString());
        return parts;
    }

    /**
     * Strips surrounding {@code []} and {@code ""} quote characters from a name part.
     */
    public static String stripQuotes(String part) {
        if (part == null) {
            return "";
        }
        String s = part.trim();
        if (s.startsWith("[") && s.endsWith("]") && s.length() >= 2) {
            return s.substring(1, s.length() - 1);
        }
        if (s.startsWith("\"") && s.endsWith("\"") && s.length() >= 2) {
            return s.substring(1, s.length() - 1);
        }
        return s;
    }

    /**
     * Normalized SQL Server name with server/database/schema/object components.
     */
    public static class NormalizedName {
        private final String server;
        private final String database;
        private final String schema;
        private final String object;
        private final String displayText;
        private final String matchKey;

        public NormalizedName(String server, String database, String schema,
                              String object, String displayText, String matchKey) {
            this.server = server;
            this.database = database;
            this.schema = schema;
            this.object = object;
            this.displayText = displayText;
            this.matchKey = matchKey;
        }

        public String getServer() { return server; }
        public String getDatabase() { return database; }
        public String getSchema() { return schema; }
        public String getObject() { return object; }
        public String getDisplayText() { return displayText; }
        public String getMatchKey() { return matchKey; }

        /**
         * Returns the number of name segments (1 = object only, 2 = schema.object, etc.).
         */
        public int getPartCount() {
            int count = 1;
            if (schema != null && !schema.isEmpty()) count++;
            if (database != null && !database.isEmpty()) count++;
            if (server != null && !server.isEmpty()) count++;
            return count;
        }

        @Override
        public String toString() {
            return "NormalizedName{" + matchKey + ", parts=" + getPartCount() + "}";
        }
    }
}