package gudusoft.gsqlparser.dlineage;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.dlineage.dataflow.model.Option;
import gudusoft.gsqlparser.dlineage.dataflow.model.SqlInfo;
import gudusoft.gsqlparser.dlineage.statistics.*;
import gudusoft.gsqlparser.nodes.TJoin;
import gudusoft.gsqlparser.nodes.TJoinItem;
import gudusoft.gsqlparser.nodes.TJoinItemList;
import gudusoft.gsqlparser.nodes.TJoinList;
import gudusoft.gsqlparser.stmt.*;
import gudusoft.gsqlparser.util.Logger;
import gudusoft.gsqlparser.util.LoggerFactory;
import gudusoft.gsqlparser.util.SQLUtil;
import gudusoft.gsqlparser.util.json.JSON;

import java.io.File;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * SQL file statistics utility class for analyzing various statistical information in SQL files.
 * Supports both multi-file statistics and single SQL statement statistics modes.
 * 
 * Single SQL statistics functionality:
 * 1. Create an instance using constructor SQLFileStatistics(String sqlContent, Option option)
 * 2. Call generateSingleSQLStatistics() method to get statistics results
 * 3. Or use the static convenience method analyzeSingleSQL(String sqlContent, Option option)
 * 
 * Single SQL statistics features:
 * - File size: counts the number of characters in SQL content
 * - Line count: counts the number of lines in SQL content
 * - Other statistics: same as file statistics, including statement types, JOINs, subqueries, etc.
 * 
 * Usage example:
 * <pre>
 * String sql = "SELECT * FROM table WHERE id = 1";
 * Option option = new Option();
 * option.setVendor(EDbVendor.dbvmysql);
 * 
 * // Method 1: Using static method
 * String result = SQLFileStatistics.analyzeSingleSQL(sql, option);
 * 
 * // Method 2: Using instance method
 * SQLFileStatistics analyzer = new SQLFileStatistics(sql, option);
 * String result = analyzer.generateSingleSQLStatistics();
 * </pre>
 */
public class SQLFileStatistics {
    private static final Logger logger = LoggerFactory.getLogger(SQLFileStatistics.class);

    private SqlInfo[] sqlInfos;
    private Option option;
    private List<FileStatistics> fileStatisticsList = new ArrayList<>();

    public SQLFileStatistics(SqlInfo[] sqlInfos, Option option) {
        if (sqlInfos == null) {
            this.sqlInfos = new SqlInfo[0];
        } else {
            this.sqlInfos = new SqlInfo[sqlInfos.length];
            for (int i = 0; i < sqlInfos.length; i++) {
                if (sqlInfos[i] == null) {
                    this.sqlInfos[i] = new SqlInfo();
                    this.sqlInfos[i].setSql("");
                    this.sqlInfos[i].setOriginIndex(i);
                } else {
                    this.sqlInfos[i] = sqlInfos[i];
                    this.sqlInfos[i].setOriginIndex(i);
                }
            }
        }
        this.option = option;
    }

    /**
     * Merge analysis results from another SQLFileStatistics object into the current object
     *
     * @param other The SQLFileStatistics object to merge
     */
    public void merge(SQLFileStatistics other) {
        if (other == null || other.fileStatisticsList == null || other.fileStatisticsList.isEmpty()) {
            return;
        }

        // Create a map of current file statistics for quick lookup
        Map<String, FileStatistics> currentFileStatsMap = new HashMap<>();
        for (FileStatistics stats : this.fileStatisticsList) {
            currentFileStatsMap.put(stats.getFile(), stats);
        }

        // Merge file statistics from another object
        for (FileStatistics otherStats : other.fileStatisticsList) {
            if (currentFileStatsMap.containsKey(otherStats.getFile())) {
                // If the current object already has statistics for this file, merge them
                FileStatistics currentStats = currentFileStatsMap.get(otherStats.getFile());
                mergeFileStatistics(currentStats, otherStats);
            } else {
                // If the current object doesn't have statistics for this file, add it directly
                this.fileStatisticsList.add(otherStats);
                currentFileStatsMap.put(otherStats.getFile(), otherStats);
            }
        }
    }

