package gudusoft.gsqlparser;

import java.util.concurrent.ConcurrentHashMap;

/**
 * Factory class for managing parser pool instances.
 * Provides singleton access to parser pools and configuration options.
 */
public class TParserPoolFactory {
    
    // Global shared pool instance
    private static volatile TParserPool sharedPool;
    
    // Named pool instances for specific use cases
    private static final ConcurrentHashMap<String, TParserPool> namedPools = new ConcurrentHashMap<>();
    
    // Configuration
    private static int defaultPoolSize = Runtime.getRuntime().availableProcessors() * 2;
    
    /**
     * Private constructor to prevent instantiation
     */
    private TParserPoolFactory() {
    }
    
    /**
     * Gets the shared global parser pool instance.
     * Creates it lazily with double-checked locking.
     * 
     * @return Shared parser pool instance
     */
    public static TParserPool getSharedPool() {
        if (sharedPool == null) {
            synchronized (TParserPoolFactory.class) {
                if (sharedPool == null) {
                    sharedPool = new TParserPool(defaultPoolSize);
                }
            }
        }
        return sharedPool;
    }
    
    /**
     * Creates or gets a named parser pool.
     * Useful for isolating pools for different components or use cases.
     * 
     * @param name Pool name
     * @param poolSize Size of the pool
     * @return Named parser pool instance
     */
    public static TParserPool getNamedPool(String name, int poolSize) {
        return namedPools.computeIfAbsent(name, k -> new TParserPool(poolSize));
    }
    
    /**
     * Gets a named parser pool with default size.
     * 
     * @param name Pool name
     * @return Named parser pool instance
     */
    public static TParserPool getNamedPool(String name) {
        return getNamedPool(name, defaultPoolSize);
    }
    
    /**
     * Sets the default pool size for new pools.
     * 
     * @param size Default pool size
     */
    public static void setDefaultPoolSize(int size) {
        if (size > 0) {
            defaultPoolSize = size;
        }
    }
    
    /**
     * Resets the shared pool instance.
     * The old pool is shut down and a new one will be created on next access.
     */
    public static synchronized void resetSharedPool() {
        if (sharedPool != null) {
            sharedPool.shutdown();
            sharedPool = null;
        }
    }
    
    /**
     * Removes and shuts down a named pool.
     * 
     * @param name Pool name
     */
    public static void removeNamedPool(String name) {
        TParserPool pool = namedPools.remove(name);
        if (pool != null) {
            pool.shutdown();
        }
    }
    
    /**
     * Shuts down all pools.
     */
    public static void shutdownAll() {
        resetSharedPool();
        namedPools.values().forEach(TParserPool::shutdown);
        namedPools.clear();
    }
    
    /**
     * Convenience method to parse SQL using the shared pool.
     * This is a drop-in replacement for direct TGSqlParser usage.
     * 
     * @param vendor Database vendor
     * @param sqlText SQL text to parse
     * @return Parse result (0 for success, non-zero for errors)
     */
    public static int parseSQL(EDbVendor vendor, String sqlText) {
        TGSqlParser parser = null;
        try {
            parser = getSharedPool().borrowParser(vendor);
            parser.sqltext = sqlText;
            return parser.parse();
        } catch (Exception e) {
            return -1;
        } finally {
            if (parser != null) {
                getSharedPool().returnParser(vendor, parser);
            }
        }
    }
    
    /**
     * Convenience method to tokenize SQL using the shared pool.
     * 
     * @param vendor Database vendor
     * @param sqlText SQL text to tokenize
     * @return 0 for success, -1 for error
     */
    public static int tokenizeSQL(EDbVendor vendor, String sqlText) {
        TGSqlParser parser = null;
        try {
            parser = getSharedPool().borrowParser(vendor);
            parser.sqltext = sqlText;
            parser.tokenizeSqltext();
            return 0; // Success
        } catch (Exception e) {
            return -1;
        } finally {
            if (parser != null) {
                getSharedPool().returnParser(vendor, parser);
            }
        }
    }
    
    /**
     * Gets statistics for all pools.
     * 
     * @return String representation of all pool statistics
     */
    public static String getAllStatistics() {
        StringBuilder sb = new StringBuilder();
        sb.append("=== Parser Pool Statistics ===\n");
        
        if (sharedPool != null) {
            sb.append("\nShared Pool:\n");
            for (EDbVendor vendor : EDbVendor.values()) {
                TParserPool.PoolStatistics stats = sharedPool.getStatistics(vendor);
                if (stats.totalParsers > 0) {
                    sb.append("  ").append(vendor).append(": ").append(stats).append("\n");
                }
            }
        }
        
        if (!namedPools.isEmpty()) {
            sb.append("\nNamed Pools:\n");
            namedPools.forEach((name, pool) -> {
                sb.append("  Pool '").append(name).append("':\n");
                for (EDbVendor vendor : EDbVendor.values()) {
                    TParserPool.PoolStatistics stats = pool.getStatistics(vendor);
                    if (stats.totalParsers > 0) {
                        sb.append("    ").append(vendor).append(": ").append(stats).append("\n");
                    }
                }
            });
        }
        
        return sb.toString();
    }
}