package gudusoft.gsqlparser.resolver2.matcher;

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

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

    /**
     * Create a vendor name matcher with default object type (column).
     *
     * @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;
    }

    @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 IdentifierService.areEqualStatic(vendor, objectType, name1, name2);
    }

    @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 IdentifierService.normalizeStatic(vendor, objectType, name);
    }

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

        // Parse the qualified name into parts
        // Handle quoted identifiers that may contain dots
        StringBuilder result = new StringBuilder();
        StringBuilder currentPart = new StringBuilder();
        boolean inQuote = false;
        char quoteChar = 0;

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

            // Track quote state
            if (!inQuote && (c == '"' || c == '`' || c == '[')) {
                inQuote = true;
                quoteChar = c;
                currentPart.append(c);
            } else if (inQuote && ((quoteChar == '"' && c == '"') ||
                                   (quoteChar == '`' && c == '`') ||
                                   (quoteChar == '[' && c == ']'))) {
                inQuote = false;
                currentPart.append(c);
            } else if (!inQuote && c == '.') {
                // End of a part - normalize it
                if (currentPart.length() > 0) {
                    if (result.length() > 0) {
                        result.append('.');
                    }
                    // Use dotTable for intermediate parts, objectType for final part
                    result.append(normalize(currentPart.toString(), ESQLDataObjectType.dotTable));
                    currentPart.setLength(0);
                }
            } else {
                currentPart.append(c);
            }
        }

        // Handle the last part with the actual object type
        if (currentPart.length() > 0) {
            if (result.length() > 0) {
                result.append('.');
            }
            result.append(normalize(currentPart.toString(), objectType));
        }

        return result.toString();
    }

    @Override
    public boolean isCaseSensitive() {
        // This is a simplified check - actual sensitivity depends on vendor and object type
        // For most databases, unquoted identifiers are case-insensitive
        return false;
    }

    /**
     * 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(vendor, objectType);
    }

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