package gudusoft.gsqlparser.resolver2.model;

import gudusoft.gsqlparser.resolver2.matcher.INameMatcher;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;

/**
 * Represents a fully qualified name for a database object (table, view, etc.).
 *
 * <p>A qualified name can be represented in two ways:
 * <ol>
 *   <li>As a list of parts (legacy mode) - for generic N-part names</li>
 *   <li>As explicit catalog/schema/name (structured mode) - for table names</li>
 * </ol>
 *
 * <p>For table names, the structured fields provide:
 * <ul>
 *   <li><b>catalog</b> (database) - The top-level container (e.g., "mydb")</li>
 *   <li><b>schema</b> - The schema within the catalog (e.g., "dbo", "public")</li>
 *   <li><b>name</b> - The object name itself (e.g., "users", "orders")</li>
 * </ul>
 *
 * <h3>Usage Examples</h3>
 * <pre>{@code
 * // Legacy list-based construction
 * QualifiedName q1 = new QualifiedName("schema", "table");
 *
 * // Structured table name construction
 * QualifiedName q2 = QualifiedName.forTable("mydb", "dbo", "users");
 *
 * // Apply defaults for unqualified names
 * QualifiedName q3 = QualifiedName.forTable(null, null, "users")
 *     .withDefaults("mydb", "dbo");
 * // Result: catalog=mydb, schema=dbo, name=users
 * }</pre>
 *
 * @see QualifiedNameResolver
 */
public class QualifiedName {

    // ========== Legacy list-based storage ==========
    private final List<String> parts;

    // ========== Structured table name storage ==========
    /** The catalog (database) part, or null if not specified */
    private final String catalog;

    /** The schema part, or null if not specified */
    private final String schema;

    /** The object name (table name), or null if using legacy mode */
    private final String tableName;

    /** Whether this instance uses structured mode */
    private final boolean structuredMode;

    // ========== Legacy Constructors ==========

    /**
     * Create a qualified name from a list of parts (legacy mode).
     */
    public QualifiedName(List<String> parts) {
        this.parts = new ArrayList<>(parts);
        this.catalog = null;
        this.schema = null;
        this.tableName = null;
        this.structuredMode = false;
    }

    /**
     * Create a qualified name from varargs parts (legacy mode).
     */
    public QualifiedName(String... parts) {
        this.parts = Arrays.asList(parts);
        this.catalog = null;
        this.schema = null;
        this.tableName = null;
        this.structuredMode = false;
    }

    // ========== Structured Constructors ==========

    /**
     * Private constructor for structured mode.
     */
    private QualifiedName(String catalog, String schema, String tableName, boolean structured) {
        this.catalog = normalizeEmpty(catalog);
        this.schema = normalizeEmpty(schema);
        this.tableName = tableName;
        this.structuredMode = structured;

        // Also populate parts for backward compatibility
        List<String> partsList = new ArrayList<>();
        if (this.catalog != null) partsList.add(this.catalog);
        if (this.schema != null) partsList.add(this.schema);
        if (this.tableName != null) partsList.add(this.tableName);
        this.parts = partsList;
    }

    /**
     * Create a structured qualified name for a table.
     *
     * @param catalog The catalog/database name (nullable)
     * @param schema The schema name (nullable)
     * @param tableName The table name (required)
     * @return A new QualifiedName in structured mode
     */
    public static QualifiedName forTable(String catalog, String schema, String tableName) {
        if (tableName == null || tableName.isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }
        return new QualifiedName(catalog, schema, tableName, true);
    }

    /**
     * Create a qualified name from just the table name.
     */
    public static QualifiedName forTable(String tableName) {
        return forTable(null, null, tableName);
    }

    /**
     * Create a qualified name from schema and table name.
     */
    public static QualifiedName forTable(String schema, String tableName) {
        return forTable(null, schema, tableName);
    }

    private static String normalizeEmpty(String value) {
        return (value == null || value.isEmpty()) ? null : value;
    }

    // ========== Legacy Getters ==========

    public List<String> getParts() {
        return new ArrayList<>(parts);
    }

    public int getPartCount() {
        return parts.size();
    }

    public String getPart(int index) {
        return parts.get(index);
    }

    public String getFirstPart() {
        return parts.isEmpty() ? null : parts.get(0);
    }

    public String getLastPart() {
        return parts.isEmpty() ? null : parts.get(parts.size() - 1);
    }

    // ========== Structured Getters ==========

    /**
     * Get the catalog (database) part.
     * Only meaningful in structured mode.
     */
    public String getCatalog() {
        return catalog;
    }

