package gudusoft.gsqlparser.resolver2.format;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TTable;

/**
 * Normalizes identifier names for display output.
 *
 * <p>This class provides display-focused normalization that is separate from
 * the matching/equality normalization used during name resolution. The key
 * principle is:</p>
 *
 * <ul>
 *   <li><b>Matching normalization</b> (in {@code IdentifierService}): applies case folding
 *       and other transformations to create a canonical key for comparison</li>
 *   <li><b>Display normalization</b> (this class): strips delimiters but preserves
 *       the original case as written by the user</li>
 * </ul>
 *
 * <h3>Usage Example:</h3>
 * <pre>
 * DisplayNameNormalizer normalizer = new DisplayNameNormalizer(EDbVendor.dbvbigquery);
 * normalizer.setMode(DisplayNameMode.DISPLAY);
 *
 * // Strip backticks, preserve case
 * String display = normalizer.normalizeTableName("`kalyan-DB`.`test-schema`.`t1`");
 * // Result: "kalyan-DB.test-schema.t1"
 * </pre>
 *
 * @see DisplayNameMode
 * @see DisplayNamePolicy
 */
public class DisplayNameNormalizer {

    private final EDbVendor vendor;
    private DisplayNameMode mode = DisplayNameMode.DISPLAY;
    private boolean stripDelimiters = true;

    /**
     * Create a normalizer for the specified database vendor.
     *
     * @param vendor the database vendor (determines delimiter style)
     */
    public DisplayNameNormalizer(EDbVendor vendor) {
        this.vendor = vendor != null ? vendor : EDbVendor.dbvansi;
    }

    /**
     * Create a normalizer with default vendor (ANSI).
     */
    public DisplayNameNormalizer() {
        this(EDbVendor.dbvansi);
    }

    /**
     * Get the current display mode.
     */
    public DisplayNameMode getMode() {
        return mode;
    }

    /**
     * Set the display mode.
     *
     * @param mode the display mode
     * @return this normalizer for chaining
     */
    public DisplayNameNormalizer setMode(DisplayNameMode mode) {
        this.mode = mode != null ? mode : DisplayNameMode.DISPLAY;
        return this;
    }

    /**
     * Check if delimiters should be stripped.
     */
    public boolean isStripDelimiters() {
        return stripDelimiters;
    }

    /**
     * Set whether to strip delimiters.
     *
     * @param stripDelimiters true to strip delimiters
     * @return this normalizer for chaining
     */
    public DisplayNameNormalizer setStripDelimiters(boolean stripDelimiters) {
        this.stripDelimiters = stripDelimiters;
        return this;
    }

    /**
     * Normalize a table name for display.
     *
     * @param table the table object
     * @return the normalized display name
     */
    public String normalizeTableName(TTable table) {
        if (table == null) {
            return null;
        }

        // Try to get the full name from the table
        String fullName = table.getFullName();
        if (fullName != null && !fullName.isEmpty()) {
            return normalizeQualifiedName(fullName);
        }

        // Fallback to table name
        String name = table.getName();
        return name != null ? normalizeIdentifier(name) : null;
    }

    /**
     * Normalize an object name (table or column) for display.
     *
     * @param objectName the object name node
     * @return the normalized display name
     */
    public String normalizeObjectName(TObjectName objectName) {
        if (objectName == null) {
            return null;
        }

        // Use toString() which gives the full representation
        String name = objectName.toString();
        return normalizeQualifiedName(name);
    }

    /**
     * Normalize a column name for display.
     *
     * @param columnName the column name (may include table prefix)
     * @return the normalized display name
     */
    public String normalizeColumnName(String columnName) {
        if (columnName == null || columnName.isEmpty()) {
            return columnName;
        }
        return normalizeIdentifier(columnName);
    }

