package gudusoft.gsqlparser.dlineage.dataflow.model;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.dlineage.dataflow.listener.DataFlowHandleListener;
import gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlTrustMode;
import gudusoft.gsqlparser.sqlenv.IdentifierProfile;

public class Option implements Cloneable {

    private boolean collectCommentBindings;
    private int commentBindingMaxRawLength = 8192;
    private int commentBindingMaxCommentsPerSourceUnit = 50000;
    private int commentBindingMaxTotalRawLength = 4 * 1024 * 1024;

    /** Collect source comment occurrences without changing legacy comments or lineage. */
    public boolean isCollectCommentBindings() { return collectCommentBindings; }
    public void setCollectCommentBindings(boolean value) { collectCommentBindings = value; }
    public int getCommentBindingMaxRawLength() { return commentBindingMaxRawLength; }
    public void setCommentBindingMaxRawLength(int value) {
        if (value < 0) throw new IllegalArgumentException("Comment limit must be nonnegative");
        commentBindingMaxRawLength = value;
    }
    public int getCommentBindingMaxCommentsPerSourceUnit() { return commentBindingMaxCommentsPerSourceUnit; }
    public void setCommentBindingMaxCommentsPerSourceUnit(int value) {
        if (value < 0) throw new IllegalArgumentException("Comment limit must be nonnegative");
        commentBindingMaxCommentsPerSourceUnit = value;
    }
    public int getCommentBindingMaxTotalRawLength() { return commentBindingMaxTotalRawLength; }
    public void setCommentBindingMaxTotalRawLength(int value) {
        if (value < 0) throw new IllegalArgumentException("Comment limit must be nonnegative");
        commentBindingMaxTotalRawLength = value;
    }

    private EDbVendor vendor;
    private EDbVendor powerQueryInnerVendor;
    private DataFlowHandleListener handleListener;
    private boolean simpleOutput;
    private boolean textFormat = false;
    private boolean showJoin = false;
    private boolean ignoreRecordSet = false;
    private boolean ignoreTemporaryTable = false;
    private boolean ignoreTopSelect = false;
    private boolean ignoreUnusedSynonym = true;
    private boolean showCallRelation = false;
    private boolean simpleShowFunction = false;
    private boolean simpleShowSynonym = false;
    private boolean simpleShowUdfFunctionOnly = false;
    private boolean simpleShowCursor = false;
    private boolean simpleShowVariable = false;
    private boolean simpleRetainIntermediate = false;
    private boolean simpleShowTopSelectResultSet = false;
    private boolean linkOrphanColumnToFirstTable = false;
    private boolean ignoreCoordinate = false;
    private boolean transform = false;
    private boolean transformCoordinate = false;
    /**
     * Whether SQL Server parsers created by {@code DataFlowAnalyzer} accept
     * colon-prefixed bind variables such as {@code :name}, {@code :1}, and
     * {@code :@name}. This compatibility extension is disabled by default.
     */
    private boolean enableMssqlColonBindVariables = false;
    /**
     * Whether {@code DataFlowAnalyzer} should collect the immutable semantic
     * sidecar consumed by the SLPC adapter.
     *
     * <p>This is deliberately opt-in. The established dlineage XML/JSON model
     * remains the default execution path, with no AST traversal or sidecar
     * bookkeeping added for callers that do not request SLPC projection.
     * Parallel analysis currently forces this option off because merged legacy
     * IDs are remapped and cannot yet be correlated safely to worker evidence.</p>
     */
    private boolean collectAuthoritativeLineageEvidence = false;
    private boolean showImplicitSchema = false;
    private boolean showCountTableColumn = true;
    private boolean showConstantTable = false;
    private boolean showCaseWhenAsDirect = true;
    private String filePathDatabase;
    private String filePathSchema;
    private long startId = 0;
    private boolean output = true;
    private boolean traceSQL = false;
    private boolean showComment = false;
    private boolean traceProcedure = false;
    private int parallel = Runtime.getRuntime().availableProcessors() / 2 - 1;
    private String defaultServer;
    private String defaultDatabase;
    private String defaultSchema;
    private boolean showERDiagram = false;
    private Set<ResultSetType> targetResultSetTypes = new HashSet<ResultSetType>(); 
    private Set<String> filterRelationTypes = new HashSet<String>();
    private Set<String> simpleShowRelationTypes = new HashSet<String>();
    private boolean sqlflowIgnoreFunction = false;
    private DynamicSqlTrustMode dynamicSqlTrustMode = DynamicSqlTrustMode.LEGACY;
    /** Whether execution statements may analyze embedded/generated SQL text.
     *  Defaults true for compatibility. Routine-summary extraction disables
     *  it so dynamic relationships cannot lose their site provenance when
     *  collapsed into an ordinary base-summary edge. */
    private boolean analyzeDynamicSql = true;

