package gudusoft.gsqlparser.nodes;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.stmt.TCreateTableSqlStatement;
import gudusoft.gsqlparser.stmt.snowflake.TSnowflakeCopyIntoStmt;
import gudusoft.gsqlparser.stmt.snowflake.TAlterStageStmt;
import gudusoft.gsqlparser.stmt.snowflake.TCreateStageStmt;

public class TCreateTableOption extends TParseTreeNode {

    private TDistributeBy distributeBy;

    public TDistributeBy getDistributeBy() {
        return distributeBy;
    }

    private TBaseTablePartition partitionSpec;

    public TBaseTablePartition getPartitionSpec() {
        return partitionSpec;
    }

    public TObjectName getComment() {
        return comment;
    }

    private TObjectName comment;

    /*
     * BigQuery external_table_option_list
     *
     * @see https://cloud.google.com/bigquery/docs/reference/standard-sql/data-
     * definition-language#external_table_option_list
     */
    private Boolean allowJaggedRows;
    private Boolean allowQuotedNewlines;
    private String compression;
    private String description;
    private Boolean enableLogicalTypes;
    private String encoding;
    private String expirationTimestamp;
    private String fieldDelimiter;
    private String format;
    private List<String> decimalTargetTypes;
    private String hivePartitionUriPrefix;
    private Boolean ignoreUnknownValues;
    private Long maxBadRecords;
    private String nullMarker;
    private String projectionFields;
    private String quote;
    private Boolean requireHivePartitionFilter;
    private String sheetRange;
    private Long skipLeadingRows;
    private List<String> uris;

    private  TObjectNameList columnNamelist;

    public TObjectNameList getColumnNamelist() {
        return columnNamelist;
    }

    private String awsSnsTopic = null;
    private TObjectNameList partitionColumnList;
    private TExpression partitionByExpr;

    /**
     * Bigquery partition by expr
     * @return expr
     */
    public TExpression getPartitionByExpr() {
        return partitionByExpr;
    }

    private String fileFormatName = null;
    private String fileFormatType = null;
    private ArrayList<TNameValuePair> fileFormatProperties = null;

    public void setFileFormatName(TSourceToken fileFormatName) {
        this.fileFormatName = fileFormatName.toString();
    }
    public void setFileFormatName(TObjectName fileFormatName) {
        this.fileFormatName = fileFormatName.toString();
    }

    public void setFileFormatType(TSourceToken fileFormatType) {
        this.fileFormatType = fileFormatType.toString();
    }

    public String getFileFormatName() {
        return fileFormatName;
    }

    public String getFileFormatType() {
        return fileFormatType;
    }

    /**
     * Get file format properties list (e.g., TYPE=CSV, FIELD_DELIMITER='|', SKIP_HEADER=1)
     * Used in Snowflake external table file_format option
     * @return list of name-value pairs representing file format properties
     */
    public ArrayList<TNameValuePair> getFileFormatProperties() {
        return fileFormatProperties;
    }

    /**
     * Set file format properties list
     * @param fileFormatProperties list of name-value pairs for file format options
     */
    public void setFileFormatProperties(ArrayList<TNameValuePair> fileFormatProperties) {
        this.fileFormatProperties = fileFormatProperties;
    }

