package gudusoft.gsqlparser;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.Map;

/**
 * Thread-safe parser pool implementation to replace the singleton pattern.
 * This pool dramatically improves performance in multi-threaded environments
 * by eliminating synchronized method bottlenecks.
 * 
 * Each database vendor has its own pool of parser instances that can be
 * borrowed and returned for reuse.
 */
public class TParserPool {
    
    // Pool configuration
    private static final int DEFAULT_POOL_SIZE = Runtime.getRuntime().availableProcessors() * 2;
    private static final int MAX_POOL_SIZE = 64;
    private static final long BORROW_TIMEOUT_MS = 5000;
    
    // Pools for each database vendor
    private final ConcurrentHashMap<EDbVendor, BlockingQueue<TGSqlParser>> parserPools;
    private final ConcurrentHashMap<EDbVendor, AtomicInteger> poolSizes;
    private final ConcurrentHashMap<EDbVendor, Semaphore> poolSemaphores;
    
    // Pool statistics for monitoring
    private final ConcurrentHashMap<EDbVendor, AtomicInteger> borrowCount;
    private final ConcurrentHashMap<EDbVendor, AtomicInteger> returnCount;
    private final ConcurrentHashMap<EDbVendor, AtomicInteger> createCount;
    
    private final int poolSize;
    private volatile boolean shutdown = false;
    
    /**
     * Creates a parser pool with default size
     */
    public TParserPool() {
        this(DEFAULT_POOL_SIZE);
    }
    
    /**
     * Creates a parser pool with specified size
     * @param poolSize Size of the pool for each vendor
     */
    public TParserPool(int poolSize) {
        this.poolSize = Math.min(poolSize, MAX_POOL_SIZE);
        this.parserPools = new ConcurrentHashMap<>();
        this.poolSizes = new ConcurrentHashMap<>();
        this.poolSemaphores = new ConcurrentHashMap<>();
        this.borrowCount = new ConcurrentHashMap<>();
        this.returnCount = new ConcurrentHashMap<>();
        this.createCount = new ConcurrentHashMap<>();
    }
    