    private Set<String> excludedProcedureNames = new HashSet<String>();

    /**
     * Wildcard patterns to exclude procedures from analysis.
     * <p>
     * Supports the following wildcard characters:
     * <ul>
     *   <li><code>*</code> - Matches any sequence of characters (e.g., <code>SCHEMA1.*</code> matches all procedures in SCHEMA1)</li>
     *   <li><code>?</code> - Matches any single character (e.g., <code>SCHEMA?.PROC?</code> matches SCHEMA1.PROC1, SCHEMA2.PROC2, etc.)</li>
     *   <li><code>.</code> - Reserved as schema/procedure name separator (e.g., <code>SCHEMA.PROC</code> matches a two-segment qualified name)</li>
     * </ul>
     * <p>
     * Examples:
     * <ul>
     *   <li><code>"SCHEMA1.*"</code> - Excludes all procedures in SCHEMA1</li>
     *   <li><code>"*.SP_*"</code> - Excludes all procedures starting with SP_ in any schema</li>
     *   <li><code>"*_TEST"</code> - Excludes all procedures ending with _TEST in any schema</li>
     *   <li><code>"SCHEMA?.PROC?"</code> - Excludes procedures like SCHEMA1.PROC1, SCHEMA2.PROC2, etc.</li>
     *   <li><code>"DB.SCHEMA.PROC"</code> - Excludes a specific three-segment procedure</li>
     * </ul>
     * <p>
     * Note: Pattern matching is case-insensitive. Quoted identifiers (double quotes, square brackets, backticks, single quotes)
     * will be automatically stripped before matching.
     */
    private Set<String> excludedProcedurePatterns = new HashSet<String>();
    private boolean showCandidateTable = true;
    private boolean ignoreInsertIntoValues = true;
    private boolean normalizeOutput = false;
    /*
     * Whether to trace all table positions. Default is false.
     */
    private boolean traceTablePosition = false;

    private boolean enablePipelinedStitching = true;

    /**
     * B3 (routine-summary-scc-design §3): object-level per-overload variable
     * pools — the identity-first createVariable path. OFF by default: LEGACY
     * keeps the historical shared-key merge of same-named overload formals;
     * only the SHADOW/ENHANCED pipelines switch this on. Folds into
     * ProceduralLineageOptions in B6.
     */
    private boolean identityFirstVariablePools = false;
    private int maxPipelinedExpansionDepth = 8;
    private int maxStitchedSourcesPerColumn = 64;

    private AnalyzeMode analyzeMode;

    public EDbVendor getVendor() {
        return vendor;
    }

    public void setVendor(EDbVendor vendor) {
        this.vendor = vendor;
    }

    /**
     * Identifier configuration for this analysis, per object category; null means the vendor
     * default.
     */
    private IdentifierProfile identifierProfile;

    /**
     * The identifier configuration this analysis compares, normalizes and keys names under.
     *
     * @return the profile, or null when the vendor default applies
     */
    public IdentifierProfile getIdentifierProfile() {
        return identifierProfile;
    }

    /**
     * Configure how identifiers are compared for this analysis, per object category — for
     * example BigQuery table names compared case-insensitively while catalog, schema and column
     * keep their documented rules:
     *
     * <pre>
     * Option option = new Option();
     * option.setVendor(EDbVendor.dbvbigquery);
     * option.setIdentifierProfile(IdentifierProfile.builder(EDbVendor.dbvbigquery)
     *         .withObjectRules(ESQLDataObjectType.dotTable,
     *                 new IdentifierRules(CaseFold.NONE, CaseCompare.INSENSITIVE,
     *                                     CaseFold.NONE, CaseCompare.INSENSITIVE))
     *         .build());
     * new DataFlowAnalyzer(sql, option).generateDataFlow();
     * </pre>
     *
     * <p>Set it BEFORE {@code generateDataFlow()}. The analyzer takes a snapshot at entry and the
     * whole run — catalog registration and lookup, the parser and resolver, lineage model keys and
     * output merging — uses that snapshot, so mutating this option mid-run changes nothing.
     * Two analyzers may run concurrently under opposite configurations.
     *
     * <p>This is the analysis assumption the CALLER states. GSP does not read it from a live
     * server, and {@code CREATE SCHEMA ... OPTIONS(is_case_insensitive=...)} in the script is
     * parsed but NOT interpreted as a configuration change.
     *
     * @param identifierProfile the configuration, or null for the vendor default
     */
    public void setIdentifierProfile(IdentifierProfile identifierProfile) {
        this.identifierProfile = identifierProfile;
    }