    /**
     * Normalize a qualified name (e.g., schema.table.column) for display.
     *
     * <p>This method handles multi-part names by normalizing each segment
     * separately while preserving the dot separators.</p>
     *
     * @param qualifiedName the qualified name
     * @return the normalized display name
     */
    public String normalizeQualifiedName(String qualifiedName) {
        if (qualifiedName == null || qualifiedName.isEmpty()) {
            return qualifiedName;
        }

        if (mode == DisplayNameMode.SQL_RENDER) {
            // In SQL_RENDER mode, preserve the original form
            return qualifiedName;
        }

        // Split by dots, but be careful with quoted identifiers that contain dots
        // For now, use a simple approach: normalize the whole string if it's a single identifier,
        // or split and normalize each part

        // Check if the entire name is a single quoted identifier (contains dot inside quotes)
        if (isSingleQuotedIdentifier(qualifiedName)) {
            return normalizeIdentifier(qualifiedName);
        }

        // Split by dots that are not inside quotes
        String[] parts = splitQualifiedName(qualifiedName);
        StringBuilder result = new StringBuilder();

        for (int i = 0; i < parts.length; i++) {
            if (i > 0) {
                result.append(".");
            }
            result.append(normalizeIdentifier(parts[i]));
        }

        return result.toString();
    }

    /**
     * Normalize a single identifier (without dots) for display.
     *
     * @param identifier the identifier
     * @return the normalized identifier
     */
    public String normalizeIdentifier(String identifier) {
        if (identifier == null || identifier.isEmpty()) {
            return identifier;
        }

        switch (mode) {
            case SQL_RENDER:
                // Preserve original form including delimiters
                return identifier;

            case CANONICAL:
                // Apply vendor-specific folding (delegate to IdentifierService if needed)
                // For now, just strip delimiters - full canonical would need IdentifierService
                return stripDelimiters ? stripAllDelimiters(identifier) : identifier;

            case DISPLAY:
            default:
                // Strip delimiters, preserve case
                return stripDelimiters ? stripAllDelimiters(identifier) : identifier;
        }
    }

    /**
     * Strip all SQL delimiters from an identifier.
     *
     * <p>Handles multiple delimiter styles:</p>
     * <ul>
     *   <li>Double quotes: {@code "name"} → {@code name}</li>
     *   <li>Backticks: {@code `name`} → {@code name}</li>
     *   <li>Square brackets: {@code [name]} → {@code name}</li>
     *   <li>Single quotes (for some vendors): {@code 'name'} → {@code name}</li>
     * </ul>
     *
     * @param identifier the identifier (may be quoted)
     * @return the identifier without delimiters
     */
    public String stripAllDelimiters(String identifier) {
        if (identifier == null || identifier.isEmpty()) {
            return identifier;
        }

        String result = identifier;

        // Strip double quotes
        if (result.startsWith("\"") && result.endsWith("\"") && result.length() > 2) {
            result = result.substring(1, result.length() - 1);
            // Handle escaped double quotes inside
            result = result.replace("\"\"", "\"");
        }
        // Strip backticks (MySQL, BigQuery, Databricks, Hive, Spark)
        else if (result.startsWith("`") && result.endsWith("`") && result.length() > 2) {
            result = result.substring(1, result.length() - 1);
            // Handle escaped backticks inside
            result = result.replace("``", "`");
        }
        // SQL Server square brackets - strip them for deduplication
        // Previously kept for special names like [1], [2], [3] from PIVOT, but this causes
        // duplicates when same column is referenced with and without brackets (e.g., [col3] vs col3)
        else if (result.startsWith("[") && result.endsWith("]") && result.length() > 2) {
            result = result.substring(1, result.length() - 1);
            // Handle escaped brackets inside
            result = result.replace("]]", "]");
        }
        // Strip single quotes (for string literals used as identifiers in some contexts)
        else if (result.startsWith("'") && result.endsWith("'") && result.length() > 2) {
            result = result.substring(1, result.length() - 1);
            // Handle escaped single quotes inside
            result = result.replace("''", "'");
        }

        return result;
    }

