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;

public class Option implements Cloneable {

    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 simpleShowTopSelectResultSet = false;
    private boolean linkOrphanColumnToFirstTable = false;
    private boolean ignoreCoordinate = false;
    private boolean transform = false;
    private boolean transformCoordinate = 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 traceProcedure = false;
    private int parallel = Runtime.getRuntime().availableProcessors() / 2;
    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 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;
    private int maxPipelinedExpansionDepth = 8;
    private int maxStitchedSourcesPerColumn = 64;

    private AnalyzeMode analyzeMode;

    public EDbVendor getVendor() {
        return vendor;
    }

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

    /**
     * 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 UNRESOLVED / PARSE_ERROR dynamic-SQL site is also mirrored into an
     * {@link ErrorInfo} (type {@link ErrorInfo#DYNAMIC_SQL_UNRESOLVED}) so legacy 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;
    }

    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;
    }

    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 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;
    }

    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 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 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);
            }
        }
    }

}