    /**
     * Explicit SQL dialect for the inner SQL embedded in Power Query
     * {@code Value.NativeQuery()} calls and for navigation-chain synthetic
     * SELECTs. When set, this takes precedence over the connector-based
     * inference performed by {@code TPowerQueryAnalyzer}; when {@code null}
     * (default), inference is used.
     */
    public EDbVendor getPowerQueryInnerVendor() {
        return powerQueryInnerVendor;
    }

    public void setPowerQueryInnerVendor(EDbVendor powerQueryInnerVendor) {
        this.powerQueryInnerVendor = powerQueryInnerVendor;
    }

    public DataFlowHandleListener getHandleListener() {
        return handleListener;
    }

    public void setHandleListener(DataFlowHandleListener handleListener) {
        this.handleListener = handleListener;
    }

    public boolean isSimpleOutput() {
        return simpleOutput;
    }

    public void setSimpleOutput(boolean simpleOutput) {
        this.simpleOutput = simpleOutput;
    }

    public boolean isTextFormat() {
        return textFormat;
    }

    public void setTextFormat(boolean textFormat) {
        this.textFormat = textFormat;
    }

    public boolean isShowJoin() {
        return showJoin;
    }

    public void setShowJoin(boolean showJoin) {
        this.showJoin = showJoin;
    }

    /**
     * When true, every non-RESOLVED dynamic-SQL site (including SHADOW's PARTIAL sites) is also
     * mirrored into an {@link ErrorInfo} (type {@link ErrorInfo#DYNAMIC_SQL_UNRESOLVED}) so callers reading
     * {@code getErrorMessages()} can see them. Default false, so existing callers are unaffected;
     * the structured list is always available via {@code DataFlowAnalyzer.getDynamicSqlSites()}.
     */
    private boolean reportDynamicSqlSitesAsErrors = false;

    public boolean isReportDynamicSqlSitesAsErrors() {
        return reportDynamicSqlSitesAsErrors;
    }

    public void setReportDynamicSqlSitesAsErrors(boolean reportDynamicSqlSitesAsErrors) {
        this.reportDynamicSqlSitesAsErrors = reportDynamicSqlSitesAsErrors;
    }

    /**
     * Observation policy for incompletely materialized dynamic SQL. The default
     * {@link DynamicSqlTrustMode#LEGACY} retains historical output. SHADOW keeps
     * the exact same model and adds incompleteness diagnostics.
     */
    public DynamicSqlTrustMode getDynamicSqlTrustMode() {
        return dynamicSqlTrustMode;
    }

    public void setDynamicSqlTrustMode(DynamicSqlTrustMode dynamicSqlTrustMode) {
        this.dynamicSqlTrustMode = dynamicSqlTrustMode == null
                ? DynamicSqlTrustMode.LEGACY : dynamicSqlTrustMode;
    }

    /**
     * Controls inner analysis of dynamic SQL text. When false, ordinary
     * static statements and static routine calls are still analyzed, but
     * EXEC-string, sp_executesql, EXECUTE IMMEDIATE, DBMS_SQL.PARSE, and
     * similar embedded-text expansions publish no relationships.
     */
    public boolean isAnalyzeDynamicSql() {
        return analyzeDynamicSql;
    }

    public void setAnalyzeDynamicSql(boolean analyzeDynamicSql) {
        this.analyzeDynamicSql = analyzeDynamicSql;
    }