    /**
     * Check if the name is a single quoted identifier that may contain dots.
     * A single quoted identifier has matching delimiters at start/end AND
     * no unquoted dots inside (which would indicate a multi-part name).
     *
     * @param name the name to check
     * @return true if it's a single quoted identifier
     */
    private boolean isSingleQuotedIdentifier(String name) {
        if (name == null || name.length() < 3) {
            return false;
        }

        char first = name.charAt(0);
        char last = name.charAt(name.length() - 1);
        char expectedClose;

        // Check for matching delimiters
        if (first == '"' && last == '"') {
            expectedClose = '"';
        } else if (first == '`' && last == '`') {
            expectedClose = '`';
        } else if (first == '[' && last == ']') {
            expectedClose = ']';
        } else {
            return false;
        }

        // Check if there are any unquoted dots inside
        // If so, this is a multi-part identifier, not a single quoted one
        boolean inQuote = true;  // We start inside the first quote
        for (int i = 1; i < name.length() - 1; i++) {
            char c = name.charAt(i);
            if (c == expectedClose) {
                inQuote = !inQuote;
            } else if (c == '.' && !inQuote) {
                // Found an unquoted dot - this is multi-part
                return false;
            }
        }

        return true;
    }

    /**
     * Split a qualified name by dots, respecting quoted identifiers.
     *
     * @param qualifiedName the qualified name
     * @return array of parts
     */
    private String[] splitQualifiedName(String qualifiedName) {
        if (qualifiedName == null || qualifiedName.isEmpty()) {
            return new String[0];
        }

        java.util.List<String> parts = new java.util.ArrayList<>();
        StringBuilder current = new StringBuilder();
        boolean inDoubleQuote = false;
        boolean inBacktick = false;
        boolean inBracket = false;

        for (int i = 0; i < qualifiedName.length(); i++) {
            char c = qualifiedName.charAt(i);

            // Track quote state
            if (c == '"' && !inBacktick && !inBracket) {
                inDoubleQuote = !inDoubleQuote;
                current.append(c);
            } else if (c == '`' && !inDoubleQuote && !inBracket) {
                inBacktick = !inBacktick;
                current.append(c);
            } else if (c == '[' && !inDoubleQuote && !inBacktick && !inBracket) {
                inBracket = true;
                current.append(c);
            } else if (c == ']' && inBracket) {
                inBracket = false;
                current.append(c);
            } else if (c == '.' && !inDoubleQuote && !inBacktick && !inBracket) {
                // Split point
                parts.add(current.toString());
                current = new StringBuilder();
            } else {
                current.append(c);
            }
        }

        // Add the last part
        if (current.length() > 0) {
            parts.add(current.toString());
        }

        return parts.toArray(new String[0]);
    }

    /**
     * Get a display name for a table, handling various TTable configurations.
     *
     * @param table the table
     * @return the display name
     */
    public String getTableDisplayName(TTable table) {
        if (table == null) {
            return null;
        }

        // Build the full qualified name from parts if available
        StringBuilder sb = new StringBuilder();

        // Server/catalog
        String server = table.getPrefixServer();
        if (server != null && !server.isEmpty()) {
            sb.append(normalizeIdentifier(server));
            sb.append(".");
        }

        // Database
        String database = table.getPrefixDatabase();
        if (database != null && !database.isEmpty()) {
            sb.append(normalizeIdentifier(database));
            sb.append(".");
        }

        // Schema
        String schema = table.getPrefixSchema();
        if (schema != null && !schema.isEmpty()) {
            sb.append(normalizeIdentifier(schema));
            sb.append(".");
        }

        // Table name
        String tableName = table.getName();
        if (tableName != null && !tableName.isEmpty()) {
            sb.append(normalizeIdentifier(tableName));
        }

        String result = sb.toString();

        // If we got nothing useful, fall back to getFullName
        if (result.isEmpty() || result.equals(".")) {
            String fullName = table.getFullName();
            if (fullName != null) {
                return normalizeQualifiedName(fullName);
            }
        }

        return result.isEmpty() ? null : result;
    }

    @Override
    public String toString() {
        return String.format("DisplayNameNormalizer{vendor=%s, mode=%s, stripDelimiters=%s}",
                vendor, mode, stripDelimiters);
    }
}