    /**
     * Get the schema part.
     * Only meaningful in structured mode.
     */
    public String getSchema() {
        return schema;
    }

    /**
     * Get the table name.
     * In structured mode, returns the explicit table name.
     * In legacy mode, returns the last part.
     */
    public String getTableName() {
        if (structuredMode) {
            return tableName;
        }
        return getLastPart();
    }

    /**
     * Alias for getTableName() - returns the object name.
     */
    public String getName() {
        return getTableName();
    }

    /**
     * Check if this instance uses structured mode.
     */
    public boolean isStructuredMode() {
        return structuredMode;
    }

    /**
     * Check if this qualified name has a catalog specified.
     */
    public boolean hasCatalog() {
        return catalog != null;
    }

    /**
     * Check if this qualified name has a schema specified.
     */
    public boolean hasSchema() {
        return schema != null;
    }

    /**
     * Check if this is a fully qualified name (all three parts in structured mode).
     */
    public boolean isFullyQualified() {
        return structuredMode && catalog != null && schema != null && tableName != null;
    }

    // ========== Legacy Operations ==========

    /**
     * Returns a new qualified name with the first part removed (legacy mode).
     */
    public QualifiedName removeFirst() {
        if (parts.size() <= 1) {
            return new QualifiedName();
        }
        return new QualifiedName(parts.subList(1, parts.size()));
    }

    /**
     * Returns a new qualified name with an additional part prepended (legacy mode).
     */
    public QualifiedName prepend(String part) {
        List<String> newParts = new ArrayList<>();
        newParts.add(part);
        newParts.addAll(parts);
        return new QualifiedName(newParts);
    }

    /**
     * Returns a new qualified name with an additional part appended (legacy mode).
     */
    public QualifiedName append(String part) {
        List<String> newParts = new ArrayList<>(parts);
        newParts.add(part);
        return new QualifiedName(newParts);
    }

    // ========== Structured Operations ==========

    /**
     * Create a new qualified name by filling in missing parts from defaults.
     *
     * <p>This does NOT override existing parts - it only fills in nulls.
     * Only works in structured mode.
     *
     * @param defaultCatalog The default catalog to use if this.catalog is null
     * @param defaultSchema The default schema to use if this.schema is null
     * @return A new qualified name with defaults applied
     */
    public QualifiedName withDefaults(String defaultCatalog, String defaultSchema) {
        if (!structuredMode) {
            // In legacy mode, convert to structured mode first
            String name = getLastPart();
            String schemaFromParts = parts.size() >= 2 ? parts.get(parts.size() - 2) : null;
            String catalogFromParts = parts.size() >= 3 ? parts.get(parts.size() - 3) : null;
            return new QualifiedName(
                catalogFromParts != null ? catalogFromParts : defaultCatalog,
                schemaFromParts != null ? schemaFromParts : defaultSchema,
                name,
                true
            );
        }
        return new QualifiedName(
            this.catalog != null ? this.catalog : defaultCatalog,
            this.schema != null ? this.schema : defaultSchema,
            this.tableName,
            true
        );
    }

    /**
     * Create a fully qualified name by applying defaults for all missing parts.
     *
     * @param defaultCatalog The default catalog
     * @param defaultSchema The default schema
     * @return A fully qualified name (all three parts set)
     */
    public QualifiedName toFullyQualified(String defaultCatalog, String defaultSchema) {
        return withDefaults(defaultCatalog, defaultSchema);
    }

    // ========== Matching ==========

    /**
     * Check if this qualified name matches another, using the given name matcher.
     *
     * <p>Matching rules:
     * <ul>
     *   <li>Object names must always match</li>
     *   <li>If both have schemas, they must match</li>
     *   <li>If both have catalogs, they must match</li>
     *   <li>Missing parts (null) are treated as wildcards</li>
     * </ul>
     *
     * @param other The other qualified name to compare
     * @param matcher The name matcher for comparison (handles case sensitivity)
     * @return true if the names match according to the rules
     */
    public boolean matches(QualifiedName other, INameMatcher matcher) {
        if (other == null) {
            return false;
        }

        // Object names must always match
        String thisName = this.getTableName();
        String otherName = other.getTableName();
        if (thisName == null || otherName == null) {
            return false;
        }
        if (!matcher.matches(thisName, otherName)) {
            return false;
        }

        // For structured mode, also check schema and catalog
        if (this.structuredMode || other.structuredMode) {
            String thisSchema = this.getSchema();
            String otherSchema = other.getSchema();

            // If both have schemas, they must match
            if (thisSchema != null && otherSchema != null) {
                if (!matcher.matches(thisSchema, otherSchema)) {
                    return false;
                }
            }

            String thisCatalog = this.getCatalog();
            String otherCatalog = other.getCatalog();

            // If both have catalogs, they must match
            if (thisCatalog != null && otherCatalog != null) {
                if (!matcher.matches(thisCatalog, otherCatalog)) {
                    return false;
                }
            }
        }

        return true;
    }