    /**
     * Whether the dynamic SQL evaluation compares strings case-sensitively when it runs a query over a table
     * variable or temporary table the procedure fills with literal rows (Mantis 4962). Default false, as SQL Server's
     * default {@code _CI_AS} collations do; trailing spaces are ignored either way.
     */
    private boolean dynamicSqlCaseSensitiveCompare = false;

    public boolean isDynamicSqlCaseSensitiveCompare() {
        return dynamicSqlCaseSensitiveCompare;
    }

    public void setDynamicSqlCaseSensitiveCompare(boolean dynamicSqlCaseSensitiveCompare) {
        this.dynamicSqlCaseSensitiveCompare = dynamicSqlCaseSensitiveCompare;
    }

    /**
     * Recover T-SQL routines whose body holds statements the grammar rejects (see
     * {@code TGSqlParser.setRecoverRoutineBodyErrors}): the statements holding syntax errors are skipped and the
     * routine is analyzed with the rest of its body, instead of yielding no lineage at all. The skipped statements
     * are still reported as syntax errors. It applies to the analyzed SQL itself; SQL parsed on the way (dynamic SQL,
     * routines found elsewhere) is parsed as written. Off by default.
     */
    public boolean isRecoverRoutineBodyErrors() {
        return recoverRoutineBodyErrors;
    }

    public void setRecoverRoutineBodyErrors(boolean recoverRoutineBodyErrors) {
        this.recoverRoutineBodyErrors = recoverRoutineBodyErrors;
    }

    private boolean recoverRoutineBodyErrors = false;

    public boolean isIgnoreRecordSet() {
        return ignoreRecordSet;
    }

    public void setIgnoreRecordSet(boolean ignoreRecordSet) {
        this.ignoreRecordSet = ignoreRecordSet;
    }

    public boolean isLinkOrphanColumnToFirstTable() {
        return linkOrphanColumnToFirstTable;
    }

    public void setLinkOrphanColumnToFirstTable(boolean linkOrphanColumnToFirstTable) {
        this.linkOrphanColumnToFirstTable = linkOrphanColumnToFirstTable;
    }

    /**
     * When true, dlineage ASSUMES that an external script
     * ({@code sp_execute_external_script}) passes its input dataset through to the
     * declared {@code WITH RESULT SETS} output positionally, emitting
     * {@link gudusoft.gsqlparser.dlineage.dataflow.model.EffectType#external_script_passthrough}
     * edges from each @input_data_1 column to the corresponding output column.
     *
     * <p>The script body (Python/R/…) is opaque and may reorder, drop or
     * synthesize columns, so these edges are an assumption, not proven lineage —
     * hence the dedicated effect type. Default {@code true}: column-level lineage
     * flows THROUGH the script (e.g. across an {@code INSERT ... EXEC} that
     * consumes the procedure's result set), with every assumed edge marked
     * {@code external_script_passthrough} so it stays distinguishable from proven
     * lineage. Set to {@code false} to suppress the assumption: the input query's
     * source lineage is still emitted, but it stops at the script boundary (it is
     * not connected to the output columns).
     */
    private boolean assumeExternalScriptPassthrough = true;

    public boolean isAssumeExternalScriptPassthrough() {
        return assumeExternalScriptPassthrough;
    }

    public void setAssumeExternalScriptPassthrough(boolean assumeExternalScriptPassthrough) {
        this.assumeExternalScriptPassthrough = assumeExternalScriptPassthrough;
    }

    public boolean isIgnoreCoordinate() {
        return ignoreCoordinate;
    }

    public void setIgnoreCoordinate(boolean ignoreCoordinate) {
        this.ignoreCoordinate = ignoreCoordinate;
    }

    public boolean isTransform() {
        return transform;
    }

    public void setTransform(boolean transform) {
        this.transform = transform;
    }

    public boolean isTransformCoordinate() {
        return transformCoordinate;
    }

    public void setTransformCoordinate(boolean transformCoordinate) {
        this.transformCoordinate = transformCoordinate;
    }

    public boolean isMssqlColonBindVariablesEnabled() {
        return enableMssqlColonBindVariables;
    }

    public void setEnableMssqlColonBindVariables(boolean enabled) {
        this.enableMssqlColonBindVariables = enabled;
    }

    public boolean isCollectAuthoritativeLineageEvidence() {
        return collectAuthoritativeLineageEvidence;
    }