    /**
     * Borrows a parser from the pool for the specified vendor.
     * If no parser is available, creates a new one up to the pool limit.
     * 
     * @param vendor Database vendor
     * @return Parser instance
     * @throws InterruptedException if interrupted while waiting
     */
    public TGSqlParser borrowParser(EDbVendor vendor) throws InterruptedException {
        if (shutdown) {
            throw new IllegalStateException("Parser pool has been shut down");
        }
        
        // Get or create the semaphore for this vendor
        Semaphore semaphore = poolSemaphores.computeIfAbsent(vendor, 
            v -> new Semaphore(poolSize, true));
        
        // Try to acquire a permit with timeout
        if (!semaphore.tryAcquire(BORROW_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
            throw new TimeoutException("Timeout waiting for available parser");
        }
        
        try {
            // Get or create the pool for this vendor
            BlockingQueue<TGSqlParser> pool = parserPools.computeIfAbsent(vendor, 
                v -> new LinkedBlockingQueue<>());
            
            // Update borrow statistics
            borrowCount.computeIfAbsent(vendor, v -> new AtomicInteger(0)).incrementAndGet();
            
            // Try to get an existing parser from the pool
            TGSqlParser parser = pool.poll();
            
            if (parser == null) {
                // No parser available, create a new one
                parser = createParser(vendor);
                AtomicInteger currentSize = poolSizes.computeIfAbsent(vendor, 
                    v -> new AtomicInteger(0));
                currentSize.incrementAndGet();
                createCount.computeIfAbsent(vendor, v -> new AtomicInteger(0)).incrementAndGet();
            }
            
            // Reset parser state before returning
            resetParser(parser);
            return parser;
            
        } catch (Exception e) {
            // Release permit if we fail to get a parser
            semaphore.release();
            throw new RuntimeException("Failed to borrow parser", e);
        }
    }
    
    /**
     * Returns a parser to the pool for reuse.
     * 
     * @param vendor Database vendor
     * @param parser Parser instance to return
     */
    public void returnParser(EDbVendor vendor, TGSqlParser parser) {
        if (parser == null) {
            return;
        }
        
        if (shutdown) {
            // Don't return to pool if shutting down
            return;
        }
        
        BlockingQueue<TGSqlParser> pool = parserPools.get(vendor);
        if (pool != null) {
            // Reset parser state before returning to pool
            resetParser(parser);
            
            // Try to return parser to pool
            if (pool.offer(parser)) {
                returnCount.computeIfAbsent(vendor, v -> new AtomicInteger(0)).incrementAndGet();
            }
        }
        
        // Release the semaphore permit
        Semaphore semaphore = poolSemaphores.get(vendor);
        if (semaphore != null) {
            semaphore.release();
        }
    }
    
    /**
     * Executes a function with a borrowed parser and automatically returns it.
     * This is the recommended way to use the pool.
     * 
     * @param vendor Database vendor
     * @param function Function to execute with the parser
     * @return Result of the function
     */
    public <T> T withParser(EDbVendor vendor, ParserFunction<T> function) throws Exception {
        TGSqlParser parser = null;
        try {
            parser = borrowParser(vendor);
            return function.apply(parser);
        } finally {
            if (parser != null) {
                returnParser(vendor, parser);
            }
        }
    }
    
    /**
     * Creates a new parser instance for the specified vendor.
     */
    private TGSqlParser createParser(EDbVendor vendor) {
        return new TGSqlParser(vendor);
    }
    
    /**
     * Resets parser state for reuse.
     */
    private void resetParser(TGSqlParser parser) {
        if (parser != null) {
            // Clear previous SQL text and results
            parser.sqltext = null;
            parser.sqlfilename = null;
            if (parser.sourcetokenlist != null) {
                parser.sourcetokenlist.clear();
            }
            if (parser.sqlstatements != null) {
                parser.sqlstatements.clear();
            }
            // Note: Some internal parser state cannot be reset from outside
            // The parser will handle this internally on next parse
        }
    }
    
    /**
     * Gets pool statistics for monitoring.
     */
    public PoolStatistics getStatistics(EDbVendor vendor) {
        return new PoolStatistics(
            poolSizes.getOrDefault(vendor, new AtomicInteger(0)).get(),
            borrowCount.getOrDefault(vendor, new AtomicInteger(0)).get(),
            returnCount.getOrDefault(vendor, new AtomicInteger(0)).get(),
            createCount.getOrDefault(vendor, new AtomicInteger(0)).get(),
            parserPools.containsKey(vendor) ? parserPools.get(vendor).size() : 0
        );
    }
    
    /**
     * Pre-warms the pool by creating parsers in advance.
     * This avoids the initialization cost during actual usage.
     * 
     * @param vendor Database vendor
     * @param count Number of parsers to pre-create (up to poolSize)
     */
    public void prewarm(EDbVendor vendor, int count) {
        if (shutdown) {
            throw new IllegalStateException("Parser pool has been shut down");
        }
        
        int toCreate = Math.min(count, poolSize);
        BlockingQueue<TGSqlParser> pool = parserPools.computeIfAbsent(vendor, 
            v -> new LinkedBlockingQueue<>());
        
        for (int i = 0; i < toCreate; i++) {
            TGSqlParser parser = createParser(vendor);
            resetParser(parser);
            pool.offer(parser);
            poolSizes.computeIfAbsent(vendor, v -> new AtomicInteger(0)).incrementAndGet();
            createCount.computeIfAbsent(vendor, v -> new AtomicInteger(0)).incrementAndGet();
        }
    }
    
    /**
     * Shuts down the pool and clears all parsers.
     */
    public void shutdown() {
        shutdown = true;
        parserPools.clear();
        poolSizes.clear();
        poolSemaphores.clear();
    }
    
    /**
     * Functional interface for parser operations.
     */
    @FunctionalInterface
    public interface ParserFunction<T> {
        T apply(TGSqlParser parser) throws Exception;
    }
    
    /**
     * Pool statistics for monitoring.
     */
    public static class PoolStatistics {
        public final int totalParsers;
        public final int borrowCount;
        public final int returnCount;
        public final int createCount;
        public final int availableParsers;
        
        public PoolStatistics(int totalParsers, int borrowCount, int returnCount, 
                             int createCount, int availableParsers) {
            this.totalParsers = totalParsers;
            this.borrowCount = borrowCount;
            this.returnCount = returnCount;
            this.createCount = createCount;
            this.availableParsers = availableParsers;
        }
        
        @Override
        public String toString() {
            return String.format("PoolStats[total=%d, available=%d, borrows=%d, returns=%d, creates=%d]",
                totalParsers, availableParsers, borrowCount, returnCount, createCount);
        }
    }
    
    /**
     * Custom exception for timeout scenarios.
     */
    public static class TimeoutException extends RuntimeException {
        public TimeoutException(String message) {
            super(message);
        }
    }
}