package gudusoft.gsqlparser.nodes;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.nodes.teradata.TDataDefinition;

import java.util.ArrayList;


/**
 * Define the characteristics of the column.
 *
 */
public class TColumnDefinition extends TParseTreeNode implements Cloneable {

    private TColumnGeneratedClause columnGeneratedClause;

    public void setColumnGeneratedClause(TColumnGeneratedClause columnGeneratedClause) {
        this.columnGeneratedClause = columnGeneratedClause;
    }

    public TColumnGeneratedClause getColumnGeneratedClause() {
        return columnGeneratedClause;
    }

    public TColumnDefinition clone(){
        TColumnDefinition columnDefinitionClone = new TColumnDefinition();
        if (this.columnName != null){
            columnDefinitionClone.columnName = this.columnName.clone();
        }
        if (this.getDatatype() != null){
            columnDefinitionClone.datatype = this.datatype.clone();
        }

        return columnDefinitionClone;
    }
    private ArrayList<TDataDefinition> dataDefinitions;

    public void setDataDefinitions(ArrayList<TDataDefinition> dataDefinitions) {
        this.dataDefinitions = dataDefinitions;
    }

    public ArrayList<TDataDefinition> getDataDefinitions() {
        return dataDefinitions;
    }

    public void setAsJson(boolean asJson) {
        this.asJson = asJson;
    }

    public boolean isAsJson() {
        return asJson;
    }

    private boolean asJson = false;
    private String columnPath; // sql server openjson column_path

    public void setColumnPath(TSourceToken columnPath) {
        this.columnPath = columnPath.toString();
    }

    public String getColumnPath() {
        return columnPath;
    }

    private TIdentityClause identityClause;

    public void setIdentityClause(TIdentityClause identityClause) {
        this.identityClause = identityClause;
    }

    public TIdentityClause getIdentityClause() {
        return identityClause;
    }

    private TSourceToken xmlTableColumnPath;

    public void setXmlTableColumnPath(TSourceToken xmlTableColumnPath) {
        this.xmlTableColumnPath = xmlTableColumnPath;
    }

    /**
     * Oracle, path of xml table column
     * @return Oracle, path of xml table column
     */
    public TSourceToken getXmlTableColumnPath() {

        return xmlTableColumnPath;
    }

    private  TColumnAttributes columnAttributes;

    public TColumnAttributes getColumnAttributes() {
        return columnAttributes;
    }

    public void setColumnAttributes(TColumnAttributes pcolumnAttributes) {

        columnAttributes = pcolumnAttributes;
//        if (columnAttributes != null){
//            if (columnAttributes.getDefaultValue() != null){
//                defaultExpression = columnAttributes.getDefaultValue();
//            }
//            if (columnAttributes.getIdentitySeed() != null){
//                this.seed = columnAttributes.getIdentitySeed();
//            }
//            if (columnAttributes.getIdentityStep() != null){
//                this.increment = columnAttributes.getIdentityStep();
//            }
//            if (columnAttributes.getEncoding() != null){
//                this.encoding = columnAttributes.getEncoding();
//            }
//        }
    }

    private TObjectName comment;

    public TObjectName getComment() {
        return comment;
    }

    public void setComment(TObjectName comment) {

        this.comment = comment;
    }

    public void setCommentByCreateTableOption(TCreateTableOption comment) {
       if (comment == null) return;
       this.comment = comment.getComment();
    }


    private TObjectName columnName;

    private TObjectNameList columnReferences = null;

    private TObjectNameList getColumnReferences() {
        if (columnReferences == null){
            columnReferences = new TObjectNameList();
        }

        return columnReferences;
    }

    public TColumnDefinition(){
        
    }

    public TColumnDefinition(TObjectName columnName){
        this.columnName = columnName;
    }

    public void init(Object arg1)
    {
        this.columnName = (TObjectName)arg1;
        this.columnName.setObjectType(TObjectName.ttobjColumn);
    }

    public void init(Object arg1,Object arg2)
    {
        this.columnName = (TObjectName)arg1;
        if (this.columnName != null) {
            this.columnName.setObjectType(TObjectName.ttobjColumn);
        }
        if (arg2 != null){
            datatype = (TTypeName )arg2;
        }
    }

