package gudusoft.gsqlparser.resolver2.model;

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

/**
 * Service for normalizing table names into fully qualified names.
 *
 * <p>This class handles the conversion of potentially partial table names
 * (e.g., just "table", "schema.table", or "catalog.schema.table") into
 * fully qualified {@link QualifiedName} objects by applying default
 * catalog and schema from {@link TSQLEnv}.
 *
 * <h3>Normalization Rules</h3>
 * <table border="1">
 *   <tr><th>Input</th><th>Rule</th><th>Output</th></tr>
 *   <tr><td>table</td><td>Apply both defaults</td><td>(defaultCatalog, defaultSchema, table)</td></tr>
 *   <tr><td>schema.table</td><td>Apply catalog default only</td><td>(defaultCatalog, schema, table)</td></tr>
 *   <tr><td>catalog.schema.table</td><td>No defaults applied</td><td>(catalog, schema, table)</td></tr>
 * </table>
 *
 * <h3>Usage Example</h3>
 * <pre>{@code
 * // Setup
 * TSQLEnv env = new TSQLEnv(EDbVendor.dbvmssql);
 * env.setDefaultCatalogName("mydb");
 * env.setDefaultSchemaName("dbo");
 *
 * QualifiedNameResolver resolver = new QualifiedNameResolver(env, EDbVendor.dbvmssql);
 *
 * // Normalize a simple table name
 * QualifiedName q1 = resolver.resolve(tableNode);
 * // Result: (mydb, dbo, tableName)
 *
 * // Normalize a two-part name
 * QualifiedName q2 = resolver.resolve("sales", "orders");
 * // Result: (mydb, sales, orders)
 *
 * // Three-part name is unchanged
 * QualifiedName q3 = resolver.resolve("otherdb", "hr", "employees");
 * // Result: (otherdb, hr, employees)
 * }</pre>
 *
 * @see QualifiedName
 * @see TSQLEnv
 */
public class QualifiedNameResolver {

    /** The SQL environment containing default catalog/schema */
    private final TSQLEnv sqlEnv;

    /** The database vendor (affects parsing behavior) */
    private final EDbVendor vendor;

    /** Default catalog to use when not provided */
    private final String defaultCatalog;

    /** Default schema to use when not provided */
    private final String defaultSchema;

    /**
     * Create a QualifiedNameResolver with the given SQL environment.
     *
     * @param sqlEnv The SQL environment containing default catalog/schema
     * @param vendor The database vendor
     */
    public QualifiedNameResolver(TSQLEnv sqlEnv, EDbVendor vendor) {
        this.sqlEnv = sqlEnv;
        this.vendor = vendor;
        this.defaultCatalog = sqlEnv != null ? sqlEnv.getDefaultCatalogName() : null;
        this.defaultSchema = sqlEnv != null ? sqlEnv.getDefaultSchemaName() : null;
    }

    /**
     * Create a QualifiedNameResolver with explicit defaults.
     *
     * @param defaultCatalog The default catalog name
     * @param defaultSchema The default schema name
     * @param vendor The database vendor
     */
    public QualifiedNameResolver(String defaultCatalog, String defaultSchema, EDbVendor vendor) {
        this.sqlEnv = null;
        this.vendor = vendor;
        this.defaultCatalog = defaultCatalog;
        this.defaultSchema = defaultSchema;
    }

    /**
     * Get the current default catalog.
     *
     * <p>If sqlEnv was provided, returns the current value from sqlEnv
     * (which may have changed since construction).
     */
    public String getDefaultCatalog() {
        if (sqlEnv != null) {
            return sqlEnv.getDefaultCatalogName();
        }
        return defaultCatalog;
    }

    /**
     * Get the current default schema.
     *
     * <p>If sqlEnv was provided, returns the current value from sqlEnv
     * (which may have changed since construction).
     */
    public String getDefaultSchema() {
        if (sqlEnv != null) {
            return sqlEnv.getDefaultSchemaName();
        }
        return defaultSchema;
    }

    /**
     * Resolve a TTable's name to a fully qualified name.
     *
     * @param table The table node from the AST
     * @return A normalized QualifiedName with defaults applied
     */
    public QualifiedName resolve(TTable table) {
        if (table == null) {
            return null;
        }
        return resolve(table.getTableName());
    }

    /**
     * Resolve a TObjectName (table reference) to a fully qualified name.
     *
     * @param tableName The table name node from the AST
     * @return A normalized QualifiedName with defaults applied
     */
    public QualifiedName resolve(TObjectName tableName) {
        if (tableName == null) {
            return null;
        }

        // Extract parts from the TObjectName
        String catalog = null;
        String schema = null;
        String name = null;

        // TObjectName stores: database.schema.object or schema.object or object
        // For table names: databaseToken -> catalogToken
        //                  schemaToken -> schemaToken
        //                  objectToken -> tableToken (but getTableString() returns object name)

        // Get the object/table name (required)
        name = tableName.getObjectString();
        if (name == null || name.isEmpty()) {
            // Fallback to full string representation
            name = tableName.toString();
            if (name == null || name.isEmpty()) {
                return null;
            }
            // Parse the string manually
            return parseQualifiedString(name);
        }

        // Get schema if present
        if (tableName.getSchemaToken() != null) {
            schema = tableName.getSchemaString();
        }

        // Get database/catalog if present
        if (tableName.getDatabaseToken() != null) {
            catalog = tableName.getDatabaseString();
        }

        // Create QualifiedName and apply defaults
        return normalizeQualifiedName(catalog, schema, name);
    }

