package gudusoft.gsqlparser.resolver2.matcher;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierProfile;
import gudusoft.gsqlparser.sqlenv.IdentifierService;
import gudusoft.gsqlparser.sqlenv.QualifiedNameHierarchy;

import java.util.List;

/**
 * Vendor-specific name matcher using IdentifierService.
 *
 * <p>This implementation provides database vendor-specific identifier normalization
 * and comparison by delegating to {@link IdentifierService}.</p>
 *
 * <p>Key features:</p>
 * <ul>
 *   <li>Vendor-specific case folding (Oracle: UPPER, PostgreSQL: LOWER, etc.)</li>
 *   <li>Proper handling of quoted vs unquoted identifiers</li>
 *   <li>Support for different object types (tables, columns, schemas)</li>
 *   <li>High-performance static caching via IdentifierService</li>
 * </ul>
 *
 * <p>Usage example:</p>
 * <pre>
 * // Create matcher for Oracle
 * VendorNameMatcher matcher = new VendorNameMatcher(EDbVendor.dbvoracle);
 *
 * // Normalize column name
 * String normalized = matcher.normalize("\"Column1\"");  // Returns "Column1" (quoted preserved)
 * String normalized2 = matcher.normalize("column1");     // Returns "COLUMN1" (unquoted folded)
 *
 * // Compare names
 * boolean match = matcher.matches("COL1", "col1");  // Returns true (both normalize to COL1)
 * </pre>
 *
 * @since 3.1.0.9
 * @see IdentifierService
 */
public class VendorNameMatcher implements INameMatcher {

    private final EDbVendor vendor;
    private final ESQLDataObjectType defaultObjectType;
    private final IdentifierService service;

    /**
     * Create a vendor name matcher with default object type (column) under the vendor's DEFAULT
     * identifier configuration.
     *
     * @param vendor the database vendor
     */
    public VendorNameMatcher(EDbVendor vendor) {
        this(vendor, ESQLDataObjectType.dotColumn);
    }

    /**
     * Create a vendor name matcher with specified default object type.
     *
     * @param vendor the database vendor
     * @param defaultObjectType the default object type for normalization/comparison
     */
    public VendorNameMatcher(EDbVendor vendor, ESQLDataObjectType defaultObjectType) {
        this.vendor = vendor != null ? vendor : EDbVendor.dbvoracle;
        this.defaultObjectType = defaultObjectType != null ? defaultObjectType : ESQLDataObjectType.dotColumn;
        this.service = IdentifierService.defaultServiceFor(this.vendor);
    }

    /**
     * Create a matcher over ONE analysis's identifier service, so resolution observes that
     * analysis's per-category configuration rather than the vendor default.
     *
     * @param service the frozen identifier service of the current analysis
     * @param defaultObjectType the default object type for normalization/comparison
     */
    public VendorNameMatcher(IdentifierService service, ESQLDataObjectType defaultObjectType) {
        if (service == null) {
            throw new IllegalArgumentException("VendorNameMatcher: service must not be null");
        }
        this.service = service;
        this.vendor = service.getProfile().getVendor();
        this.defaultObjectType = defaultObjectType != null ? defaultObjectType : ESQLDataObjectType.dotColumn;
    }

    /**
     * The identifier service every comparison here delegates to.
     *
     * @return the identifier service
     */
    public IdentifierService getIdentifierService() {
        return service;
    }

    @Override
    public boolean matches(String name1, String name2) {
        return matches(name1, name2, defaultObjectType);
    }

    /**
     * Check if two names match according to vendor rules for a specific object type.
     *
     * @param name1 first name
     * @param name2 second name
     * @param objectType the object type (table, column, etc.)
     * @return true if names match according to vendor rules
     */
    public boolean matches(String name1, String name2, ESQLDataObjectType objectType) {
        if (name1 == null || name2 == null) {
            return name1 == name2;
        }
        return service.areEqual(name1, name2, objectType);
    }

    @Override
    public boolean matchesPattern(String name, String pattern) {
        if (name == null || pattern == null) {
            return false;
        }
        // Normalize both and do prefix matching
        String normalizedName = normalize(name);
        String normalizedPattern = normalize(pattern);
        return normalizedName.startsWith(normalizedPattern);
    }

