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.calcite.CatalogStore;

import java.util.ArrayList;
import java.util.List;
import java.util.HashMap;
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 HashMap<>();

    /**
     * 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.vendor = vendor;

        // Create IdentifierProfile and IdentifierService
        IdentifierProfile profile = IdentifierProfile.forVendor(vendor, flags);
        gudusoft.gsqlparser.sqlenv.CollatorProvider collatorProvider = null;
        if (vendor == EDbVendor.dbvmssql || vendor == EDbVendor.dbvazuresql) {
            collatorProvider = new gudusoft.gsqlparser.sqlenv.CollatorProvider();
        }
        this.identifierService = new IdentifierService(profile, collatorProvider);

        // Create CatalogStore with IdentifierService for proper normalization
        this.catalogStore = new CatalogStore(vendor, this.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)
        return catalogStore.get(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);
    }
}