    public void setCollectAuthoritativeLineageEvidence(boolean collectAuthoritativeLineageEvidence) {
        this.collectAuthoritativeLineageEvidence = collectAuthoritativeLineageEvidence;
    }

    public boolean isSimpleShowFunction() {
        return simpleShowFunction;
    }

    public void setSimpleShowFunction(boolean simpleShowFunction) {
        this.simpleShowFunction = simpleShowFunction;
    }

    public boolean isSimpleShowSynonym() {
        return simpleShowSynonym;
    }

    public void setSimpleShowSynonym(boolean simpleShowSynonym) {
        this.simpleShowSynonym = simpleShowSynonym;
    }

    public boolean isSimpleShowTopSelectResultSet() {
        return simpleShowTopSelectResultSet;
    }

    public void setSimpleShowTopSelectResultSet(boolean simpleShowTopSelectResultSet) {
        this.simpleShowTopSelectResultSet = simpleShowTopSelectResultSet;
    }

    public boolean isShowImplicitSchema() {
        return showImplicitSchema;
    }

    public void setShowImplicitSchema(boolean showImplicitSchema) {
        this.showImplicitSchema = showImplicitSchema;
    }

    public boolean isShowCountTableColumn() {
        return showCountTableColumn;
    }

    public void setShowCountTableColumn(boolean showCountTableColumn) {
        this.showCountTableColumn = showCountTableColumn;
    }

    public boolean isShowConstantTable() {
        return showConstantTable;
    }

    public void setShowConstantTable(boolean showConstantTable) {
        this.showConstantTable = showConstantTable;
    }

    public long getStartId() {
        return startId;
    }

    public void setStartId(long startId) {
        this.startId = startId;
    }

    public boolean isOutput() {
        return output;
    }

    public void setOutput(boolean output) {
        this.output = output;
    }

    public int getParallel() {
        return parallel;
    }

    public void setParallel(int parallel) {
        this.parallel = parallel;
    }

    public boolean isTraceSQL() {
        return traceSQL;
    }

    /**
     * Whether the comment a script author wrote against an object is carried into the output:
     * the leading comment of a procedure and of a package, and the comment on the statement
     * behind a call relationship.
     *
     * <p>Off by default, so output that consumers already parse does not grow a field. It is
     * separate from {@link #isTraceSQL()} because a caller can want the author's label without
     * the SQL text and hash that tracing attaches. When tracing is on, relationship comments keep
     * the exact text they have always had; this option adds the blank-line-bounded comment
     * instead, which is the one that belongs to the statement rather than to the section above it.
     */
    public boolean isShowComment() {
        return showComment;
    }

    public void setShowComment(boolean showComment) {
        this.showComment = showComment;
    }

    public void setTraceSQL(boolean traceSQL) {
        this.traceSQL = traceSQL;
    }

    public boolean isIgnoreTopSelect() {
                return ignoreTopSelect;
        }

        public void setIgnoreTopSelect(boolean ignoreTopSelect) {
                this.ignoreTopSelect = ignoreTopSelect;
        }
        
        public void setShowCallRelation(boolean showCallRelation) {
                this.showCallRelation = showCallRelation;
        }
        
        public boolean isShowCallRelation() {
                return showCallRelation;
        }

        public String getFilePathDatabase() {
                return filePathDatabase;
        }

        public void setFilePathDatabase(String filePathDatabase) {
                this.filePathDatabase = filePathDatabase;
        }

        public String getFilePathSchema() {
                return filePathSchema;
        }

        public void setFilePathSchema(String filePathSchema) {
                this.filePathSchema = filePathSchema;
        }

        public String getDefaultServer() {
                return defaultServer;
        }

        public void setDefaultServer(String defaultServer) {
                this.defaultServer = defaultServer;
        }

        public String getDefaultDatabase() {
                return defaultDatabase;
        }

        public void setDefaultDatabase(String defaultDatabase) {
                this.defaultDatabase = defaultDatabase;
        }

        public String getDefaultSchema() {
                return defaultSchema;
        }

        public void setDefaultSchema(String defaultSchema) {
                this.defaultSchema = defaultSchema;
        }

    public boolean isShowERDiagram() {
        return showERDiagram;
    }

    public void setShowERDiagram(boolean showERDiagram) {
        this.showERDiagram = showERDiagram;
    }

    public boolean isIgnoreTemporaryTable() {
        return ignoreTemporaryTable;
    }

