package gudusoft.gsqlparser.nodes;


import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.nodes.flink.TFlinkWithClause;
import gudusoft.gsqlparser.nodes.hive.*;
import gudusoft.gsqlparser.nodes.oracle.TPhysicalProperties;
import gudusoft.gsqlparser.nodes.postgresql.TPartitionBoundSpecSqlNode;
import gudusoft.gsqlparser.nodes.teradata.TIndexDefinition;
import gudusoft.gsqlparser.stmt.TCreateTableSqlStatement;
import gudusoft.gsqlparser.nodes.postgresql.TInheritsClause;

import java.util.ArrayList;
import java.util.EnumSet;

public class TCreateTableSqlNode extends TParseTreeNode {

    private TDistributeBy distributeBy;

    public void setDistributeBy(TDistributeBy distributeBy) {
        this.distributeBy = distributeBy;
    }

    public TDistributeBy getDistributeBy() {
        return distributeBy;
    }

    private TBaseTablePartition tablePartition;

    public void setTablePartition(TBaseTablePartition tablePartition) {
        this.tablePartition = tablePartition;
    }

    public TBaseTablePartition getTablePartition() {
        return tablePartition;
    }

    public void setPartitionBoundSpec(TPartitionBoundSpecSqlNode partitionBoundSpec) {
        this.partitionBoundSpec = partitionBoundSpec;
    }

    public TPartitionBoundSpecSqlNode getPartitionBoundSpec() {
        return partitionBoundSpec;
    }

    /**
     * postgresql PartitionBoundSpec
     * https://www.postgresql.org/docs/current/sql-createtable.html
     */
    private TPartitionBoundSpecSqlNode partitionBoundSpec;

    public TTableProperties getTableProperties() {
        return tableProperties;
    }

    public void setTableProperties(TTableProperties tableProperties) {
        this.tableProperties = tableProperties;
    }

    private TTableProperties tableProperties;

    private ArrayList<TConstant> locationFiles;

    public void setLocationFiles(ArrayList<TConstant> locationFiles) {
        this.locationFiles = locationFiles;
    }

    public ArrayList<TConstant> getLocationFiles() {
        return locationFiles;
    }

    public void setOptionStartParenthesis(TSourceToken optionStartParenthesis) {
        this.optionStartParenthesis = optionStartParenthesis;
    }

    public void setOptionEndParenthesis(TSourceToken optionEndParenthesis) {
        this.optionEndParenthesis = optionEndParenthesis;
    }

    public TSourceToken getOptionStartParenthesis() {
        return optionStartParenthesis;
    }

    public TSourceToken getOptionEndParenthesis() {
        return optionEndParenthesis;
    }

    private TSourceToken optionStartParenthesis;
    private TSourceToken optionEndParenthesis;

    private TCreateTableSqlStatement.TableSourceType tableSourceType = TCreateTableSqlStatement.TableSourceType.normal;

    private TObjectName cloneSourceTable = null;

    private TDummy netezzaExternalTableOption = null;

    public void setCloneSourceTable(TObjectName cloneSourceTable) {
        this.cloneSourceTable = cloneSourceTable;
        this.tableSourceType = TCreateTableSqlStatement.TableSourceType.clone;
    }

    public TObjectName getCloneSourceTable() {
        return cloneSourceTable;
    }

    public void setNetezzaExternalTableOption(TDummy netezzaExternalTableOption) {
        this.netezzaExternalTableOption = netezzaExternalTableOption;
    }

    public TDummy getNetezzaExternalTableOption() {
        return netezzaExternalTableOption;
    }

    public TObjectName getComment(){
        return this.tableComment;
    }
    public void setTableOptions(ArrayList<TCreateTableOption> tableOptions, boolean enableAppend) {
        if (tableOptions == null) return;
        for(TCreateTableOption option:tableOptions){
            if (option.getCreateTableOptionType() == ECreateTableOption.etoComment){
                this.tableComment = option.getComment();
            }
        }

        if ((enableAppend) && (this.tableOptions != null)){
            this.tableOptions.addAll(tableOptions);
        }else{
            this.tableOptions = tableOptions;
        }
    }

    public void setTableOptions(ArrayList<TCreateTableOption> tableOptions) {

        this.setTableOptions(tableOptions,false);
//        if (tableOptions == null) return;
//        for(TCreateTableOption option:tableOptions){
//            if (option.getCreateTableOptionType() == ECreateTableOption.etoComment){
//                this.tableComment = option.getComment();
//            }
//        }
//
//        this.tableOptions = tableOptions;

    }