    public void init(Object arg1,Object arg2,Object arg3)
    {
        this.columnName = (TObjectName)arg1;
        if (this.columnName != null) {
            this.columnName.setObjectType(TObjectName.ttobjColumn);
        }
        if (arg2 != null){
            datatype = (TTypeName )arg2;
        }
        this.constraints = (TConstraintList)arg3;
    }

    /**
     *
     * @return the name of a column of the table.
     */
    public TObjectName getColumnName() {
        return columnName;
    }

    public void setColumnName(TObjectName columnName) {
        this.columnName = columnName;
    }

    public void setColumnReferences(TObjectNameList columnReferences) {
        this.columnReferences = columnReferences;
    }

    public void setDatatype(TTypeName datatype) {
        this.datatype = datatype;
    }

    public void setConstraints(TConstraintList constraints) {
        this.constraints = constraints;
    }

    public void setRowGuidCol(boolean isRowGuidCol) {
        this.isRowGuidCol = isRowGuidCol;
    }

    public void setSeed(TExpression seed) {
        this.seed = seed;
    }

    public void setIncrement(TExpression increment) {
        this.increment = increment;
    }

    public void setIdentity(boolean isIdentity) {
        this.isIdentity = isIdentity;
    }

    /**
     * When create table by using a subquery, then you can omit column and datatype unless you are creating an index-organized table.
     * <p>If you specify AS subquery when creating an index-organized table, then you must specify column, and you must omit datatype.
     * <p>So datetype can be null.

     * @return the datatype of a column.
     */

    public TTypeName getDatatype() {
        return datatype;
    }

    private TTypeName datatype = null;

    private TConstraintList constraints = null;

    public void addNewConstraint(TConstraint pConstraint){
        if (constraints == null){
            constraints = new TConstraintList();
        }
        constraints.addConstraint(pConstraint);
    }
    /**
     *
     * @return constraint list of this column if any.
     */
    public TConstraintList getConstraints() {
        return constraints;
    }

    private TExpression defaultExpression = null;

    public void setDefaultExpression(TExpression defaultExpression) {
        this.defaultExpression = defaultExpression;
    }

    /**
     * The DEFAULT clause lets you specify a value to be assigned to the column if a
     * subsequent INSERT statement omits a value for the column.
     * 
     * @return   The DEFAULT expression can include any SQL function as long as the function does
     * not return a literal argument, a column reference, or a nested function invocation.
     */
    
    public TExpression getDefaultExpression() {
        return defaultExpression;
    }

    private boolean isNull = false;

    public void setNull(boolean aNull) {
        isNull = aNull;
    }

    public boolean isNull() {

        return isNull;
    }

    /**
     *
     * @return SQL Server ROWGUIDCOL
     */
    public boolean isRowGuidCol() {
        return isRowGuidCol;
    }

    private boolean isRowGuidCol = false;

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

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