    public void setIgnoreTemporaryTable(boolean ignoreTemporaryTable) {
        this.ignoreTemporaryTable = ignoreTemporaryTable;
    }
    
    public void showResultSetTypes(ResultSetType... types) {
        if(types!=null) {
                targetResultSetTypes.addAll(Arrays.asList(types));
        }
    }
    
        public void showResultSetTypes(String... types) {
                if (types != null) {
                        for (String type : types) {
                                ResultSetType resultSetType = ResultSetType.of(type);
                                if (resultSetType != null) {
                                        targetResultSetTypes.add(resultSetType);
                                }
                        }
                }
        }
    
    public boolean containsResultSetType(ResultSetType type) {
        return targetResultSetTypes.contains(type);
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
        public void filterRelationTypes(String... types) {
                if (types != null) {
                        for (String type : types) {
                                RelationshipType relationshipType = RelationshipType.of(type);
                                if (relationshipType != null) {
                                        filterRelationTypes.add(relationshipType.name());
                                }
                        }
                }
        }

        public Set<String> getFilterRelationTypes() {
                return filterRelationTypes;
        }

    public boolean isSimpleShowCursor() {
        return simpleShowCursor;
    }

    public void setSimpleShowCursor(boolean simpleShowCursor) {
        this.simpleShowCursor = simpleShowCursor;
    }

    public boolean isSimpleShowVariable() {
        return simpleShowVariable;
    }

    public void setSimpleShowVariable(boolean simpleShowVariable) {
        this.simpleShowVariable = simpleShowVariable;
    }

    public boolean isSimpleRetainIntermediate() {
        return simpleRetainIntermediate;
    }

    public void setSimpleRetainIntermediate(boolean simpleRetainIntermediate) {
        this.simpleRetainIntermediate = simpleRetainIntermediate;
    }

    public boolean isSimpleShowUdfFunctionOnly() {
        return simpleShowUdfFunctionOnly;
    }

    public void setSimpleShowUdfFunctionOnly(boolean simpleShowUdfFunctionOnly) {
        this.simpleShowUdfFunctionOnly = simpleShowUdfFunctionOnly;
    }

        public boolean isTraceProcedure() {
                return traceProcedure;
        }

        public void setTraceProcedure(boolean traceProcedure) {
                this.traceProcedure = traceProcedure;
        }

    public boolean isSqlflowIgnoreFunction() {
        return sqlflowIgnoreFunction;
    }

    public void setSqlflowIgnoreFunction(boolean sqlflowIgnoreFunction) {
        this.sqlflowIgnoreFunction = sqlflowIgnoreFunction;
    }

    public boolean isShowCaseWhenAsDirect() {
        return showCaseWhenAsDirect;
    }

    public void setShowCaseWhenAsDirect(boolean showCaseWhenAsDirect) {
        this.showCaseWhenAsDirect = showCaseWhenAsDirect;
    }

        public boolean isIgnoreUnusedSynonym() {
                return ignoreUnusedSynonym;
        }

        public void setIgnoreUnusedSynonym(boolean ignoreUnusedSynonym) {
                this.ignoreUnusedSynonym = ignoreUnusedSynonym;
        }

        public boolean isShowCandidateTable() {
                return showCandidateTable;
        }

        public void setShowCandidateTable(boolean showCandidateTable) {
                this.showCandidateTable = showCandidateTable;
        }

        public Set<String> getSimpleShowRelationTypes() {
                return simpleShowRelationTypes;
        }

        public void setSimpleShowRelationTypes(String... types) {
                if (types != null) {
                        for (String type : types) {
                                RelationshipType relationshipType = RelationshipType.of(type);
                                if (relationshipType != null) {
                                        simpleShowRelationTypes.add(relationshipType.name());
                                }
                        }
                }
        }
        
        public void setSimpleShowRelationTypes(RelationshipType... types) {
                if (types != null) {
                        for (RelationshipType relationshipType : types) {
                                simpleShowRelationTypes.add(relationshipType.name());
                        }
                }
        }

        public AnalyzeMode getAnalyzeMode() {
                return analyzeMode;
        }

        public void setAnalyzeMode(AnalyzeMode analyzeMode) {
                this.analyzeMode = analyzeMode;
        }

        public boolean isIgnoreInsertIntoValues() {
                return ignoreInsertIntoValues;
        }

        public void setIgnoreInsertIntoValues(boolean ignoreInsertIntoValues) {
                this.ignoreInsertIntoValues = ignoreInsertIntoValues;
        }

    public boolean isNormalizeOutput() {
        return normalizeOutput;
    }

    public void setNormalizeOutput(boolean normalizeOutput) {
        this.normalizeOutput = normalizeOutput;
    }

        public boolean isTraceTablePosition() {
                return traceTablePosition;
        }

        public void setTraceTablePosition(boolean traceTablePosition) {
                this.traceTablePosition = traceTablePosition;
        }

        public boolean isEnablePipelinedStitching() {
                return enablePipelinedStitching;
        }

        public boolean isIdentityFirstVariablePools() {
                return identityFirstVariablePools;
        }

        public void setIdentityFirstVariablePools(boolean identityFirstVariablePools) {
                this.identityFirstVariablePools = identityFirstVariablePools;
        }

        public void setEnablePipelinedStitching(boolean enablePipelinedStitching) {
                this.enablePipelinedStitching = enablePipelinedStitching;
        }

        public int getMaxPipelinedExpansionDepth() {
                return maxPipelinedExpansionDepth;
        }

        public void setMaxPipelinedExpansionDepth(int maxPipelinedExpansionDepth) {
                this.maxPipelinedExpansionDepth = maxPipelinedExpansionDepth;
        }

        public int getMaxStitchedSourcesPerColumn() {
        return maxStitchedSourcesPerColumn;
    }

    public void setMaxStitchedSourcesPerColumn(int maxStitchedSourcesPerColumn) {
        this.maxStitchedSourcesPerColumn = maxStitchedSourcesPerColumn;
    }

    public Set<String> getExcludedProcedureNames() {
        return excludedProcedureNames;
    }

    public void setExcludedProcedureNames(Set<String> excludedProcedureNames) {
        this.excludedProcedureNames = excludedProcedureNames;
    }

    public void addExcludedProcedureName(String name) {
        if (name != null && !name.isEmpty()) {
            this.excludedProcedureNames.add(name);
        }
    }

    public void addExcludedProcedureNames(String... names) {
        if (names != null) {
            for (String name : names) {
                addExcludedProcedureName(name);
            }
        }
    }

    /**
     * @see #excludedProcedurePatterns
     */
    public Set<String> getExcludedProcedurePatterns() {
        return excludedProcedurePatterns;
    }

    /**
     * @see #excludedProcedurePatterns
     */
    public void setExcludedProcedurePatterns(Set<String> excludedProcedurePatterns) {
        this.excludedProcedurePatterns = excludedProcedurePatterns;
    }

    /**
     * Adds a wildcard pattern to exclude procedures from analysis.
     * @param pattern A wildcard pattern (e.g., "SCHEMA1.*", "*.SP_*", "*_TEST")
     * @see #excludedProcedurePatterns
     */
    public void addExcludedProcedurePattern(String pattern) {
        if (pattern != null && !pattern.isEmpty()) {
            this.excludedProcedurePatterns.add(pattern);
        }
    }

    /**
     * Adds multiple wildcard patterns to exclude procedures from analysis.
     * @param patterns Variable number of wildcard patterns
     * @see #excludedProcedurePatterns
     */
    public void addExcludedProcedurePatterns(String... patterns) {
        if (patterns != null) {
            for (String pattern : patterns) {
                addExcludedProcedurePattern(pattern);
            }
        }
    }

    /**
     * Whether to automatically detect large files and delegate to
     * {@link gudusoft.gsqlparser.dlineage.ParallelDataFlowAnalyzer} for parallel
     * processing. When enabled, the {@link gudusoft.gsqlparser.dlineage.util.LargeFileDetector}
     * checks the input scale against the configured thresholds and may split large
     * files or route sharded manifests to the parallel analyzer. Default {@code false}.
     */
    private boolean autoDetectLargeFile = false;

    public boolean isAutoDetectLargeFile() {
        return autoDetectLargeFile;
    }

    public void setAutoDetectLargeFile(boolean autoDetectLargeFile) {
        this.autoDetectLargeFile = autoDetectLargeFile;
    }

    /**
     * Threshold for the number of {@link SqlInfo} entries that triggers large-file
     * delegation. When the total SqlInfo count reaches this value, the analyzer
     * delegates to parallel processing. Default {@code 1000}.
     */
    private int largeSqlInfoCountThreshold = 1000;

    public int getLargeSqlInfoCountThreshold() {
        return largeSqlInfoCountThreshold;
    }

    public void setLargeSqlInfoCountThreshold(int largeSqlInfoCountThreshold) {
        this.largeSqlInfoCountThreshold = largeSqlInfoCountThreshold;
    }

    /**
     * Threshold for the total SQL content size (in bytes) that triggers large-file
     * delegation. When the sum of all SQL string lengths reaches this value, the
     * analyzer delegates to parallel processing. Default {@code 25 * 1024 * 1024} (25 MB).
     */
    private long largeSqlTotalSizeThreshold = 25 * 1024 * 1024L;

    public long getLargeSqlTotalSizeThreshold() {
        return largeSqlTotalSizeThreshold;
    }

    public void setLargeSqlTotalSizeThreshold(long largeSqlTotalSizeThreshold) {
        this.largeSqlTotalSizeThreshold = largeSqlTotalSizeThreshold;
    }

    /**
     * Threshold for the number of queries in a sqlflow/grabit manifest that triggers
     * large-file delegation. When the manifest contains this many queries, the analyzer
     * delegates to parallel processing. Default {@code 1000}.
     */
    private int largeQueryCountThreshold = 1000;

    public int getLargeQueryCountThreshold() {
        return largeQueryCountThreshold;
    }

    public void setLargeQueryCountThreshold(int largeQueryCountThreshold) {
        this.largeQueryCountThreshold = largeQueryCountThreshold;
    }

    /**
     * Threshold for the number of shards in a sqlflow-sharded manifest that triggers
     * large-file delegation. When the manifest references this many shard source files,
     * the analyzer delegates to parallel processing. Default {@code 10}.
     */
    private int largeShardCountThreshold = 10;

    public int getLargeShardCountThreshold() {
        return largeShardCountThreshold;
    }

    public void setLargeShardCountThreshold(int largeShardCountThreshold) {
        this.largeShardCountThreshold = largeShardCountThreshold;
    }

    /**
     * Maximum size in MB for a single file before it is split into smaller chunks
     * for parallel processing. Files larger than this threshold are split using
     * {@link gudusoft.gsqlparser.util.FileSplitter}. Default {@code 5} (5 MB).
     */
    private int largeFileSplitSizeMB = 5;

    public int getLargeFileSplitSizeMB() {
        return largeFileSplitSizeMB;
    }

    public void setLargeFileSplitSizeMB(int largeFileSplitSizeMB) {
        this.largeFileSplitSizeMB = largeFileSplitSizeMB;
    }

    /**
     * Multiplier applied to {@link #largeFileSplitSizeMB} to calculate the
     * byte threshold in {@link #isLargeSql(String)}. Default {@code 1.5}.
     */
    private double largeSqlThresholdMultiplier = 1.5;

    public double getLargeSqlThresholdMultiplier() {
        return largeSqlThresholdMultiplier;
    }

    public void setLargeSqlThresholdMultiplier(double largeSqlThresholdMultiplier) {
        this.largeSqlThresholdMultiplier = largeSqlThresholdMultiplier;
    }

    public boolean isLargeSql(String sql) {
        if (!autoDetectLargeFile || sql == null) {
            return false;
        }
        return sql.length() > getLargeSqlThresholdBytes();
    }

    public long getLargeSqlThresholdBytes() {
        return (long) (largeFileSplitSizeMB * largeSqlThresholdMultiplier * 1024 * 1024);
    }

    /**
     * Estimated memory consumption per parallel task in MB, used to calculate the
     * thread pool size in {@code ParallelDataFlowAnalyzer}. The pool size is capped
     * so that {@code poolSize * estimatedMemoryPerTaskMB} does not exceed the JVM's
     * available memory. Default {@code 2560} (2.5 GB).
     */
    private long estimatedMemoryPerTaskMB = 2560L;

    public long getEstimatedMemoryPerTaskMB() {
        return estimatedMemoryPerTaskMB;
    }

    public void setEstimatedMemoryPerTaskMB(long estimatedMemoryPerTaskMB) {
        this.estimatedMemoryPerTaskMB = estimatedMemoryPerTaskMB;
    }

}