package gudusoft.gsqlparser.resolver2.namespace;

import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.resolver2.ColumnLevel;
import gudusoft.gsqlparser.resolver2.matcher.INameMatcher;
import gudusoft.gsqlparser.resolver2.matcher.DefaultNameMatcher;
import gudusoft.gsqlparser.resolver2.model.ColumnReference;
import gudusoft.gsqlparser.resolver2.model.ColumnSource;
import gudusoft.gsqlparser.resolver2.model.ColumnSourceWithReferences;

import java.util.*;

/**
 * Abstract base class for all namespaces.
 * Provides common functionality for column resolution and caching.
 *
 * <p>Enhanced with reference traceability support: multiple syntactically different
 * identifiers that refer to the same semantic column can be tracked and traced back.</p>
 */
public abstract class AbstractNamespace implements INamespace {

    /** Associated AST node */
    protected final Object node;

    /** Whether this namespace has been validated */
    protected boolean validated = false;

    /** Cached column sources (populated during validation) - keyed by normalized name */
    protected Map<String, ColumnSource> columnSources = null;

    /**
     * Enhanced column sources with reference traceability (keyed by normalized name).
     * When enabled, this map stores ColumnSourceWithReferences that track all original
     * references to each semantic column.
     */
    protected Map<String, ColumnSourceWithReferences> columnSourcesWithRefs = null;

    /** Whether reference traceability is enabled */
    protected boolean referenceTraceabilityEnabled = false;

    /** Name matcher for column name comparisons */
    protected final INameMatcher nameMatcher;

    /**
     * Strategy for handling ambiguous columns.
     * Defaults to -1, which means use global TBaseType.GUESS_COLUMN_STRATEGY.
     * Can be overridden per-namespace instance.
     */
    protected int guessColumnStrategy = -1;

    protected AbstractNamespace(Object node, INameMatcher nameMatcher) {
        this.node = node;
        this.nameMatcher = nameMatcher != null ? nameMatcher : new DefaultNameMatcher();
    }

    protected AbstractNamespace(Object node) {
        this(node, new DefaultNameMatcher());
    }

    /**
     * Set the strategy for handling ambiguous columns.
     * @param strategy One of TBaseType.GUESS_COLUMN_STRATEGY_* constants, or -1 to use global default
     */
    public void setGuessColumnStrategy(int strategy) {
        this.guessColumnStrategy = strategy;
    }

    /**
     * Get the strategy for handling ambiguous columns.
     * Returns the instance-level strategy if set, otherwise returns the global default.
     * @return The strategy constant
     */
    public int getGuessColumnStrategy() {
        if (guessColumnStrategy >= 0) {
            return guessColumnStrategy;
        }
        return gudusoft.gsqlparser.TBaseType.GUESS_COLUMN_STRATEGY;
    }

    @Override
    public Object getNode() {
        return node;
    }

    @Override
    public boolean isValidated() {
        return validated;
    }

    @Override
    public void validate() {
        if (!validated) {
            doValidate();
            validated = true;
        }
    }

    /**
     * Subclasses override this to perform actual validation logic.
     */
    protected abstract void doValidate();

    /**
     * Enable reference traceability for this namespace.
     * When enabled, all column additions will track original references.
     */
    public void enableReferenceTraceability() {
        this.referenceTraceabilityEnabled = true;
        if (columnSourcesWithRefs == null) {
            columnSourcesWithRefs = new LinkedHashMap<>();
        }
    }

    /**
     * Check if reference traceability is enabled.
     *
     * @return true if traceability is enabled
     */
    public boolean isReferenceTraceabilityEnabled() {
        return referenceTraceabilityEnabled;
    }

    /**
     * Add a column source with reference traceability support.
     *
     * <p>This method normalizes the column name and either:</p>
     * <ul>
     *   <li>Creates a new entry if this is the first reference</li>
     *   <li>Adds a reference to an existing entry if the column already exists</li>
     * </ul>
     *
     * @param columnName original column name (may include quotes)
     * @param source the column source
     * @param objectName the original AST node for traceability (may be null)
     */
    protected void addColumnSource(String columnName, ColumnSource source, TObjectName objectName) {
        if (columnSources == null) {
            columnSources = new LinkedHashMap<>();
        }

        String normalizedKey = nameMatcher.normalize(columnName);

        // Add to basic map if not exists
        if (!columnSources.containsKey(normalizedKey)) {
            columnSources.put(normalizedKey, source);
        }

        // Add to enhanced map with references if traceability is enabled
        if (referenceTraceabilityEnabled) {
            if (columnSourcesWithRefs == null) {
                columnSourcesWithRefs = new LinkedHashMap<>();
            }

            ColumnSourceWithReferences enhanced = columnSourcesWithRefs.computeIfAbsent(
                normalizedKey,
                k -> new ColumnSourceWithReferences(normalizedKey, source)
            );

            if (objectName != null) {
                enhanced.addReference(new ColumnReference(objectName));
            }
        }
    }