    public void appendTableOption(TCreateTableOption tableOption) {
        if (tableOption == null) return;
        if (tableOptions == null){
            tableOptions = new ArrayList<>();
        }
        tableOptions.add(tableOption);
    }

    public void addTableOptionByToken(TSourceToken st, ECreateTableOption createTableOption){
        if (st == null) return;

        TCreateTableOption newOption = new TCreateTableOption();
        newOption.init(createTableOption,st);
        switch (createTableOption){
            case etoFileFormat:
                newOption.setFileFormatType(st);
                break;
            case etoEncoding:
                newOption.setEncoding(st);
                break;
        }

        if (tableOptions == null){
            tableOptions = new ArrayList<>();
        }

        tableOptions.add(newOption);
    }
    public ArrayList<TCreateTableOption> getTableOptions() {
        return tableOptions;
    }

    private ArrayList<TCreateTableOption> tableOptions;

    public void setOnFilegroup(TDummy onFilegroup) {
        this.onFilegroup = onFilegroup;
    }

    public TDummy getOnFilegroup() {
        return onFilegroup;
    }

    private TDummy onFilegroup = null;

    private TPhysicalProperties physicalProperties;

    public void setPhysicalProperties(TPhysicalProperties physicalProperties) {
        this.physicalProperties = physicalProperties;
    }

    public void setTableOption(TCreateTableOption option){
        if (option == null) return;
        if (this.tableOptions == null){
            this.tableOptions = new ArrayList<>();
        }
        this.tableOptions.add(option);
    }

    /**
     * Oracle physical properties
     *
     * @return Oracle physical properties
     */
    public TPhysicalProperties getPhysicalProperties() {
        return physicalProperties;
    }

    public void setTableKindByToken(TSourceToken st){
        if (st == null) return;
        if (st.toString().equalsIgnoreCase("set")){
            tableKinds.add(ETableKind.etkSet);
        }else if (st.toString().equalsIgnoreCase("multiset")){
            tableKinds.add(ETableKind.etkMultiset);
        }else if (st.toString().equalsIgnoreCase("volatile")){
            tableKinds.add(ETableKind.etkVolatile);
        }else if (st.toString().equalsIgnoreCase("global")){
            tableKinds.add(ETableKind.etkGlobalTemporary);
        }else if (st.toString().equalsIgnoreCase("temporary")){
            tableKinds.add(ETableKind.etkTemporary);
        }else if (st.toString().equalsIgnoreCase("temp")){
            tableKinds.add(ETableKind.etkTemp);
        }else if (st.toString().equalsIgnoreCase("external")){
            tableKinds.add(ETableKind.etkExternal);
            this.external = true;
        }
    }
    public void setTableKindByNode(TDummy node) {
        if ((TDummy) node.node1 == null) return;
        TDummy node2 = (TDummy) node.node1;
        setTableKindByToken(node2.st1);
        setTableKindByToken(node2.st2);
    }

    private EnumSet<ETableKind> tableKinds = EnumSet.noneOf(ETableKind.class);

    public void setTableKinds(EnumSet<ETableKind> tableKinds) {
        this.tableKinds = tableKinds;
    }

    public EnumSet<ETableKind> getTableKinds() {

        return tableKinds;
    }

    //private TObjectName asTableName;
    private TTable asTable = null;

    public TTable getAsTable() {
        return asTable;
    }

    public void setAsTableName(TObjectName asTableName) {
        asTable = new TTable();
        asTableName.setObjectType(TObjectName.ttobjTable);
        asTable.setTableName(asTableName);
        asTable.setTableType(ETableSource.objectname);
        asTable.setEffectType(ETableEffectType.tetCreateAs);
    }



    public void setExternalTable(boolean externalTable) {
        this.externalTable = externalTable;
    }

    /**
     * @deprecated As of v1.9.7.2 , replace by {@link #isExternal}
     *
     * @return true if it's an external table
     */
    public boolean isExternalTable() {

        return externalTable;
    }

    private boolean externalTable;

    private ArrayList <TIndexDefinition> indexDefinitions;

    public void setIndexDefinitions(ArrayList<TIndexDefinition> indexDefinitions) {
        this.indexDefinitions = indexDefinitions;
    }

    public ArrayList<TIndexDefinition> getIndexDefinitions() {

        return indexDefinitions;
    }

    private boolean readable = false;
    private boolean writable = false;
    private boolean webTable = false;

    public void setWebTable(boolean webTable) {
        this.webTable = webTable;
    }

    public boolean isWebTable() {
        return webTable;
    }

    private TConstant executeCmd;

    public void setExecuteCmd(TConstant executeCmd) {
        this.executeCmd = executeCmd;
    }

