package gudusoft.gsqlparser.sqlenv.catalog;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierProfile;
import gudusoft.gsqlparser.sqlenv.IdentifierService;
import gudusoft.gsqlparser.sqlenv.TSQLCatalog;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.sqlenv.TSQLSchemaObject;
import gudusoft.gsqlparser.sqlenv.CatalogStore;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

/**
 * CatalogStore Provider（新实现）
 *
 * <p>此实现基于 CatalogStore，使用 IdentifierService 进行标识符处理。
 *
 * @since 3.2.0 (Phase 1)
 */
public class CatalogStoreProvider implements ICatalogProvider {

    private final EDbVendor vendor;
    private final CatalogStore catalogStore;
    private final IdentifierService identifierService;
    private String defaultCatalogName;

    // Cache for TSQLCatalog objects (for compatibility with TSQLEnv API)
    private final Map<String, TSQLCatalog> catalogCache = new ConcurrentHashMap<>();

    /**
     * Creates a CatalogStoreProvider with default flags
     *
     * @param vendor database vendor
     */
    public CatalogStoreProvider(EDbVendor vendor) {
        this(vendor, IdentifierProfile.VendorFlags.defaults());
    }

    /**
     * Creates a CatalogStoreProvider with custom vendor flags
     *
     * @param vendor database vendor
     * @param flags vendor-specific flags
     */
    public CatalogStoreProvider(EDbVendor vendor, IdentifierProfile.VendorFlags flags) {
        this(IdentifierProfile.forVendor(vendor, flags));
    }

    /**
     * Creates a CatalogStoreProvider under ONE analysis's identifier configuration.
     *
     * <p>The profile reaches the catalog store and every index built inside it, so registration,
     * lookup and enumeration observe the same per-category rules the rest of the analysis does.
     * A provider built from a bare vendor keeps the vendor default.
     *
     * @param profile the effective identifier configuration; its vendor is the provider's vendor
     */
    public CatalogStoreProvider(IdentifierProfile profile) {
        this(IdentifierService.forProfile(profile));
    }

    /**
     * Creates a CatalogStoreProvider over an existing analysis service.
     *
     * @param identifierService the frozen service of the current analysis
     */
    public CatalogStoreProvider(IdentifierService identifierService) {
        this.vendor = identifierService.getProfile().getVendor();
        this.identifierService = identifierService;
        this.catalogStore = new CatalogStore(this.vendor, identifierService);
    }

    /**
     * Creates a CatalogStoreProvider wrapping existing CatalogStore
     *
     * @param catalogStore existing catalog store
     * @param identifierService identifier service
     */
    public CatalogStoreProvider(CatalogStore catalogStore, IdentifierService identifierService) {
        this.vendor = catalogStore.getVendor();
        this.catalogStore = catalogStore;
        this.identifierService = identifierService;
    }

    @Override
    public TSQLCatalog getCatalog(String catalogName) {
        if (catalogName == null || catalogName.isEmpty()) {
            return null;
        }

        // Normalize catalog name
        String normalizedName = identifierService.normalize(catalogName, ESQLDataObjectType.dotCatalog);

        // Return cached catalog if exists
        return catalogCache.get(normalizedName);
    }

    @Override
    public TSQLCatalog createCatalog(String catalogName) {
        if (catalogName == null || catalogName.isEmpty()) {
            throw new IllegalArgumentException("catalogName cannot be null or empty");
        }

        // Normalize catalog name
        String normalizedName = identifierService.normalize(catalogName, ESQLDataObjectType.dotCatalog);

        // Return existing if already cached
        TSQLCatalog existing = catalogCache.get(normalizedName);
        if (existing != null) {
            return existing;
        }

        // Note: We cannot create TSQLCatalog here because it requires TSQLEnv
        // This is a limitation of the current architecture
        // For now, return null and let the caller handle it
        // In Phase 2-3, we'll refactor TSQLCatalog to not require TSQLEnv

        return null;
    }

    @Override
    public List<TSQLCatalog> getAllCatalogs() {
        return new ArrayList<>(catalogCache.values());
    }

    @Override
    public String getDefaultCatalogName() {
        return defaultCatalogName;
    }

    @Override
    public void setDefaultCatalogName(String name) {
        this.defaultCatalogName = name;
    }

    @Override
    public TSQLSchemaObject findObject(String catalog, String schema,
                                        String objectName, ESQLDataObjectType type) {
        // Delegate directly to CatalogStore (it handles normalization internally)
        // The ICatalogProvider contract: TSQLEnv normalizes the segments before it asks.
        return catalogStore.getNormalized(catalog, schema, objectName, type);
    }

    @Override
    public void addObject(TSQLSchemaObject object) {
        if (object == null) {
            return;
        }

        // Add to CatalogStore
        catalogStore.put(object);

        // Update catalog cache if needed
        if (object.getSchema() != null && object.getSchema().getCatalog() != null) {
            TSQLCatalog catalog = object.getSchema().getCatalog();
            String normalizedName = identifierService.normalize(
                catalog.getName(),
                ESQLDataObjectType.dotCatalog
            );
            catalogCache.putIfAbsent(normalizedName, catalog);
        }
    }

    @Override
    public boolean removeObject(TSQLSchemaObject object) {
        if (object == null) {
            return false;
        }

        return catalogStore.remove(object);
    }

    @Override
    public void clear() {
        catalogStore.clear();
        catalogCache.clear();
    }

    @Override
    public int size() {
        return catalogStore.size();
    }

    /**
     * Get the underlying CatalogStore
     *
     * @return catalog store
     */
    public CatalogStore getCatalogStore() {
        return catalogStore;
    }

    /**
     * Get the IdentifierService
     *
     * @return identifier service
     */
    public IdentifierService getIdentifierService() {
        return identifierService;
    }

    /**
     * Register a catalog in the cache (used by TSQLEnv during migration)
     *
     * @param catalog the catalog to register
     */
    public void registerCatalog(TSQLCatalog catalog) {
        if (catalog == null) {
            return;
        }

        String normalizedName = identifierService.normalize(
            catalog.getName(),
            ESQLDataObjectType.dotCatalog
        );
        catalogCache.put(normalizedName, catalog);
    }
}