    /**
     * Check exact match (all parts must match, including nulls).
     */
    public boolean matchesExact(QualifiedName other, INameMatcher matcher) {
        if (other == null) return false;

        // Check table name
        String thisName = this.getTableName();
        String otherName = other.getTableName();
        if (!Objects.equals(thisName, otherName) &&
            (thisName == null || otherName == null || !matcher.matches(thisName, otherName))) {
            return false;
        }

        // Check schema (must both be null or both match)
        String thisSchema = this.getSchema();
        String otherSchema = other.getSchema();
        if (thisSchema == null != (otherSchema == null)) return false;
        if (thisSchema != null && !matcher.matches(thisSchema, otherSchema)) return false;

        // Check catalog (must both be null or both match)
        String thisCatalog = this.getCatalog();
        String otherCatalog = other.getCatalog();
        if (thisCatalog == null != (otherCatalog == null)) return false;
        if (thisCatalog != null && !matcher.matches(thisCatalog, otherCatalog)) return false;

        return true;
    }

    // ========== Key Generation ==========

    /**
     * Create a key suitable for use in maps/sets.
     *
     * <p>The key is lowercase and includes all three parts separated by null characters
     * to ensure uniqueness.
     */
    public String toNormalizedKey() {
        String c = catalog != null ? catalog.toLowerCase() : "";
        String s = schema != null ? schema.toLowerCase() : "";
        String n = getTableName() != null ? getTableName().toLowerCase() : "";
        return c + "\0" + s + "\0" + n;
    }

    // ========== String Conversion ==========

    @Override
    public String toString() {
        if (structuredMode) {
            StringBuilder sb = new StringBuilder();
            if (catalog != null) {
                sb.append(catalog).append(".");
            }
            if (schema != null) {
                sb.append(schema).append(".");
            }
            if (tableName != null) {
                sb.append(tableName);
            }
            return sb.toString();
        }
        return String.join(".", parts);
    }

    /**
     * Convert to a fully qualified string representation, using placeholders for missing parts.
     *
     * @param catalogPlaceholder Placeholder for missing catalog (e.g., "*" or "?")
     * @param schemaPlaceholder Placeholder for missing schema
     * @return String like "*.*.name" or "catalog.*.name"
     */
    public String toStringWithPlaceholders(String catalogPlaceholder, String schemaPlaceholder) {
        String c = catalog != null ? catalog : catalogPlaceholder;
        String s = schema != null ? schema : schemaPlaceholder;
        String n = getTableName() != null ? getTableName() : "?";
        return c + "." + s + "." + n;
    }

    // ========== Equality ==========

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        QualifiedName that = (QualifiedName) o;
        if (this.structuredMode || that.structuredMode) {
            return Objects.equals(catalog, that.catalog) &&
                   Objects.equals(schema, that.schema) &&
                   Objects.equals(getTableName(), that.getTableName());
        }
        return Objects.equals(parts, that.parts);
    }

    @Override
    public int hashCode() {
        if (structuredMode) {
            return Objects.hash(catalog, schema, tableName);
        }
        return Objects.hash(parts);
    }

    /**
     * Check equality ignoring case.
     *
     * @param other The other qualified name
     * @return true if all parts match (ignoring case)
     */
    public boolean equalsIgnoreCase(QualifiedName other) {
        if (other == null) return false;

        String thisName = this.getTableName();
        String otherName = other.getTableName();
        if (thisName == null || otherName == null) {
            if (thisName != otherName) return false;
        } else if (!thisName.equalsIgnoreCase(otherName)) {
            return false;
        }

        String thisSchema = this.getSchema();
        String otherSchema = other.getSchema();
        if (thisSchema == null != (otherSchema == null)) return false;
        if (thisSchema != null && !thisSchema.equalsIgnoreCase(otherSchema)) return false;

        String thisCatalog = this.getCatalog();
        String otherCatalog = other.getCatalog();
        if (thisCatalog == null != (otherCatalog == null)) return false;
        if (thisCatalog != null && !thisCatalog.equalsIgnoreCase(otherCatalog)) return false;

        return true;
    }
}