    public TConstant getExecuteCmd() {
        return executeCmd;
    }

    public void setReadWritableByToken(TSourceToken st){
        if (st == null) return;
        if (st.toString().equalsIgnoreCase("readable")){
            readable = true;
        }else if (st.toString().equalsIgnoreCase("writable")){
            writable = true;
        }
    }

    public boolean isReadable() {
        return readable;
    }

    public boolean isWritable() {
        return writable;
    }

    private boolean external;
    private boolean ifNotExists;
    private TObjectName tableLocation;
    private TObjectName tableComment;
    private THiveTableProperties hiveTableProperties;
    private THiveTablePartition hiveTablePartition;
    private THiveTableBuckets hiveTableBuckets;
    private THiveTableSkewed hiveTableSkewed;
    private THiveRowFormat hiveRowFormat;
    private THiveTableFileFormat hiveTableFileFormat;
    private TObjectName likeTableName;

    public void setDummyOfTemp(TDummy dummy){
        if (dummy == null) return;
        if (dummy.st1.toString().equalsIgnoreCase("external")){
            this.external = true;
        }
    }

    public void setExternal(boolean external) {
        this.external = external;
    }

    public void setHiveRowFormat(THiveRowFormat hiveRowFormat) {
        this.hiveRowFormat = hiveRowFormat;
    }

    public void setHiveTableBuckets(THiveTableBuckets hiveTableBuckets) {
        this.hiveTableBuckets = hiveTableBuckets;
    }

    public void setHiveTableFileFormat(THiveTableFileFormat hiveTableFileFormat) {
        this.hiveTableFileFormat = hiveTableFileFormat;
    }

    public void setHiveTablePartition(THiveTablePartition hiveTablePartition) {
        this.hiveTablePartition = hiveTablePartition;
    }

    public void setHiveTableProperties(THiveTableProperties hiveTableProperties) {
        this.hiveTableProperties = hiveTableProperties;
    }

    public void setHiveTableSkewed(THiveTableSkewed hiveTableSkewed) {
        this.hiveTableSkewed = hiveTableSkewed;
    }

    public void setIfNotExists(boolean ifNotExists) {
        this.ifNotExists = ifNotExists;
    }

    public void setLikeTableName(TObjectName likeTableName) {
        if ((likeTableName != null)&&(tableSourceType == TCreateTableSqlStatement.TableSourceType.normal)){
           tableSourceType = TCreateTableSqlStatement.TableSourceType.like;
        }
        this.likeTableName = likeTableName;
    }

    public void setTableComment(TObjectName tableComment) {
        this.tableComment = tableComment;
    }

    public void setTableLocation(TObjectName tableLocation) {
        this.tableLocation = tableLocation;
    }

    public boolean isExternal() {

        return external;
    }

    public THiveRowFormat getHiveRowFormat() {
        return hiveRowFormat;
    }

    public THiveTableBuckets getHiveTableBuckets() {
        return hiveTableBuckets;
    }

    public THiveTableFileFormat getHiveTableFileFormat() {
        return hiveTableFileFormat;
    }

    public THiveTablePartition getHiveTablePartition() {
        return hiveTablePartition;
    }

    public THiveTableProperties getHiveTableProperties() {
        return hiveTableProperties;
    }

    public THiveTableSkewed getHiveTableSkewed() {
        return hiveTableSkewed;
    }

    public boolean isIfNotExists() {
        return ifNotExists;
    }

    public TObjectName getLikeTableName() {
        return likeTableName;
    }

    public TObjectName getTableComment() {
        return tableComment;
    }

    public TObjectName getTableLocation() {
        return tableLocation;
    }

    private TObjectName rowTypeName;
    private TObjectName superTableName;

    public void setRowTypeName(TObjectName rowTypeName) {
        this.rowTypeName = rowTypeName;
    }

    public void setSuperTableName(TObjectName superTableName) {
        this.superTableName = superTableName;
    }

    public TObjectName getRowTypeName() {

        return rowTypeName;
    }

    public TObjectName getSuperTableName() {
        return superTableName;
    }


    private TPTNodeList <TMySQLCreateTableOption> mySQLTableOptionList;

    public void setMySQLTableOptionList(TPTNodeList<TMySQLCreateTableOption> mySQLTableOptionList) {
        this.mySQLTableOptionList = mySQLTableOptionList;
    }

    public TPTNodeList<TMySQLCreateTableOption> getMySQLTableOptionList() {

        return mySQLTableOptionList;
    }

    private TTable table = null;

    public void setTableElementList(TTableElementList tableElementList) {
        this.tableElementList = tableElementList;
    }

    private TTableElementList tableElementList = null;