    /**
     * Merge two FileStatistics objects
     *
     * @param target Target FileStatistics object, where merged results will be stored
     * @param source Source FileStatistics object, which will not be changed after merging
     */
    private void mergeFileStatistics(FileStatistics target, FileStatistics source) {
        // Merge count-type statistics
        target.setTotal_statements(target.getTotal_statements() + source.getTotal_statements());
        target.setSelect_count(target.getSelect_count() + source.getSelect_count());
        target.setInsert_count(target.getInsert_count() + source.getInsert_count());
        target.setUpdate_count(target.getUpdate_count() + source.getUpdate_count());
        target.setDelete_count(target.getDelete_count() + source.getDelete_count());
        target.setMerge_count(target.getMerge_count() + source.getMerge_count());
        target.setCreate_table_count(target.getCreate_table_count() + source.getCreate_table_count());
        target.setCreate_temp_table_count(target.getCreate_temp_table_count() + source.getCreate_temp_table_count());
        target.setCtas_count(target.getCtas_count() + source.getCtas_count());
        target.setCreate_view_count(target.getCreate_view_count() + source.getCreate_view_count());
        target.setCreate_temp_view_count(target.getCreate_temp_view_count() + source.getCreate_temp_view_count());
        target.setDrop_count(target.getDrop_count() + source.getDrop_count());
        target.setTruncate_count(target.getTruncate_count() + source.getTruncate_count());
        target.setParse_error_count(target.getParse_error_count() + source.getParse_error_count());
        target.setJoin_count(target.getJoin_count() + source.getJoin_count());

        // Merge subquery depth (take maximum value)
        if (source.getSubquery_depth() > target.getSubquery_depth()) {
            target.setSubquery_depth(source.getSubquery_depth());
        }

        // Merge other counts
        target.setCte_count(target.getCte_count() + source.getCte_count());
        target.setCase_count(target.getCase_count() + source.getCase_count());
        target.setUnion_count(target.getUnion_count() + source.getUnion_count());
        target.setWindow_function_count(target.getWindow_function_count() + source.getWindow_function_count());
        target.setAggregate_function_count(target.getAggregate_function_count() + source.getAggregate_function_count());
        target.setWhere_predicate_count(target.getWhere_predicate_count() + source.getWhere_predicate_count());

        // Merge JOIN type statistics
        for (Map.Entry<String, Integer> entry : source.getJoin_types().entrySet()) {
            String joinType = entry.getKey();
            int count = entry.getValue();
            target.getJoin_types().put(joinType, target.getJoin_types().getOrDefault(joinType, 0) + count);
        }

        // Merge table references
        target.addTableReferences(source.getDistinct_table_references());

        // Merge created objects
        for (String object : source.getObjects_created()) {
            if (!target.getObjects_created().contains(object)) {
                target.addObject_created(object);
            }
        }

        // Merge read objects
        for (String object : source.getObjects_read()) {
            target.addObject_read(object);
        }
    }

    public SQLFileStatistics(String sqlContent, Option option) {
        SqlInfo[] sqlInfos = new SqlInfo[1];
        SqlInfo info = new SqlInfo();
        info.setSql(sqlContent);
        info.setOriginIndex(0);
        sqlInfos[0] = info;
        this.sqlInfos = sqlInfos;
        this.option = option;
    }

    public SQLFileStatistics(File[] sqlFiles, Option option) {
        SqlInfo[] sqlInfos = new SqlInfo[sqlFiles.length];
        for (int i = 0; i < sqlFiles.length; i++) {
            SqlInfo info = new SqlInfo();
            info.setSql(SQLUtil.getFileContent(sqlFiles[i]));
            info.setFileName(sqlFiles[i].getName());
            info.setFilePath(sqlFiles[i].getAbsolutePath());
            info.setOriginIndex(0);
            sqlInfos[i] = info;
        }
        this.sqlInfos = sqlInfos;
        this.option = option;
    }