    /**
     * Resolve a simple table name string to a fully qualified name.
     *
     * @param tableName The table name (may include dots)
     * @return A normalized QualifiedName with defaults applied
     */
    public QualifiedName resolve(String tableName) {
        if (tableName == null || tableName.isEmpty()) {
            return null;
        }
        return parseQualifiedString(tableName);
    }

    /**
     * Create a qualified name from explicit parts with defaults applied.
     *
     * @param catalog The catalog (null to use default)
     * @param schema The schema (null to use default)
     * @param name The table name (required)
     * @return A normalized QualifiedName
     */
    public QualifiedName resolve(String catalog, String schema, String name) {
        if (name == null || name.isEmpty()) {
            return null;
        }
        return normalizeQualifiedName(catalog, schema, name);
    }

    /**
     * Parse a dot-separated qualified name string.
     *
     * @param qualifiedString A string like "table", "schema.table", or "catalog.schema.table"
     * @return A normalized QualifiedName with defaults applied
     */
    private QualifiedName parseQualifiedString(String qualifiedString) {
        if (qualifiedString == null || qualifiedString.isEmpty()) {
            return null;
        }

        // Handle quoted identifiers - simple split won't work for "schema"."table"
        // For now, use a simple split approach that handles most cases
        String[] parts = splitQualifiedName(qualifiedString);

        String catalog = null;
        String schema = null;
        String name;

        if (parts.length == 1) {
            // Just table name
            name = parts[0];
        } else if (parts.length == 2) {
            // schema.table
            schema = parts[0];
            name = parts[1];
        } else if (parts.length >= 3) {
            // catalog.schema.table (use last three parts)
            int offset = parts.length - 3;
            catalog = parts[offset];
            schema = parts[offset + 1];
            name = parts[offset + 2];
        } else {
            return null;
        }

        return normalizeQualifiedName(catalog, schema, name);
    }

    /**
     * Split a qualified name string into parts, handling quoted identifiers.
     */
    private String[] splitQualifiedName(String qualifiedString) {
        // Simple implementation - split on dots not inside quotes
        // This handles most common cases but may need enhancement for complex quoting

        java.util.List<String> parts = new java.util.ArrayList<>();
        StringBuilder current = new StringBuilder();
        boolean inQuote = false;
        char quoteChar = 0;

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

            if (!inQuote && (c == '"' || c == '`' || c == '[')) {
                inQuote = true;
                quoteChar = c;
                // Don't include the quote character in the part
            } else if (inQuote && ((quoteChar == '[' && c == ']') ||
                                    (quoteChar != '[' && c == quoteChar))) {
                inQuote = false;
                quoteChar = 0;
                // Don't include the closing quote
            } else if (!inQuote && c == '.') {
                // Split point
                if (current.length() > 0) {
                    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]);
    }

    /**
     * Apply normalization rules to create a fully qualified name.
     *
     * <p>Rules:
     * <ul>
     *   <li>If catalog is provided, use it (don't override with default)</li>
     *   <li>If schema is provided, use it (don't override with default)</li>
     *   <li>If catalog is null and we have a default, apply it</li>
     *   <li>If schema is null and we have a default, apply it</li>
     * </ul>
     *
     * <p>Special case for 2-part names:
     * <ul>
     *   <li>schema.table -> (defaultCatalog, schema, table) - schema is kept, catalog applied</li>
     * </ul>
     */
    private QualifiedName normalizeQualifiedName(String catalog, String schema, String name) {
        if (name == null || name.isEmpty()) {
            return null;
        }

        // Normalize empty strings to null
        catalog = normalizeEmpty(catalog);
        schema = normalizeEmpty(schema);

        // Get current defaults from sqlEnv (may have changed)
        String defCatalog = getDefaultCatalog();
        String defSchema = getDefaultSchema();

        // Apply defaults only for missing parts
        // Key: Don't override explicitly provided parts
        String finalCatalog = catalog != null ? catalog : defCatalog;
        String finalSchema = schema != null ? schema : defSchema;

        return QualifiedName.forTable(finalCatalog, finalSchema, name);
    }

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

    /**
     * Check if two qualified names refer to the same table.
     *
     * <p>Both names are first normalized using current defaults,
     * then compared for equality.
     *
     * @param name1 First qualified name (may be partial)
     * @param name2 Second qualified name (may be partial)
     * @return true if they refer to the same fully-qualified table
     */
    public boolean isSameTable(QualifiedName name1, QualifiedName name2) {
        if (name1 == null || name2 == null) {
            return false;
        }

        // Apply defaults to both
        QualifiedName normalized1 = name1.withDefaults(getDefaultCatalog(), getDefaultSchema());
        QualifiedName normalized2 = name2.withDefaults(getDefaultCatalog(), getDefaultSchema());

        return normalized1.equalsIgnoreCase(normalized2);
    }

    /**
     * Check if a qualified name matches a target name, considering defaults.
     *
     * @param reference The reference being checked (may be partial)
     * @param target The target table name (should be fully qualified)
     * @return true if the reference resolves to the target
     */
    public boolean matches(QualifiedName reference, QualifiedName target) {
        if (reference == null || target == null) {
            return false;
        }

        // Normalize the reference using defaults
        QualifiedName normalizedRef = reference.withDefaults(getDefaultCatalog(), getDefaultSchema());

        // Compare with target
        return normalizedRef.equalsIgnoreCase(target);
    }

    @Override
    public String toString() {
        return String.format("QualifiedNameResolver{defaultCatalog='%s', defaultSchema='%s', vendor=%s}",
            getDefaultCatalog(), getDefaultSchema(), vendor);
    }
}