    /**
     * Parse file format string and create name-value pair list
     *
     * <p>Parses file format options in formats like:</p>
     * <ul>
     *   <li>Single line: file_format=(TYPE=CSV FIELD_DELIMITER='|' SKIP_HEADER=1)</li>
     *   <li>Multi-line: FILE_FORMAT = (TYPE = CSV, FIELD_DELIMITER = ',', SKIP_HEADER = 1)</li>
     * </ul>
     *
     * @param fileFormatString the file_format string to parse
     * @return ArrayList of TNameValuePair objects representing the properties
     */
    public ArrayList<TNameValuePair> parseFileFormatProperties(String fileFormatString) {
        if (fileFormatString == null || fileFormatString.trim().isEmpty()) {
            return null;
        }

        ArrayList<TNameValuePair> properties = new ArrayList<TNameValuePair>();

        // Normalize the input: remove line breaks and extra spaces
        String normalized = fileFormatString.replaceAll("\\s+", " ").trim();

        // Extract content within parentheses
        // Match pattern: file_format=(...)  or FILE_FORMAT = (...)
        Pattern outerPattern = Pattern.compile("(?i)file_format\\s*=\\s*\\((.+)\\)", Pattern.DOTALL);
        Matcher outerMatcher = outerPattern.matcher(normalized);

        String content;
        if (outerMatcher.find()) {
            content = outerMatcher.group(1).trim();
        } else {
            // Try to match just the content in parentheses (...)
            Pattern parenthesesPattern = Pattern.compile("\\((.+)\\)", Pattern.DOTALL);
            Matcher parenthesesMatcher = parenthesesPattern.matcher(normalized);
            if (parenthesesMatcher.find()) {
                content = parenthesesMatcher.group(1).trim();
            } else {
                // No parentheses found, assume the whole string is the content
                content = normalized;
            }
        }

        // Split by comma or space, but respect quoted strings and parentheses
        ArrayList<String> pairs;
        if (hasUnquotedComma(content)) {
            // Comma-separated format
            pairs = splitByComma(content);
        } else {
            // Space-separated format
            pairs = splitBySpace(content);
        }

        // Parse each name=value pair
        for (String pair : pairs) {
            pair = pair.trim();
            if (pair.isEmpty()) {
                continue;
            }

            // Split by '=' to get name and value
            int equalsIndex = findEqualsIndex(pair);
            if (equalsIndex > 0) {
                String name = pair.substring(0, equalsIndex).trim();
                String value = pair.substring(equalsIndex + 1).trim();

                TNameValuePair nvPair = new TNameValuePair();
                nvPair.init(name, value);
                properties.add(nvPair);
            }
        }

        // Store in the field and return
        this.fileFormatProperties = properties;
        return properties;
    }

    /**
     * Check if the content has any unquoted comma
     * Helper method for parseFileFormatProperties
     */
    private boolean hasUnquotedComma(String content) {
        boolean inSingleQuote = false;
        boolean inDoubleQuote = false;

        for (int i = 0; i < content.length(); i++) {
            char ch = content.charAt(i);

            if (ch == '\'' && !inDoubleQuote) {
                inSingleQuote = !inSingleQuote;
            } else if (ch == '"' && !inSingleQuote) {
                inDoubleQuote = !inDoubleQuote;
            } else if (ch == ',' && !inSingleQuote && !inDoubleQuote) {
                return true; // Found an unquoted comma
            }
        }

        return false;
    }

    /**
     * Split string by comma, but respect quoted strings and parentheses
     * Helper method for parseFileFormatProperties
     */
    private ArrayList<String> splitByComma(String content) {
        ArrayList<String> parts = new ArrayList<String>();
        StringBuilder current = new StringBuilder();
        boolean inSingleQuote = false;
        boolean inDoubleQuote = false;
        int parenthesesDepth = 0;

        for (int i = 0; i < content.length(); i++) {
            char ch = content.charAt(i);

            if (ch == '\'' && !inDoubleQuote) {
                inSingleQuote = !inSingleQuote;
                current.append(ch);
            } else if (ch == '"' && !inSingleQuote) {
                inDoubleQuote = !inDoubleQuote;
                current.append(ch);
            } else if (ch == '(' && !inSingleQuote && !inDoubleQuote) {
                parenthesesDepth++;
                current.append(ch);
            } else if (ch == ')' && !inSingleQuote && !inDoubleQuote) {
                parenthesesDepth--;
                current.append(ch);
            } else if (ch == ',' && !inSingleQuote && !inDoubleQuote && parenthesesDepth == 0) {
                // Found a separator comma
                parts.add(current.toString());
                current.setLength(0); // Clear StringBuilder
            } else {
                current.append(ch);
            }
        }

        // Add the last part
        if (current.length() > 0) {
            parts.add(current.toString());
        }

        return parts;
    }