    /**
 * Extract original file name from split file name
 * Split file name format: original_filename_file_index_start_line_end_line.extension
 *
 * @param filename Split file name
 * @return Original file name, return the original file name if it's not a split file
 */
    private String getOriginalFileName(String filename) {
        if (filename == null || filename.isEmpty()) {
            return filename;
        }

        // Use regular expression to match split file name format
        // Format: original_filename_number_number_number.extension
        String regex = "^(.*?)_\\d+_\\d+_\\d+\\.(.*)$";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(filename);

        if (matcher.matches()) {
            // If match is successful, return original file name (originalFilename.extension)
            return matcher.group(1) + "." + matcher.group(2);
        }

        // If not a split file, return original file name
        return filename;
    }

    /**
 * Extract original file name from file path
 *
 * @param filePath File path
 * @return Original file name, return the original file path if it's not a split file
 */
    private String getOriginalFilePath(String filePath) {
        if (filePath == null || filePath.isEmpty()) {
            return filePath;
        }

        File file = new File(filePath);
        String filename = file.getName();
        String originalFilename = getOriginalFileName(filename);

        if (originalFilename.equals(filename)) {
            // If not a split file, return original file path
            return filePath;
        }

        // If it is a split file, return original file path
        return new File(file.getParent(), originalFilename).getAbsolutePath();
    }

    public synchronized String generateSQLQueryStatistics() {
        if (sqlInfos == null || sqlInfos.length == 0) {
            return JSON.toJSONString(Collections.emptyMap());
        }

        // Get first SQL information
        SqlInfo sqlInfo = sqlInfos[0];
        if (sqlInfo == null || sqlInfo.getSql() == null || sqlInfo.getSql().trim().isEmpty()) {
            return JSON.toJSONString(Collections.emptyMap());
        }

        // Create statistics object for a single SQL
        FileStatistics sqlStats = new FileStatistics("sql_query");

        // For a single SQL, set SQL content length as "file size" and SQL line count as "line count"
        String sqlContent = sqlInfo.getSql();
        if (sqlContent != null) {
            sqlStats.setFile_size(sqlContent.length());

            // Calculate SQL line count
            int lineCount = sqlContent.split("\n").length;
            sqlStats.setLine_count(lineCount);
        }

        // Cache vendor type to avoid repeated calls
        EDbVendor vendor = option.getVendor();

        // Pre-create visitor objects to avoid repeated creation
        SubqueryDepthVisitor subqueryDepthVisitor = new SubqueryDepthVisitor();
        CaseVisitor caseVisitor = new CaseVisitor();
        WindowFunctionVisitor windowFunctionVisitor = new WindowFunctionVisitor();
        AggregateFunctionVisitor aggregateFunctionVisitor = new AggregateFunctionVisitor();
        TableReferenceVisitor tableReferenceVisitor = new TableReferenceVisitor();
        WherePredicateVisitor wherePredicateVisitor = new WherePredicateVisitor();

        // Pre-create SQL parser to avoid repeated creation
        TGSqlParser sqlparser = new TGSqlParser(vendor);
        sqlparser.sqltext = sqlInfo.getSql();

        int parseResult = sqlparser.parse();
        if (parseResult != 0) {
            logger.warn("SQL parse error: " + sqlparser.getErrormessage());
            // Use sqlparser.getErrorCount() to get the number of parse errors
            sqlStats.setParse_error_count(sqlparser.getErrorCount());
        }

        // Get statement list to avoid repeated calls
        int statementCount = sqlparser.sqlstatements.size();

        // Count each SQL statement
        for (int i = 0; i < statementCount; i++) {
            TCustomSqlStatement stmt = sqlparser.sqlstatements.get(i);
            sqlStats.incrementTotal_statements();

            // Count statement type
            countStatementType(sqlStats, stmt);

            // Count JOIN-related metrics
            countJoins(sqlStats, stmt);

            // Count subquery depth - reset visitor state
            subqueryDepthVisitor.reset();
            stmt.acceptChildren(subqueryDepthVisitor);
            int subqueryDepth = subqueryDepthVisitor.getMaxDepth();
            if (subqueryDepth > sqlStats.getSubquery_depth()) {
                sqlStats.setSubquery_depth(subqueryDepth);
            }

            // Count CTEs
            countCTEs(sqlStats, stmt);

            // Count CASE expressions - reset visitor state
            caseVisitor.reset();
            stmt.acceptChildren(caseVisitor);
            sqlStats.addCase_count(caseVisitor.getCaseCount());

            // Count UNIONs
            countUnions(sqlStats, stmt);

            // Count window functions - reset visitor state
            windowFunctionVisitor.reset();
            stmt.acceptChildren(windowFunctionVisitor);
            sqlStats.addWindow_function_count(windowFunctionVisitor.getWindowFunctionCount());

            // Count aggregate functions - reset visitor state
            aggregateFunctionVisitor.reset();
            stmt.acceptChildren(aggregateFunctionVisitor);
            sqlStats.addAggregate_function_count(aggregateFunctionVisitor.getAggregateFunctionCount());

            // Count table references - reset visitor state
            tableReferenceVisitor.reset();
            stmt.acceptChildren(tableReferenceVisitor);
            sqlStats.addTableReferences(tableReferenceVisitor.getTableReferences());

            // For SELECT statements, collect referenced tables
            if (stmt instanceof TSelectSqlStatement) {
                tableReferenceVisitor.getTableReferences().forEach(table -> {
                    sqlStats.addObject_read(table);
                });
            }

            // Count WHERE/HAVING predicates - reset visitor state
            if (stmt.getWhereClause() != null) {
                wherePredicateVisitor.reset();
                stmt.getWhereClause().acceptChildren(wherePredicateVisitor);
                sqlStats.addWhere_predicate_count(wherePredicateVisitor.getPredicateCount());
            }
            if (stmt.getStatements() != null) {
                for (int j = 0; j < stmt.getStatements().size(); j++) {
                    TCustomSqlStatement subStmt = stmt.getStatements().get(j);
                    if (subStmt.getWhereClause() == null) {
                        continue;
                    }
                    wherePredicateVisitor.reset();
                    subStmt.getWhereClause().acceptChildren(wherePredicateVisitor);
                    sqlStats.addWhere_predicate_count(wherePredicateVisitor.getPredicateCount());
                }
            }
        }

        // Generate JSON output
        Map result = new LinkedHashMap();
        result.put("file_statistics", sqlStats.toJSON());
        return JSON.toJSONString(result);
    }