    @Override
    public String normalize(String name) {
        return normalize(name, defaultObjectType);
    }

    /**
     * Normalize a name according to vendor rules for a specific object type.
     *
     * @param name the name to normalize
     * @param objectType the object type (table, column, etc.)
     * @return normalized name
     */
    public String normalize(String name, ESQLDataObjectType objectType) {
        if (name == null || name.isEmpty()) {
            return name;
        }
        return service.normalize(name, objectType);
    }

    /**
     * Normalize a qualified name (e.g., schema.table.column).
     *
     * <p>This method properly normalizes each part of a multi-part identifier
     * according to vendor rules.</p>
     *
     * @param qualifiedName the qualified name
     * @param objectType the final object type
     * @return normalized qualified name
     */
    public String normalizeQualifiedName(String qualifiedName, ESQLDataObjectType objectType) {
        if (qualifiedName == null || qualifiedName.isEmpty()) {
            return qualifiedName;
        }

        // Split and assign a role to each position with the ONE place that knows the vendor's
        // hierarchy (QualifiedNameHierarchy), not by hand. The previous loop tracked quote
        // characters itself and compared every intermediate segment as dotTable, so a catalog or
        // schema segment was normalized by the table rule. That was invisible while a dialect gave
        // all three the same rule; configured per category it silently renames a catalog.
        List<String> segments = QualifiedNameHierarchy.split(vendor, qualifiedName);
        if (segments == null || segments.isEmpty()) {
            return qualifiedName;
        }
        List<QualifiedNameHierarchy.Segment> plan =
                QualifiedNameHierarchy.plan(vendor, objectType, segments);

        StringBuilder result = new StringBuilder(qualifiedName.length());
        if (plan == null) {
            // No hierarchy mapping for this vendor/type: normalize each segment as the whole
            // name's own kind rather than inventing a role for it.
            for (int i = 0; i < segments.size(); i++) {
                if (i > 0) {
                    result.append('.');
                }
                result.append(normalize(segments.get(i), objectType));
            }
            return result.toString();
        }
        for (int i = 0; i < plan.size(); i++) {
            if (i > 0) {
                result.append('.');
            }
            QualifiedNameHierarchy.Segment segment = plan.get(i);
            result.append(normalize(segment.getText(), segment.getType()));
        }
        return result.toString();
    }

    /**
     * Whether UNQUOTED names of this matcher's default object category compare case-sensitively
     * under the configured profile.
     *
     * <p>Answered from the profile rather than hard-coded false: the old constant claimed every
     * dialect was case-insensitive, which is wrong for BigQuery tables and Couchbase by default
     * and wrong for anything a caller configures. Quoted operands may follow a different rule —
     * {@link #matches} is the complete relation, this is a one-bit summary of the unquoted branch.
     */
    @Override
    public boolean isCaseSensitive() {
        return isCaseSensitive(defaultObjectType);
    }

    /**
     * Whether UNQUOTED names of one object category compare case-sensitively under the configured
     * profile.
     *
     * @param objectType the object category
     * @return true when unquoted names of that category compare case-sensitively
     */
    public boolean isCaseSensitive(ESQLDataObjectType objectType) {
        // A collation-based cell answers from its collation (_CS_AI and _BIN2 are case-sensitive
        // though compared through a collator); the service holds that one rule.
        return service.isCaseSensitive(objectType);
    }

    /**
     * Get the database vendor.
     *
     * @return the vendor
     */
    public EDbVendor getVendor() {
        return vendor;
    }

    /**
     * Get the default object type.
     *
     * @return the default object type
     */
    public ESQLDataObjectType getDefaultObjectType() {
        return defaultObjectType;
    }

    /**
     * Create a new matcher with a different default object type.
     *
     * @param objectType the new default object type
     * @return new VendorNameMatcher instance
     */
    public VendorNameMatcher withObjectType(ESQLDataObjectType objectType) {
        return new VendorNameMatcher(service, objectType);
    }

    @Override
    public String toString() {
        return String.format("VendorNameMatcher{vendor=%s, defaultType=%s}", vendor, defaultObjectType);
    }
}