    /**
     * Split string by space, but respect quoted strings
     * Helper method for parseFileFormatProperties (for space-separated format)
     */
    private ArrayList<String> splitBySpace(String content) {
        ArrayList<String> parts = new ArrayList<String>();
        StringBuilder current = new StringBuilder();
        boolean inSingleQuote = false;
        boolean inDoubleQuote = false;
        boolean inValue = false; // Track if we're currently building a value after '='

        for (int i = 0; i < content.length(); i++) {
            char ch = content.charAt(i);

            if (ch == '\'' && !inDoubleQuote) {
                inSingleQuote = !inSingleQuote;
                current.append(ch);
            } else if (ch == '"' && !inSingleQuote) {
                inDoubleQuote = !inDoubleQuote;
                current.append(ch);
            } else if (ch == '=' && !inSingleQuote && !inDoubleQuote) {
                current.append(ch);
                inValue = true; // After '=', we're in the value part
            } else if (ch == ' ' && !inSingleQuote && !inDoubleQuote && inValue) {
                // Space after a value - end current pair
                parts.add(current.toString());
                current.setLength(0);
                inValue = false;
            } else if (ch == ' ' && !inSingleQuote && !inDoubleQuote && !inValue) {
                // Space before '=' - just skip it
                if (current.length() > 0) {
                    current.append(ch);
                }
            } else {
                current.append(ch);
            }
        }

        // Add the last part
        if (current.length() > 0) {
            parts.add(current.toString());
        }

        return parts;
    }

    /**
     * Find the index of the first '=' that is not inside quotes
     * Helper method for parseFileFormatProperties
     */
    private int findEqualsIndex(String pair) {
        boolean inSingleQuote = false;
        boolean inDoubleQuote = false;

        for (int i = 0; i < pair.length(); i++) {
            char ch = pair.charAt(i);

            if (ch == '\'' && !inDoubleQuote) {
                inSingleQuote = !inSingleQuote;
            } else if (ch == '"' && !inSingleQuote) {
                inDoubleQuote = !inDoubleQuote;
            } else if (ch == '=' && !inSingleQuote && !inDoubleQuote) {
                return i;
            }
        }

        return -1; // No equals sign found
    }

    private TStageLocation stageLocation;

    public void setStageLocation(TStageLocation stageLocation) {
        this.stageLocation = stageLocation;
    }

    public TStageLocation getStageLocation() {
        return stageLocation;
    }



    public String getAwsSnsTopic() {
        return awsSnsTopic;
    }

    public void setAwsSnsTopic(String awsSnsTopic) {
        this.awsSnsTopic = awsSnsTopic;
    }

    public TObjectNameList getPartitionColumnList() {
        return partitionColumnList;
    }

    public void setPartitionColumnList(TObjectNameList partitionColumnList) {
        this.partitionColumnList = partitionColumnList;
    }

    public String getCompression() {
        return compression;
    }