    /**
 * Static method: Conveniently analyze a single SQL statement
 *
 * @param sqlContent SQL content to analyze
 * @param option     Analysis options
 * @return Statistical results in JSON format
 */
    public static String analyzeSingleSQL(String sqlContent, Option option) {
        SQLFileStatistics analyzer = new SQLFileStatistics(sqlContent, option);
        return analyzer.generateSQLQueryStatistics();
    }

    public synchronized String generateFileStatistics() {
        if (sqlInfos == null) {
            return JSON.toJSONString(Collections.emptyMap());
        }

        // Group statistics by file - identify and merge split files
        Map<String, List<SqlInfo>> fileSqlInfoMap = Arrays.stream(sqlInfos)
                .filter(info -> info != null && info.getSql() != null && !info.getSql().trim().isEmpty())
                .collect(Collectors.groupingBy(info -> {
                    if (info.getFilePath() != null && !info.getFilePath().isEmpty()) {
                        // If file path exists, check whether it is a split file
                        return getOriginalFilePath(info.getFilePath());
                    } else if (info.getFileName() != null && !info.getFileName().isEmpty()) {
                        // If only file name exists, check whether it is a split file
                        return getOriginalFileName(info.getFileName());
                    } else {
                        return "anonymous.sql";
                    }
                }));

        // Perform statistics for each file
        // Cache vendor type to avoid repeated calls
        EDbVendor vendor = option.getVendor();

        // Pre-create visitor objects to avoid repeated creation
        SubqueryDepthVisitor subqueryDepthVisitor = new SubqueryDepthVisitor();
        CaseVisitor caseVisitor = new CaseVisitor();
        WindowFunctionVisitor windowFunctionVisitor = new WindowFunctionVisitor();
        AggregateFunctionVisitor aggregateFunctionVisitor = new AggregateFunctionVisitor();
        TableReferenceVisitor tableReferenceVisitor = new TableReferenceVisitor();
        WherePredicateVisitor wherePredicateVisitor = new WherePredicateVisitor();

        // Pre-create SQL parser to avoid repeated creation
        TGSqlParser sqlparser = new TGSqlParser(vendor);

        // Traverse each file
        for (Map.Entry<String, List<SqlInfo>> entry : fileSqlInfoMap.entrySet()) {
            String filePath = entry.getKey();
            List<SqlInfo> fileSqlInfos = entry.getValue();

            // Pre-allocate FileStatistics object
            FileStatistics fileStats = new FileStatistics(filePath);

            // Collect file size and total line count
            File file = new File(filePath);
            collectSQLFileInfo(file, fileStats, filePath);

            // Parse all SQL statements in the file
            for (SqlInfo sqlInfo : fileSqlInfos) {
                // Reset parser state and set new SQL text
                sqlparser.sqltext = sqlInfo.getSql();

                int parseResult = sqlparser.parse();
                if (parseResult != 0) {
                    logger.warn("File: " + filePath + " SQL parse error: " + sqlparser.getErrormessage());
                    // Use sqlparser.getErrorCount() to get the number of parse errors
                    fileStats.setParse_error_count(fileStats.getParse_error_count() + sqlparser.getErrorCount());
                }
                // Get statement list to avoid repeated calls
                int statementCount = sqlparser.sqlstatements.size();

                // Count each SQL statement
                for (int i = 0; i < statementCount; i++) {
                    TCustomSqlStatement stmt = sqlparser.sqlstatements.get(i);
                    fileStats.incrementTotal_statements();

                    // Count statement type
                    countStatementType(fileStats, stmt);

                    // Count JOIN-related metrics
                    countJoins(fileStats, stmt);

                    // Count subquery depth - reset visitor state
                    subqueryDepthVisitor.reset();
                    stmt.acceptChildren(subqueryDepthVisitor);
                    int subqueryDepth = subqueryDepthVisitor.getMaxDepth();
                    if (subqueryDepth > fileStats.getSubquery_depth()) {
                        fileStats.setSubquery_depth(subqueryDepth);
                    }

                    // Count CTEs
                    countCTEs(fileStats, stmt);

                    // Count CASE expressions - reset visitor state
                    caseVisitor.reset();
                    stmt.acceptChildren(caseVisitor);
                    fileStats.addCase_count(caseVisitor.getCaseCount());

                    // Count UNIONs
                    countUnions(fileStats, stmt);

                    // Count window functions - reset visitor state
                    windowFunctionVisitor.reset();
                    stmt.acceptChildren(windowFunctionVisitor);
                    fileStats.addWindow_function_count(windowFunctionVisitor.getWindowFunctionCount());

                    // Count aggregate functions - reset visitor state
                    aggregateFunctionVisitor.reset();
                    stmt.acceptChildren(aggregateFunctionVisitor);
                    fileStats.addAggregate_function_count(aggregateFunctionVisitor.getAggregateFunctionCount());

                    // Count table references - reset visitor state
                    tableReferenceVisitor.reset();
                    stmt.acceptChildren(tableReferenceVisitor);
                    fileStats.addTableReferences(tableReferenceVisitor.getTableReferences());

                    // For SELECT statements, collect referenced tables
                    if (stmt instanceof TSelectSqlStatement) {
                        tableReferenceVisitor.getTableReferences().forEach(table -> {
                            fileStats.addObject_read(table);
                        });
                    }

                    // Count WHERE/HAVING predicates - reset visitor state
                    if (stmt.getWhereClause() != null) {
                        wherePredicateVisitor.reset();
                        stmt.getWhereClause().acceptChildren(wherePredicateVisitor);
                        fileStats.addWhere_predicate_count(wherePredicateVisitor.getPredicateCount());
                    }
                    if (stmt.getStatements() != null) {
                        for (int j = 0; j < stmt.getStatements().size(); j++) {
                            TCustomSqlStatement subStmt = stmt.getStatements().get(j);
                            if (subStmt.getWhereClause() == null) {
                                continue;
                            }
                            wherePredicateVisitor.reset();
                            subStmt.getWhereClause().acceptChildren(wherePredicateVisitor);
                            fileStats.addWhere_predicate_count(wherePredicateVisitor.getPredicateCount());
                        }
                    }
                }
            }

            fileStatisticsList.add(fileStats);
        }

        // Generate JSON output
        Map result = new LinkedHashMap();
        List fileStatsArray = new ArrayList();

        for (FileStatistics stat : fileStatisticsList) {
            fileStatsArray.add(stat.toJSON());
        }

        result.put("file_statistics", fileStatsArray);
        return JSON.toJSONString(result);
    }

