package gudusoft.gsqlparser.resolver2.format;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierCodec;
import gudusoft.gsqlparser.sqlenv.IdentifierProfile;
import gudusoft.gsqlparser.sqlenv.IdentifierService;
import gudusoft.gsqlparser.sqlenv.SqlNameGenerator;
import gudusoft.gsqlparser.util.SQLUtil;

import java.util.List;

/**
 * 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;

    /** How much delimiting {@link DisplayNameMode#SQL_RENDER} applies; see {@link #setQuotePolicy}. */
    private SqlNameGenerator.QuotePolicy quotePolicy = SqlNameGenerator.QuotePolicy.WHEN_NEEDED;

    /**
     * Vendor identifier profile, built lazily and reused. This is what makes the
     * delimiter rules come from the unified name service instead of this class.
     */
    private IdentifierProfile profileCache;

    /** Name service used for CANONICAL folding, built lazily and reused. */
    private IdentifierService serviceCache;

    private IdentifierProfile profile() {
        if (profileCache == null) {
            profileCache = IdentifierProfile.forVendor(vendor, IdentifierProfile.VendorFlags.defaults());
        }
        return profileCache;
    }

    private IdentifierService service() {
        if (serviceCache == null) {
            // Collator provider is SQL Server specific and nullable; display folding
            // does not need collation, which is a comparison concern.
            serviceCache = new IdentifierService(profile(), null);
        }
        return serviceCache;
    }

    /**
     * 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;
    }

    public SqlNameGenerator.QuotePolicy getQuotePolicy() {
        return quotePolicy;
    }

    /**
     * Choose the spelling {@link DisplayNameMode#SQL_RENDER} generates. "Valid SQL that names
     * this object" is a constraint, not a value: {@code dbo} and {@code [dbo]} both satisfy it.
     * This parameter is what makes the answer unique.
     *
     * <ul>
     *   <li>{@code WHEN_NEEDED} (default): delimit only where the bare word would be invalid,
     *       would fold to another object, or is a keyword — {@code dbo.SalesOrder},
     *       {@code [Order ID]}.</li>
     *   <li>{@code ALWAYS}: delimit every segment — {@code [dbo].[SalesOrder]}.</li>
     * </ul>
     */
    public DisplayNameNormalizer setQuotePolicy(SqlNameGenerator.QuotePolicy quotePolicy) {
        this.quotePolicy = quotePolicy != null ? quotePolicy : SqlNameGenerator.QuotePolicy.WHEN_NEEDED;
        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, ESQLDataObjectType.dotTable);
        }

        // Fallback to table name
        String name = table.getName();
        return name != null ? normalizeIdentifier(name, ESQLDataObjectType.dotTable) : 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, ESQLDataObjectType.dotColumn);
    }

    /**
     * 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) {
        return normalizeQualifiedName(qualifiedName, ESQLDataObjectType.dotColumn);
    }

    /**
     * Normalize a qualified name for display, stating the syntactic role of its
     * segments so delimiter rules come from the vendor profile.
     *
     * <p>Every segment is decoded with the same {@code objectType}, which is what
     * this class has always done. Per-segment role typing (catalog / schema / leaf)
     * is a separate change: it would alter output for vendors whose quote rules
     * differ by role, so it needs its own measurement.</p>
     *
     * @param qualifiedName the qualified name
     * @param objectType syntactic role of the identifier segments
     * @return the normalized display name
     */
    public String normalizeQualifiedName(String qualifiedName, ESQLDataObjectType objectType) {
        if (qualifiedName == null || qualifiedName.isEmpty()) {
            return qualifiedName;
        }

        // Segmentation belongs to the name service, not to this class: it knows
        // which dots are separators and which sit inside a delimited segment, and
        // it carries the vendor quirks (MSSQL "db..table", BigQuery backticks).
        List<String> parts = SQLUtil.parseNames(qualifiedName, vendor);
        if (parts == null || parts.isEmpty()) {
            return normalizeIdentifier(qualifiedName, objectType);
        }

        // The name service may hand back segments with their delimiters already removed
        // (BigQuery writes `proj.ds.tbl` inside ONE pair of backticks). Those are stored names,
        // not SQL spellings, and SQL_RENDER has to write them back from that starting point.
        boolean storedSegments = false;
        if (mode == DisplayNameMode.SQL_RENDER) {
            StringBuilder rejoined = new StringBuilder();
            for (int i = 0; i < parts.size(); i++) {
                if (i > 0) rejoined.append(".");
                rejoined.append(parts.get(i));
            }
            storedSegments = !rejoined.toString().equals(qualifiedName);   // exact text, not an identifier compare
        }

        StringBuilder result = new StringBuilder();
        for (int i = 0; i < parts.size(); i++) {
            if (i > 0) {
                result.append(".");
            }
            result.append(storedSegments
                    ? renderStoredAsSql(parts.get(i), objectType)
                    : normalizeIdentifier(parts.get(i), objectType));
        }

        return result.toString();
    }

    /**
     * Normalize a single identifier (without dots) for display.
     *
     * @param identifier the identifier
     * @return the normalized identifier
     */
    public String normalizeIdentifier(String identifier) {
        return normalizeIdentifier(identifier, ESQLDataObjectType.dotColumn);
    }

    /**
     * Normalize a single identifier (without dots) for display, stating its
     * syntactic role so delimiter rules come from the vendor profile.
     *
     * @param identifier the identifier
     * @param objectType syntactic role of the identifier
     * @return the normalized identifier
     */
    public String normalizeIdentifier(String identifier, ESQLDataObjectType objectType) {
        if (identifier == null || identifier.isEmpty()) {
            return identifier;
        }

        switch (mode) {
            case SQL_RENDER:
                return renderAsSql(identifier, objectType);

            case CANONICAL:
                // Undelimit AND apply the vendor's case folding, via the name service.
                // This is deliberately NOT a rendered CanonKey: a comparison key and a
                // display string are two different contracts, and nothing may re-derive
                // identity by comparing what this returns.
                return canonicalize(identifier, objectType);

            case DISPLAY:
            default:
                // Strip delimiters, preserve case
                return stripDelimiters ? stripAllDelimiters(identifier, objectType) : 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
     */
    /**
     * Write a name as valid SQL for the vendor: GENERATED from the stored name, not echoed from
     * the reference.
     *
     * <p>Echoing kept whatever delimiters the author happened to type, so one object had as many
     * SQL_RENDER spellings as the script had ways of writing it ({@code dbo} and {@code [dbo]}).
     * {@link SqlNameGenerator#respell} instead decides the delimiters by rule, governed by
     * {@link #setQuotePolicy}: a delimited name is decoded to its exact stored text and
     * re-delimited only if it must be.</p>
     *
     * <p>A name written WITHOUT delimiters is returned as written. It is already valid SQL for
     * that object, and folding its case would need the catalog's stored case, which SQL text
     * does not reveal. So {@code Sales} and {@code SALES} may both come back for one Oracle
     * table; a listing shows one of them through identity grouping and a
     * {@link DisplayNamePolicy}.</p>
     */
    /** Write a STORED name (no source spelling) as SQL; shown as given when none can be generated. */
    private String renderStoredAsSql(String stored, ESQLDataObjectType objectType) {
        if (stored == null || stored.isEmpty()) return stored;
        SqlNameGenerator.Result r = SqlNameGenerator.generate(vendor, quotePolicy,
                SqlNameGenerator.Segment.of(objectType, stored));
        return r.isOk() ? r.getSql() : stored;
    }

    private String renderAsSql(String identifier, ESQLDataObjectType objectType) {
        // A bare asterisk in SQL text can only be the wildcard: a column that is really named
        // "*" cannot be written without delimiters. This reads the LEXICAL input, so it does not
        // confuse the two the way a rendered name would.
        if ("*".equals(identifier)) {
            return identifier;
        }
        try {
            SqlNameGenerator.Result r = SqlNameGenerator.respell(vendor, quotePolicy, objectType, identifier);
            if (r.isOk()) {
                return r.getSql();
            }
        } catch (RuntimeException e) {
            // Malformed spelling: fall through.
        }
        // Nothing valid could be generated. Show the reference as written rather than drop it.
        return identifier;
    }

    /**
     * Render an identifier in the vendor's canonical form: delimiters removed and
     * case folded by the vendor's own rule (Oracle {@code MyTable} -> {@code MYTABLE},
     * while {@code "MyTable"} keeps its case because quoting is part of identity).
     *
     * <p>The folding rule belongs to {@link IdentifierService}; this class only asks
     * for it. The result is a DISPLAY string, not a comparison key — use
     * {@code SQLUtil.sameName} / {@code canonKey} to compare names, never this.</p>
     */
    private String canonicalize(String identifier, ESQLDataObjectType objectType) {
        try {
            String folded = service().normalizeSegment(identifier, objectType);
            if (folded != null && !folded.isEmpty()) {
                return folded;
            }
        } catch (RuntimeException e) {
            // Malformed spelling: fall back to the undelimited form rather than
            // dropping the name from the listing.
        }
        return stripDelimiters ? stripAllDelimiters(identifier, objectType) : identifier;
    }

    public String stripAllDelimiters(String identifier) {
        return stripAllDelimiters(identifier, ESQLDataObjectType.dotColumn);
    }

    /**
     * Strip SQL delimiters from an identifier, using the vendor's real quote rules.
     *
     * <p>The decision of what counts as a delimiter belongs to the unified name
     * service, not to the display layer, so this delegates to
     * {@link IdentifierCodec#decodeLexical}. Two display-specific rules are layered
     * on top of it, and both exist to keep output byte-identical to the behavior
     * this class had before it delegated:</p>
     *
     * <ul>
     *   <li><b>Never fail on a malformed spelling.</b> {@code decodeLexical} throws
     *       {@code MalformedIdentifierException} for input such as {@code "unclosed}.
     *       A display layer must not abort a whole Tables/Fields listing because one
     *       name is malformed, so a throw falls through to the legacy strip.</li>
     *   <li><b>Never display an empty name.</b> {@code decodeLexical} decodes
     *       {@code ""}, {@code []} and {@code ''} to the empty string. Rendering a
     *       column as nothing is worse than rendering its raw spelling, so an empty
     *       decode falls through as well.</li>
     * </ul>
     *
     * <p><b>Known gap, deliberately preserved.</b> The legacy fallback also strips
     * delimiters the vendor does not own (backticks for Oracle, brackets for MySQL,
     * single quotes for everyone). Routing those through the profile instead would
     * be the semantically correct behavior, but it changes output for 14 of 15
     * vendors measured, so it is a separate decision with its own golden review —
     * not something to slip in under a refactor.</p>
     *
     * @param identifier the identifier (may be quoted)
     * @param objectType syntactic role of the identifier (quote rules can depend on it)
     * @return the identifier without delimiters
     */
    public String stripAllDelimiters(String identifier, ESQLDataObjectType objectType) {
        if (identifier == null || identifier.isEmpty()) {
            return identifier;
        }

        try {
            String decoded = IdentifierCodec.decodeLexical(profile(), objectType, identifier);
            // An empty decode means the spelling was an empty delimited name such as
            // "" or []. Rendering a column as nothing is worse than rendering what
            // was written, so show the spelling instead. This is a display policy
            // applied to the codec's answer, not a second opinion about delimiters.
            return decoded.isEmpty() ? identifier : decoded;
        } catch (RuntimeException e) {
            // Malformed spelling (an unterminated delimiter). A display layer must
            // not abort a whole listing over one bad name, so show it as written.
            return identifier;
        }
    }




    /**
     * 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, ESQLDataObjectType.dotServer));
            sb.append(".");
        }

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

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

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

        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, ESQLDataObjectType.dotTable);
            }
        }

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

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