    public void setCompression(String compression) {
        this.compression = compression;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getExpirationTimestamp() {
        return expirationTimestamp;
    }

    public void setExpirationTimestamp(String expirationTimestamp) {
        this.expirationTimestamp = expirationTimestamp;
    }

    public String getFieldDelimiter() {
        return fieldDelimiter;
    }

    public void setFieldDelimiter(String fieldDelimiter) {
        this.fieldDelimiter = fieldDelimiter;
    }

    public String getFormat() {
        return format;
    }

    public void setFormat(String format) {
        this.format = format;
    }

    public List<String> getDecimalTargetTypes() {
        return decimalTargetTypes;
    }

    public void setDecimalTargetTypes(List<String> decimalTargetTypes) {
        this.decimalTargetTypes = decimalTargetTypes;
    }

    public String getHivePartitionUriPrefix() {
        return hivePartitionUriPrefix;
    }

    public void setHivePartitionUriPrefix(String hivePartitionUriPrefix) {
        this.hivePartitionUriPrefix = hivePartitionUriPrefix;
    }

    public Boolean getIgnoreUnknownValues() {
        return ignoreUnknownValues;
    }

    public void setIgnoreUnknownValues(Boolean ignoreUnknownValues) {
        this.ignoreUnknownValues = ignoreUnknownValues;
    }

    public Long getMaxBadRecords() {
        return maxBadRecords;
    }

    public void setMaxBadRecords(Long maxBadRecords) {
        this.maxBadRecords = maxBadRecords;
    }

    public void setRequireHivePartitionFilter(Boolean requireHivePartitionFilter) {
        this.requireHivePartitionFilter = requireHivePartitionFilter;
    }

    public String getNullMarker() {
        return nullMarker;
    }

    public void setNullMarker(String nullMarker) {
        this.nullMarker = nullMarker;
    }

    public String getProjectionFields() {
        return projectionFields;
    }

    public void setProjectionFields(String projectionFields) {
        this.projectionFields = projectionFields;
    }

    public String getQuote() {
        return quote;
    }

    public void setQuote(String quote) {
        this.quote = quote;
    }

    public Boolean getRequireHivePartitionFilter() {
        return requireHivePartitionFilter;
    }

    public String getSheetRange() {
        return sheetRange;
    }

    public void setSheetRange(String sheetRange) {
        this.sheetRange = sheetRange;
    }

    public Long getSkipLeadingRows() {
        return skipLeadingRows;
    }

    public void setSkipLeadingRows(Long skipLeadingRows) {
        this.skipLeadingRows = skipLeadingRows;
    }

    public List<String> getUris() {
        return uris;
    }

    public void setUris(List<String> uris) {
        this.uris = uris;
    }

    public Boolean getAllowJaggedRows() {
        return allowJaggedRows;
    }

    public void setAllowJaggedRows(Boolean allowJaggedRows) {
        this.allowJaggedRows = allowJaggedRows;
    }

    public Boolean getAllowQuotedNewlines() {
        return allowQuotedNewlines;
    }

    public void setAllowQuotedNewlines(Boolean allowQuotedNewlines) {
        this.allowQuotedNewlines = allowQuotedNewlines;
    }

    public Boolean getEnableLogicalTypes() {
        return enableLogicalTypes;
    }

    public void setEnableLogicalTypes(Boolean enableLogicalTypes) {
        this.enableLogicalTypes = enableLogicalTypes;
    }

    public String getEncoding() {
        return encoding;
    }

    public void setEncoding(String encoding) {
        this.encoding = encoding;
    }
    public void setEncoding(TSourceToken encoding) {
                this.encoding = encoding.toString();
    } // added by baffle

    public String getExternalStageURL() {
        return externalStageURL;
    }

    public void setExternalStageURL(String externalStageURL) {
        this.externalStageURL = externalStageURL;
    }

    public void setPartitionByExpr(TExpression partitionByExpr) {
        this.partitionByExpr = partitionByExpr;
    }

    public void setFileFormatName(String fileFormatName) {
        this.fileFormatName = fileFormatName;
    }

    public void setFileFormatType(String fileFormatType) {
        this.fileFormatType = fileFormatType;
    }

    public void setDateRetentionInDays(TSourceToken dateRetentionInDays) {
        this.dateRetentionInDays = dateRetentionInDays;
    }

    public void setCommentToken(TSourceToken commentToken) {
        this.commentToken = commentToken;
    }

    public void setStageFileFormat(TDummy stageFileFormat) {
        this.stageFileFormat = stageFileFormat;
    }

    public void setCopyOptions(TDummy copyOptions) {
        this.copyOptions = copyOptions;
    }

    public void setExpressionList(TExpressionList expressionList) {
        this.expressionList = expressionList;
    }

    private TSourceToken dateRetentionInDays;

    public TSourceToken getDateRetentionInDays() {
        return dateRetentionInDays;
    }

    private TSourceToken commentToken;

    /**
     * @deprecated since v 2.8.1.1, please use {@link #getComment()} instead
     * @return
     */
    public TSourceToken getCommentToken() {
        return commentToken;
    }

    private TDummy stageFileFormat;

    private TDummy copyOptions;

    public TDummy getCopyOptions() {
        return copyOptions;
    }

    protected ECreateTableOption createTableOptionType;

    public void setCreateTableOptionType(ECreateTableOption createTableOptionType) {
        this.createTableOptionType = createTableOptionType;
    }

    public ECreateTableOption getCreateTableOptionType() {
        return createTableOptionType;
    }

    public void  init(Object arg1){
        createTableOptionType = (ECreateTableOption)arg1;
    }

    private TExpressionList expressionList;

    public TExpressionList getExpressionList() {
        return expressionList;
    }

    public TDummy getStageFileFormat() {
        return stageFileFormat;
    }

    private String externalStageURL=null;

    public void init(Object arg1, Object arg2){
        init(arg1);
        switch(createTableOptionType){
            case etoClusterBy:
                this.expressionList = (TExpressionList)arg2;
                break;
            case etoStageCopyOptions:
                this.copyOptions = (TDummy)arg2;
                break;
            case etoStageFileFormat:
                this.stageFileFormat = (TDummy)arg2;
                break;
            case etoComment:
                //this.commentToken = (TSourceToken)arg2;
                this.comment = (TObjectName) arg2;
                break;
            case etoDateRetentionTimeInDays:
                this.dateRetentionInDays = (TSourceToken)arg2;
                break;
            case etoPartitionBy:
                if (arg2 instanceof TObjectNameList){
                    this.partitionColumnList = (TObjectNameList)arg2;
                }else if (arg2 instanceof  TExpression){
                    this.partitionByExpr = (TExpression)arg2;
                }
                break;
            case etoAWSSnsTopic:
                awsSnsTopic = ((TSourceToken)arg2).toString();
                break;
            case etoStageURL:
                externalStageURL = ((TSourceToken)arg2).toString();
                break;
            case etoFiles:
                this.expressionList = (TExpressionList)arg2;
                break;
            case etoDistributeOn:
            case etoOrganizeOn:
                this.columnNamelist =(TObjectNameList)arg2;
                break;
            case etoReloptions:
                this.attributeOptions  = (ArrayList<TAttributeOption>)arg2;
                break;
            case etoPartitionSpec:
                this.partitionSpec = (TBaseTablePartition)arg2;
                break;
            case etoDistributeBy:
                this.distributeBy = (TDistributeBy)arg2;
                break;
            case etoDistributeByHash:
                this.columnNamelist = (TObjectNameList)arg2;
                break;
            case etoPartitioningKey:
                this.columnNamelist = (TObjectNameList)arg2;
                break;
            case etoOrganizeBy:
            case etoOrganizeByDimensions:
                this.valueRowItemList = (TMultiTargetList)arg2;
                break;
        }
    }

    private TMultiTargetList valueRowItemList;

    public TMultiTargetList getValueRowItemList() {
        return valueRowItemList;
    }

    public ArrayList<TAttributeOption> getAttributeOptions() {
        return attributeOptions;
    }

    private ArrayList<TAttributeOption> attributeOptions ;

    private void parseBigQueryTableOption() {
        String options = this.toString().trim();
        if (!options.toUpperCase().startsWith("OPTIONS"))
            return;
        options = options.replaceFirst("(?i)OPTIONS", "").trim();
        options = options.substring(1, options.length() - 1).trim();
        if (!options.endsWith(",")) {
            options = options + ",";
        }

        this.allowJaggedRows = getPatternBoolean(options, "allow_jagged_rows");
        this.allowQuotedNewlines = getPatternBoolean(options, "allow_quoted_newlines");
        this.compression = getPatternString(options, "compression");
        this.description = getPatternString(options, "description");
        this.enableLogicalTypes = getPatternBoolean(options, "enable_logical_types");
        this.encoding = getPatternString(options, "encoding");
        this.expirationTimestamp = getTimestampString(options, "expiration_timestamp");
        this.fieldDelimiter = getPatternString(options, "field_delimiter");
        this.format = getPatternString(options, "format");
        this.decimalTargetTypes = getPatternArray(options, "decimal_target_types");
        this.hivePartitionUriPrefix = getPatternString(options, "hive_partition_uri_prefix");
        this.ignoreUnknownValues = getPatternBoolean(options, "ignore_unknown_values");
        this.maxBadRecords = getPatternLong(options, "max_bad_records");
        this.nullMarker = getPatternString(options, "null_marker");
        this.projectionFields = getPatternString(options, "projection_fields");
        this.quote = getPatternString(options, "quote");
        this.requireHivePartitionFilter = getPatternBoolean(options, "require_hive_partition_filter");
        this.sheetRange = getPatternString(options, "sheet_range");
        this.skipLeadingRows = getPatternLong(options, "skip_leading_rows");
        this.uris = getPatternArray(options, "uris");
    }

    private String getTimestampString(String content, String field) {
        content = content.replaceAll("(\\s*,)+", ",");
        if (content.matches("(?is).*" + field + "\\s*=(.+?)=.+")) {
            String patternExp = "(?is)" + field + "\\s*=(.+?)=";
            Pattern pattern = Pattern.compile(patternExp);
            Matcher matcher = pattern.matcher(content);
            if (matcher.find()) {
                String timestamp = matcher.group(1).trim();
                timestamp = timestamp.substring(0, timestamp.lastIndexOf(",")).trim();
                return timestamp;
            }
        }
        else if(content.matches("(?is).*" + field + "\\s*=(.+),")){
            String patternExp = "(?is)" + field + "\\s*=(.+),";
            Pattern pattern = Pattern.compile(patternExp);
            Matcher matcher = pattern.matcher(content);
            if (matcher.find()) {
                String timestamp = matcher.group(1).trim();
                return timestamp;
            }
        } 
        return null;
    }

    private String getPatternString(String content, String field) {
        String patternExp = "(?is)" + field + "\\s*=\\s*(\".+?\"),";
        Pattern pattern = Pattern.compile(patternExp);
        Matcher matcher = pattern.matcher(content);
        if (matcher.find()) {
            return matcher.group(1).trim();
        }
        patternExp = "(?is)" + field + "\\s*=\\s*('.+?\'),";
        pattern = Pattern.compile(patternExp);
        matcher = pattern.matcher(content);
        if (matcher.find()) {
            return matcher.group(1).trim();
        }
        return null;
    }

    private Boolean getPatternBoolean(String content, String field) {
        String patternExp = "(?is)" + field + "\\s*=(.+?),";
        Pattern pattern = Pattern.compile(patternExp);
        Matcher matcher = pattern.matcher(content);
        if (matcher.find()) {
            return Boolean.parseBoolean(matcher.group(1).trim());
        }
        return null;
    }

    private Long getPatternLong(String content, String field) {
        String patternExp = "(?is)" + field + "\\s*=(.+?),";
        Pattern pattern = Pattern.compile(patternExp);
        Matcher matcher = pattern.matcher(content);
        if (matcher.find()) {
            return Long.parseLong(matcher.group(1).trim());
        }
        return null;
    }

    private List<String> getPatternArray(String content, String field) {
        String patternExp = "(?is)" + field + "\\s*=\\s*\\[(.+?)\\]\\s*,";
        Pattern pattern = Pattern.compile(patternExp);
        Matcher matcher = pattern.matcher(content);
        if (matcher.find()) {
            String arrayItems = matcher.group(1).trim();
            if (arrayItems.startsWith("(") && arrayItems.endsWith(")")) {
                arrayItems = arrayItems.substring(1, arrayItems.length() - 1).trim();
            }
            return Arrays.asList(arrayItems.split("\\s*,\\s*"));
        }
        return null;
    }

    public void doParse(TCustomSqlStatement psql, ESqlClause plocation) {

        if (psql instanceof TCreateTableSqlStatement) {
            TCreateTableSqlStatement c = (TCreateTableSqlStatement) psql;

            switch (this.createTableOptionType){
                case etoPartitionBy:
                    if (this.partitionColumnList != null){
                        c.setPartitionColumnList(this.partitionColumnList);
                    }else if (this.partitionByExpr != null){
                        c.setPartitionByExpr(this.partitionByExpr);
                        this.partitionByExpr.doParse(c,ESqlClause.createTable);
                    }
                    break;
                case etoPattern:
                    c.setRegex_pattern(this.getEndToken().toString());
                    break;
                case etoComment:
                    c.setTableComment(TObjectName.createObjectName (psql.dbvendor, EDbObjectType.comment, this.commentToken));
                    break;
                case etoWithLocation:
                    c.setStageLocation(this.getStageLocation());
                    break;
                case etoFileFormat:
                    c.setFileFormatName(this.fileFormatName);
                    c.setFileFormatType(this.fileFormatType);
                    fileFormatProperties = parseFileFormatProperties(this.toString());
                    break;
                case etoAWSSnsTopic:
                    c.setAwsSnsTopic(this.awsSnsTopic);
                    break;
                case etoBigQueryExternal:
                    parseBigQueryTableOption();
                    break;
                case etoClusterBy:
                    if (expressionList != null){
                        expressionList.doParse(psql,plocation);
                    }
                    break;
                default:
                    break;

            }
        }else if(psql instanceof TCreateStageStmt){
            TCreateStageStmt c = (TCreateStageStmt)psql;
            switch (this.createTableOptionType){
                case etoFileFormat:
                    c.setFileFormatName(this.fileFormatName);
                    c.setFileFormatType(this.fileFormatType);
                    break;
                case etoStageURL:
                    c.setExternalStageURL(this.externalStageURL);
                    break;
                default:
                    break;
            }
        }else if(psql instanceof TAlterStageStmt){
            TAlterStageStmt c = (TAlterStageStmt)psql;
            switch (this.createTableOptionType){
                case etoFileFormat:
                    c.setFileFormatName(this.fileFormatName);
                    c.setFileFormatType(this.fileFormatType);
                    break;
                case etoStageURL:
                    c.setExternalStageURL(this.externalStageURL);
                    break;
                default:
                    break;
            }
        }else if(psql instanceof TSnowflakeCopyIntoStmt){
            TSnowflakeCopyIntoStmt c = (TSnowflakeCopyIntoStmt)psql;
            switch (this.createTableOptionType){
                case etoFileFormat:
                    c.setFileFormatName(this.fileFormatName);
                    c.setFileFormatType(this.fileFormatType);
                    break;
                case etoStageURL:
                    break;
                case etoPattern:
                    c.setRegex_pattern(this.getEndToken().toString());
                    break;
                case etoFiles:
                    for(TExpression e:this.expressionList){
                        c.getFileList().add(e.toString());
                    }
                    break;
                default:
                    break;
            }
        }
    }

    public void accept(TParseTreeVisitor v){
        v.preVisit(this);
        v.postVisit(this);
    }
    public void acceptChildren(TParseTreeVisitor v){
        v.preVisit(this);
        v.postVisit(this);
    }
}