    private void collectSQLFileInfo(File file, FileStatistics fileStats, String filePath) {
        if (file.exists()) {
            // Collect file size
            fileStats.setFile_size(file.length());

            // Collect total line count
            try (java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.FileReader(file))) {
                int lineCount = 0;
                while (reader.readLine() != null) {
                    lineCount++;
                }
                fileStats.setLine_count(lineCount);
            } catch (java.io.IOException e) {
                logger.warn("Error collecting total line count for file: " + filePath + ", message: " + e.getMessage());
            }
        }
    }

    private void countStatementType(FileStatistics fileStats, TCustomSqlStatement stmt) {
        if (stmt instanceof TSelectSqlStatement) {
            fileStats.incrementSelect_count();
        } else if (stmt instanceof TInsertSqlStatement) {
            fileStats.incrementInsert_count();
        } else if (stmt instanceof TUpdateSqlStatement) {
            fileStats.incrementUpdate_count();
        } else if (stmt instanceof TDeleteSqlStatement) {
            fileStats.incrementDelete_count();
        } else if (stmt instanceof TMergeSqlStatement) {
            fileStats.incrementMerge_count();
        } else if (stmt instanceof TCreateTableSqlStatement) {
            TCreateTableSqlStatement createTableStmt = (TCreateTableSqlStatement) stmt;
            // Check whether it is a temporary table
            if (createTableStmt.getTableKinds() != null && (
                    createTableStmt.getTableKinds().contains(ETableKind.etkTemporary) ||
                            createTableStmt.getTableKinds().contains(ETableKind.etkTemp) ||
                            createTableStmt.getTableKinds().contains(ETableKind.etkLocalTemporary) ||
                            createTableStmt.getTableKinds().contains(ETableKind.etkLocalTemp) ||
                            createTableStmt.getTableKinds().contains(ETableKind.etkGlobalTemporary) ||
                            createTableStmt.getTableKinds().contains(ETableKind.etkGlobalTemp))) {
                fileStats.incrementCreate_temp_table_count();
            } else {
                fileStats.incrementCreate_table_count();
            }
            // Check whether it is CTAS
            if (createTableStmt.getSubQuery() != null) {
                fileStats.incrementCtas_count();
            }

            fileStats.addObject_created(createTableStmt.getTargetTable().toString());
        } else if (stmt instanceof TCreateViewSqlStatement) {
            TCreateViewSqlStatement createViewStmt = (TCreateViewSqlStatement) stmt;
            // Check whether it is a temporary view
            boolean isTempView = false;
            if (createViewStmt.getTableKind() != null) {
                ETableKind tableKind = createViewStmt.getTableKind();
                isTempView = (tableKind == ETableKind.etkTemporary ||
                        tableKind == ETableKind.etkTemp ||
                        tableKind == ETableKind.etkLocalTemporary ||
                        tableKind == ETableKind.etkLocalTemp ||
                        tableKind == ETableKind.etkGlobalTemporary ||
                        tableKind == ETableKind.etkGlobalTemp);
            }

            if (isTempView) {
                fileStats.incrementCreate_temp_view_count();
            } else {
                fileStats.incrementCreate_view_count();
            }

            fileStats.addObject_created(createViewStmt.getViewName().toString());
        } else if (stmt.sqlstatementtype.toString().toLowerCase().startsWith("sstdrop")) {
            fileStats.incrementDrop_count();
        } else if (stmt instanceof TTruncateStatement) {
            fileStats.incrementTruncate_count();
        }
    }

    private void countJoins(FileStatistics fileStats, TCustomSqlStatement stmt) {
        // Use a set to track processed joins to avoid duplicate counting
        Set<TJoin> processedJoins = new HashSet<>();
        // Recursively process all statements and their child statements
        processStatementsForJoins(fileStats, stmt, processedJoins);
    }

    /**
     * Recursively process all statements and their child statements to collect join information
     *
     * @param fileStats      statistics object
     * @param stmt           current statement being processed
     * @param processedJoins set of processed joins for de-duplication
     */
    private void processStatementsForJoins(FileStatistics fileStats, TCustomSqlStatement stmt, Set<TJoin> processedJoins) {
        if (stmt == null) {
            return;
        }

        // Process joins for current statement
        TJoinList joins = stmt.getJoins();
        if (joins != null && joins.size() > 0) {
            for (int i = 0; i < joins.size(); i++) {
                TJoin join = joins.getJoin(i);
                // Check whether this join has already been processed
                if (!processedJoins.contains(join)) {
                    processedJoins.add(join);
                    TJoinItemList joinItems = join.getJoinItems();
                    if (joinItems != null && joinItems.size() > 0) {
                        for (int j = 0; j < joinItems.size(); j++) {
                            TJoinItem joinItem = joinItems.getJoinItem(j);
                            EJoinType joinType = joinItem.getJoinType();
                            if (joinType != null) {
                                fileStats.incrementJoin_count();

                                // Classify concrete join types into five main types: INNER, LEFT, RIGHT, FULL, CROSS
                                String joinTypeStr = joinType.toString().toLowerCase();
                                String mainJoinType = "";

                                // Determine main type based on specific join type
                                switch (joinType) {
                                    case inner:
                                    case join:
                                    case natural_inner:
                                        mainJoinType = "inner";
                                        break;
                                    case left:
                                    case leftouter:
                                    case natural_left:
                                    case natural_leftouter:
                                    case leftsemi:
                                    case leftanti:
                                        mainJoinType = "left";
                                        break;
                                    case right:
                                    case rightouter:
                                    case natural_right:
                                    case natural_rightouter:
                                        mainJoinType = "right";
                                        break;
                                    case full:
                                    case fullouter:
                                    case natural_full:
                                    case natural_fullouter:
                                        mainJoinType = "full";
                                        break;
                                    case cross:
                                        mainJoinType = "cross";
                                        break;
                                    default:
                                        // For other types, keep original type string
                                        mainJoinType = joinTypeStr;
                                        break;
                                }

                                fileStats.addJoin_type(mainJoinType);
                            }
                        }
                    }
                }
        }
        }

        // Process child statements
        TStatementList statements = stmt.getStatements();
        if (statements != null && statements.size() > 0) {
            for (TCustomSqlStatement subStmt : statements) {
                processStatementsForJoins(fileStats, subStmt, processedJoins);
            }
        }
    }

    private void countCTEs(FileStatistics fileStats, TCustomSqlStatement stmt) {
        if (stmt.getCteList() != null) {
            fileStats.addCte_count(stmt.getCteList().size());
        }
    }

    private void countUnions(FileStatistics fileStats, TCustomSqlStatement stmt) {
        if (stmt instanceof TSelectSqlStatement) {
            TSelectSqlStatement selectStmt = (TSelectSqlStatement) stmt;
            if (selectStmt.getSetOperatorType() != ESetOperatorType.none) {
                // Count this union operation
                fileStats.incrementUnion_count();

                // Recursively process left and right statements
                countUnions(fileStats, selectStmt.getLeftStmt());
                countUnions(fileStats, selectStmt.getRightStmt());
            }
        }
    }


}