    public TObjectNameList getColumnList() {
        return columnList;
    }

    public TTableElementList getTableElementList() {
        return tableElementList;
    }

    public TTable getTable() {

        return table;
    }

    public void setColumnList(TObjectNameList columnList) {
        this.columnList = columnList;
    }

    public TSelectSqlNode getSubQueryNode() {
        return subQueryNode;
    }

    private TObjectNameList columnList = null;
    private TSelectSqlNode subQueryNode = null;
    private TStatementSqlNode refreshUsingStatementNode = null;
    private boolean usingTemplate = false;

    /**
     * Snowflake custom incremental dynamic-table refresh DML.
     *
     * @return the MERGE or INSERT statement from REFRESH USING, or null
     */
    public TStatementSqlNode getRefreshUsingStatementNode() {
        return refreshUsingStatementNode;
    }

    public void setRefreshUsingStatementNode(
            TStatementSqlNode refreshUsingStatementNode) {
        this.refreshUsingStatementNode = refreshUsingStatementNode;
        if (refreshUsingStatementNode != null) {
            tableSourceType = TCreateTableSqlStatement.TableSourceType.refreshUsing;
        }
    }

    /**
     * Snowflake: CREATE TABLE ... USING TEMPLATE &lt;query&gt;. When true, the
     * subquery (see {@link #getSubQueryNode()}) is a schema-inference template
     * whose result derives the table's column definitions, rather than a
     * CREATE TABLE AS SELECT that also populates the table with data.
     *
     * @return true if the table is created via USING TEMPLATE
     */
    public boolean isUsingTemplate() {
        return usingTemplate;
    }

    public void setUsingTemplate(boolean usingTemplate) {
        this.usingTemplate = usingTemplate;
        if (usingTemplate) {
            // Distinguish a schema-inference template from a CTAS subquery so that
            // downstream consumers (lineage, metadata) do not treat the template
            // query as data that populates the target table. The query object is
            // still exposed via getSubQueryNode() for resolving its own sources.
            this.tableSourceType = TCreateTableSqlStatement.TableSourceType.usingTemplate;
        }
    }

    public void setExecuteSqlNode(TExecuteSqlNode executeSqlNode) {
        this.executeSqlNode = executeSqlNode;
    }

    public TExecuteSqlNode getExecuteSqlNode() {

        return executeSqlNode;
    }

    private TExecuteSqlNode executeSqlNode = null;//greenplum

    public void setSubQueryNode(TSelectSqlNode subQueryNode) {
        if (subQueryNode != null){
            this.subQueryNode = subQueryNode;
            tableSourceType = TCreateTableSqlStatement.TableSourceType.subquery;
        }

    }

    public void init(Object arg1)
    {
        table = new TTable();
        ((TObjectName)arg1).setObjectType(TObjectName.ttobjTable);
        table.setTableName((TObjectName)arg1);
        table.setTableType(ETableSource.objectname);
        table.setEffectType(ETableEffectType.tetCreate);
        table.setGsqlparser(((TObjectName)arg1).getGsqlparser());
        if (table.getTableName().toString().startsWith("##")){
            // SQL Server global temporary table (##tablename)
            this.getTableKinds().add(ETableKind.etkGlobalTemporary);
            table.getTableName().setTableKind(ETableKind.etkGlobalTemporary);
        } else if (table.getTableName().toString().startsWith("#")){
            // SQL Server local temporary table (#tablename)
            this.getTableKinds().add(ETableKind.etkTemporary);
            table.getTableName().setTableKind(ETableKind.etkTemporary);
        }
    }

    public TCreateTableSqlStatement.TableSourceType getTableSourceType() {
        return tableSourceType;
    }

    public void init(Object arg1, Object arg2){
        tableSourceType = (TCreateTableSqlStatement.TableSourceType)arg1;
        init(arg2);
    }

    public void setInheritsClause(TInheritsClause inheritsClause) {
        this.inheritsClause = inheritsClause;
    }

    public TInheritsClause getInheritsClause() {
        return inheritsClause;
    }

    private TInheritsClause inheritsClause;

    /**
     * Flink WITH clause for connector properties
     */
    private TFlinkWithClause flinkWithClause;

    /**
     * Get the Flink WITH clause containing connector properties.
     * @return the Flink WITH clause, or null if not present
     */
    public TFlinkWithClause getFlinkWithClause() {
        return flinkWithClause;
    }

    /**
     * Set the Flink WITH clause.
     * @param flinkWithClause the Flink WITH clause
     */
    public void setFlinkWithClause(TFlinkWithClause flinkWithClause) {
        this.flinkWithClause = flinkWithClause;
    }
}