    /**
     * Add a column source (backward compatible - no traceability).
     *
     * @param columnName original column name
     * @param source the column source
     */
    protected void addColumnSource(String columnName, ColumnSource source) {
        addColumnSource(columnName, source, null);
    }

    @Override
    public ColumnLevel hasColumn(String columnName) {
        ensureValidated();

        if (columnSources == null) {
            return ColumnLevel.NOT_EXISTS;
        }

        // Use normalized key for O(1) lookup
        String normalizedKey = nameMatcher.normalize(columnName);
        if (columnSources.containsKey(normalizedKey)) {
            return ColumnLevel.EXISTS;
        }

        // Fallback to linear search for backward compatibility
        for (String existingCol : columnSources.keySet()) {
            if (nameMatcher.matches(existingCol, columnName)) {
                return ColumnLevel.EXISTS;
            }
        }

        return ColumnLevel.NOT_EXISTS;
    }

    @Override
    public ColumnSource resolveColumn(String columnName) {
        ensureValidated();

        if (columnSources == null) {
            return null;
        }

        // Use normalized key for O(1) lookup
        String normalizedKey = nameMatcher.normalize(columnName);
        ColumnSource source = columnSources.get(normalizedKey);
        if (source != null) {
            return source;
        }

        // Fallback to linear search for backward compatibility
        for (Map.Entry<String, ColumnSource> entry : columnSources.entrySet()) {
            if (nameMatcher.matches(entry.getKey(), columnName)) {
                return entry.getValue();
            }
        }

        return null;
    }

    @Override
    public Map<String, ColumnSource> getAllColumnSources() {
        ensureValidated();
        return columnSources != null
            ? Collections.unmodifiableMap(columnSources)
            : Collections.emptyMap();
    }

    /**
     * Get all column references for a specific column.
     *
     * <p>Requires reference traceability to be enabled.</p>
     *
     * @param columnName the column name (normalized or original)
     * @return list of all references, empty if not found or traceability not enabled
     */
    public List<ColumnReference> getColumnReferences(String columnName) {
        if (columnSourcesWithRefs == null) {
            return Collections.emptyList();
        }

        String normalizedKey = nameMatcher.normalize(columnName);
        ColumnSourceWithReferences enhanced = columnSourcesWithRefs.get(normalizedKey);

        return enhanced != null
            ? enhanced.getAllReferences()
            : Collections.emptyList();
    }

    /**
     * Get all unique columns with their references.
     *
     * <p>Requires reference traceability to be enabled.</p>
     *
     * @return collection of enhanced column sources, empty if traceability not enabled
     */
    public Collection<ColumnSourceWithReferences> getAllUniqueColumns() {
        if (columnSourcesWithRefs == null) {
            return Collections.emptyList();
        }
        return Collections.unmodifiableCollection(columnSourcesWithRefs.values());
    }

    /**
     * Get enhanced column source with references for a specific column.
     *
     * @param columnName the column name
     * @return enhanced column source, or null if not found
     */
    public ColumnSourceWithReferences getColumnSourceWithReferences(String columnName) {
        if (columnSourcesWithRefs == null) {
            return null;
        }
        String normalizedKey = nameMatcher.normalize(columnName);
        return columnSourcesWithRefs.get(normalizedKey);
    }

    @Override
    public List<TTable> getAllFinalTables() {
        TTable finalTable = getFinalTable();
        if (finalTable != null) {
            return Collections.singletonList(finalTable);
        }
        return Collections.emptyList();
    }

    /**
     * Ensure this namespace is validated before accessing column info
     */
    protected void ensureValidated() {
        if (!validated) {
            validate();
        }
    }

    /**
     * Get the name matcher used by this namespace.
     *
     * @return the name matcher
     */
    public INameMatcher getNameMatcher() {
        return nameMatcher;
    }

    @Override
    public String toString() {
        return getDisplayName();
    }
}