        if (this.getColumnName() != null){
            this.getColumnName().acceptChildren(v);
        }
        if (this.getDatatype() != null){
            this.getDatatype().acceptChildren(v);
        }
        if (this.getIdentityClause() != null){
            this.getIdentityClause().acceptChildren(v);
        }
        if (constraints != null){
            for (int i=0;i<constraints.size();i++){
                constraints.getConstraint(i).acceptChildren(v);
            }
        }
        v.postVisit(this);
    }

    private  String encoding = null;

    public void setEncoding(String encoding) {
        this.encoding = encoding;
    }

    public String getEncoding() {

        return encoding;
    }

    private String collationName = null;

    public void setCollationName(String collationName) {
        this.collationName = collationName;
    }

    public String getCollationName() {

        if (collationName == null){
            if ((this.getDatatype() != null) && (this.getDatatype().getCollationName() != null)){
                collationName = this.getDatatype().getCollationName();
            }
        }
        return collationName;
    }

    private TExpression seed;

    public TExpression getIncrement() {
        return increment;
    }

    public TExpression getSeed() {
        return seed;
    }

    private TExpression increment;

    private boolean isIdentity = false;

    /**
     *
     * @return is identity column of sql server.
     */
    public boolean isIdentity() {
        return isIdentity;
    }

    private TExpression computedColumnExpression = null;

    public void setComputedColumnExpression(TExpression computedColumnExpression) {
        this.computedColumnExpression = computedColumnExpression;
    }

    /**
     *
     * @return computed_column_expression of sql server.
     */
    public TExpression getComputedColumnExpression() {

        return computedColumnExpression;
    }

    public void doParse(TCustomSqlStatement psql, ESqlClause plocation){

        // teradata data definition
        if (dataDefinitions != null){
            for(int i=0;i<dataDefinitions.size();i++){
                TDataDefinition dataDefinition = dataDefinitions.get(i);
                switch (dataDefinition.getDataDefinitionType()){
                    case columnConstraint:
                        this.addNewConstraint(dataDefinition.getColumnConstraint());
                        break;
                    case dataAttribute:
                        break;
                    case columnStorage:
                        break;
                }
            }
        }

        // get fake constraint from constraints, and then remove that from constraints.
        if (this.constraints == null) {return;}
        for(int i = this.constraints.size() - 1; i>=0; i--){
            this.constraints.getConstraint(i).setConstraintLevel(TBaseType.constraint_level_column);
            switch (this.constraints.getConstraint(i).getConstraint_type()){
                case fake_collate:
                    this.collationName = this.constraints.getConstraint(i).getEndToken().toString();
                    this.constraints.removeElementWithoutSyncTokens(i);
                    break;
                case fake_null:
                    this.setNull(true);
                    this.constraints.removeElementWithoutSyncTokens(i);
                    break;
                case fake_rowguidcol:
                    this.isRowGuidCol = true;
                    this.constraints.removeElementWithoutSyncTokens(i);
                    break;
                case fake_identity:
                    this.isIdentity = true;
                    this.seed = this.constraints.getConstraint(i).getSeed();
                    this.increment = this.constraints.getConstraint(i).getIncrement();
                    this.constraints.removeElementWithoutSyncTokens(i);
                    break;
                case fake_comment:
                    this.comment = this.constraints.getConstraint(i).getCommentObject();
                    this.constraints.removeElementWithoutSyncTokens(i);
                    break;
                case fake_maked_with:
                    this.constraints.removeElementWithoutSyncTokens(i);
                    break;
                case fake_fuzzy_search_index:
                    this.constraints.removeElementWithoutSyncTokens(i);
                    break;
                case fake_load_unit:
                    this.constraints.removeElementWithoutSyncTokens(i);
                    break;
                case fake_column_generated_as_expr:
                    this.columnGeneratedClause = this.constraints.getConstraint(i).getColumnGeneratedClause();
                    this.constraints.removeElementWithoutSyncTokens(i);
                    break;
                case fake_column_generated_as_identity:
                    this.columnGeneratedClause = this.constraints.getConstraint(i).getColumnGeneratedClause();
                    this.constraints.removeElementWithoutSyncTokens(i);
                    break;
                case fake_db2:
                    this.defaultExpression = this.constraints.getConstraint(i).getDefaultExpression();
                    this.constraints.removeElementWithoutSyncTokens(i);
                    break;
                case fake_default_expr:
                    this.defaultExpression = this.constraints.getConstraint(i).getDefaultExpression();
                    this.constraints.removeElementWithoutSyncTokens(i);
                    break;
                case fake_compress_off:
                    this.constraints.removeElementWithoutSyncTokens(i);
                    break;
                default:
                    break;
            }
        }



        for (int i=0;i<constraints.size();i++){
            constraints.getConstraint(i).doParse(psql,plocation);
        }

    }

    private boolean isNestedTableColumn = false; // Oracle json_table, nested table column
    private String nestedTableColumnPath = null; // Oracle json_table, nested table column path
    private TColumnDefinitionList nestedTableColumns = null; // Oracle json_table, nested table columns

    public void setNestedTableColumn(boolean isNestedTableColumn) {
        this.isNestedTableColumn = isNestedTableColumn;
    }

    public void setColumnPath(String columnPath) {
        this.columnPath = columnPath;
    }

    public void setNestedTableColumnPath(TConstant nestedTableColumnPath) {
        this.nestedTableColumnPath = nestedTableColumnPath.toString();
    }

    public void setNestedTableColumns(TColumnDefinitionList nestedTableColumns) {
        this.nestedTableColumns = nestedTableColumns;
    }

    public boolean isNestedTableColumn() {
        return isNestedTableColumn;
    }

    public String getNestedTableColumnPath() {
        return nestedTableColumnPath;
    }

    public TColumnDefinitionList getNestedTableColumns() {
        return nestedTableColumns;
    }
}