package gudusoft.gsqlparser.nodes;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.stmt.TCreateTableSqlStatement;

/**
 * Use a constraint to define an integrity constraint, a rule that restricts the values in a database.
 * <p>Oracle Database lets you create six types of constraints and lets you declare them in two ways.
 * <ul>
 * <li>A NOT NULL constraint prohibits a database value from being null.</li>
 * <li>A unique constraint prohibits multiple rows from having the same value in the same column or combination of columns but allows some values to be null.
 * call method {@link #getColumnList()} to result columns of this unique key.
 * </li>
 * <li>A primary key constraint combines a NOT NULL constraint and a unique
 * constraint in a single declaration. It prohibits multiple rows from having the same
 * value in the same column or combination of columns and prohibits values from being null.
 * call method {@link #getColumnList()} to result columns of this primary key.
 * </li>
 * <li>A foreign key constraint requires values in one table to match values in another table.
 * call method {@link #getColumnList()} to result columns of this foreign key.
 * </li>
 * <li>A check constraint requires a value in the database to comply with a specified condition.
 * call method {@link #getCheckCondition()} to return this condition.
 * </li>
 * <li>A REF column by definition references an object in another object type or in a relational table.
 * A REF constraint lets you further describe the relationship between the REF column and the object it references.
 </li>
 * <li>default constraint is valid in sql server.</li>
 * </ul>
 *
 * @see EConstraintType#notnull
 * @see EConstraintType#unique
 * @see EConstraintType#primary_key
 * @see EConstraintType#foreign_key
 * @see EConstraintType#check
 * @see EConstraintType#reference
 * @see EConstraintType#default_value
 */

public class TConstraint extends TParseTreeNode {

    private TColumnGeneratedClause columnGeneratedClause;

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

    public TColumnGeneratedClause getColumnGeneratedClause() {
        return columnGeneratedClause;
    }

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

    public TDummy getOnFilegroup() {
        return onFilegroup;
    }

    private TDummy onFilegroup = null;

    private TDummy withIndexoption = null;

    public void setWithIndexoption(TDummy withIndexoption) {
        this.withIndexoption = withIndexoption;
    }

    public TDummy getWithIndexoption() {
        return withIndexoption;
    }

    private TObjectName indexName;

    /**
     * SQL Server, index name of table index when {@link #getConstraint_type} is {@link EConstraintType#table_index}
     * or index name of column index when {@link #getConstraint_type} is {@link EConstraintType#column_index}
     *
     * @return index name
     */
    public TObjectName getIndexName() {
        return indexName;
    }

    private EConstraintType constraint_type;
    private TObjectName constraintName = null;
    private  TPTNodeList <TKeyAction> keyActions;

    private TObjectName commentObject;

    public void setCommentObject(TObjectName commentObject) {
        this.commentObject = commentObject;
    }

    private TObjectName forObjectName;

    public void setForObjectName(TObjectName forObjectName) {
        this.forObjectName = forObjectName;
    }

    public TObjectName getForObjectName() {
        return forObjectName;
    }

    public TObjectName getCommentObject() {

        return commentObject;
    }

    public void setKeyActions(TPTNodeList<TKeyAction> keyActions) {
        this.keyActions = keyActions;
    }

    public TPTNodeList<TKeyAction> getKeyActions() {

        return keyActions;
    }

    public void setConstraintLevel(int constraintLevel) {
        this.constraintLevel = constraintLevel;
    }

    /**
     *
     * @return is this a columnn level constraint or table level constraint
     * TBaseType.constraint_level_table or TBaseType.constraint_level_column.

     */
    public int getConstraintLevel() {
        return constraintLevel;
    }

    private int constraintLevel = TBaseType.constraint_level_table;

    private TExpression defaultExpression = null;

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

    /**
     *
     * @return default expression of sql server.
     */
    public TExpression getDefaultExpression() {

        return defaultExpression;
    }

    public void setConstraintName(TObjectName constraintName) {
        this.constraintName = constraintName;
    }

    /**
     *
     * @return name for the constraint, it's optional.
     */
    public TObjectName getConstraintName() {

        return constraintName;
    }

    public void setConstraint_type(EConstraintType constraint_type) {
        this.constraint_type = constraint_type;
    }

    /**
     * 
     * @return type of constraints.
     * @see EConstraintType#notnull
     * @see EConstraintType#unique
     * @see EConstraintType#primary_key
     * @see EConstraintType#foreign_key
     * @see EConstraintType#check
     * @see EConstraintType#reference
     * @see EConstraintType#default_value
     */
    public EConstraintType getConstraint_type() {

        return constraint_type;
    }

    public void setClustered(boolean clustered) {
        this.clustered = clustered;
    }

    public void setClusteredToken(TSourceToken clusteredToken)
    {
        if (clusteredToken == null) return;
        if (clusteredToken.toString().equalsIgnoreCase("clustered")){
            clustered = true;
        }else if (clusteredToken.toString().equalsIgnoreCase("nonclustered")){
            nonClustered = true;
        }
    }

    public boolean isClustered() {

        return clustered;
    }

    private boolean clustered = false;
    private boolean nonClustered = false;
    private boolean notEnforced = false;

    public boolean isNonClustered() {
        return nonClustered;
    }

    public void setNonClustered(boolean nonClustered) {

        this.nonClustered = nonClustered;
    }

    /**
     * Flink SQL: Returns true if the constraint has the NOT ENFORCED modifier.
     * <p>Flink SQL only supports NOT ENFORCED mode for PRIMARY KEY constraints,
     * as Flink does not own the data and cannot enforce constraints.</p>
     *
     * @return true if NOT ENFORCED was specified, false otherwise
     */
    public boolean isNotEnforced() {
        return notEnforced;
    }

    /**
     * Sets the NOT ENFORCED modifier for this constraint.
     *
     * @param notEnforced true if NOT ENFORCED is specified
     */
    public void setNotEnforced(boolean notEnforced) {
        this.notEnforced = notEnforced;
    }

    private TPTNodeList<TColumnWithSortOrder> columnList = null;
    private TExpression checkCondition = null;
    private TPTNodeList <TAutomaticProperty>  automaticProperties = null;

    public void setAutomaticProperties(TPTNodeList<TAutomaticProperty> automaticProperties) {
        this.automaticProperties = automaticProperties;
    }

    /**
     *
     * @return    Automatic Initialization and Updating for TIMESTAMP in MySQL
     */
    public TPTNodeList<TAutomaticProperty> getAutomaticProperties() {

        return automaticProperties;
    }

    /**
     * 
     * @return   used in check constraint, requires a value in the database to comply with this specified condition.
     */
    public TExpression getCheckCondition() {
        return checkCondition;
    }

    /**
     *
     * @return column name list used when constraint type is unique, primary key or foreign key.
     */
    public TPTNodeList<TColumnWithSortOrder> getColumnList() {
        return columnList;
    }

    public void setColumnList(TPTNodeList<TColumnWithSortOrder> columnList) {
        this.columnList = columnList;
    }

    private TPTNodeList <TIndexColName> indexCols;

    /**
     * @deprecated since 1.8.7.2, use {@link #getColumnList()} instead.
     * @return
     */
    public TPTNodeList<TIndexColName> getIndexCols() {
        return indexCols;
    }


    public void init(Object arg1){
        if (arg1 instanceof TExpression){
            this.checkCondition = (TExpression)arg1;
        }else if (arg1 instanceof TPTNodeList){
           this.columnList = (TPTNodeList<TColumnWithSortOrder>)arg1;
        }else if (arg1 instanceof TObjectNameList){
            // column in TObjectNameList not changed to TPTNodeList<TColumnWithSortOrder> in .y file
            // so we convert it here
            this.columnList = new TPTNodeList<TColumnWithSortOrder>();
            TObjectNameList onl = (TObjectNameList)arg1;
            for(int i=0;i<onl.size();i++){
                this.columnList.addElement(new TColumnWithSortOrder(onl.getObjectName(i)));
            }
//            indexCols = (TPTNodeList)arg1;
        }
    }

    private TObjectName indexColumnName = null;


    /**
     * Snowflake index table constraint: CREATE TABLE t1 (c1 INT, c2 INT, CONSTRAINT c1_idx INDEX (c1));
     * @return
     */
    public TObjectName getIndexColumnName() {
        return indexColumnName;
    }

    public void init(Object arg1, Object arg2,Object arg3){
        init(arg1,arg2);
        switch (constraint_type){
            case table_index:
                indexColumnName = (TObjectName)arg3;
                indexColumnName.setDbObjectType(EDbObjectType.column);
                break;
            default:
                break;
        }
    }

    public void init(Object arg1, Object arg2){
        constraint_type = (EConstraintType)arg1;
        switch (constraint_type){
            case table_index:
                indexName = (TObjectName)arg2;
                indexName.setDbObjectType(EDbObjectType.index);
                break;
            case cluster:
                break;
            case default_value:
                this.defaultExpression = (TExpression) arg2;
                break;
            default:
                break;
        }
    }

    private TObjectName referencedObject = null;

    // Vertica CORRELATION constraint fields
    private TObjectNameList determinesColumnList = null;
    private TExpression strengthValue = null;

    /**
     * Vertica CORRELATION constraint: columns that are determined by the correlation columns.
     * Syntax: CONSTRAINT name CORRELATION (col1) DETERMINES (col2) STRENGTH 0.95
     * @return the DETERMINES column list
     */
    public TObjectNameList getDeterminesColumnList() {
        return determinesColumnList;
    }

    public void setDeterminesColumnList(TObjectNameList determinesColumnList) {
        this.determinesColumnList = determinesColumnList;
    }

    /**
     * Vertica CORRELATION constraint: the strength value indicating correlation coefficient.
     * @return the STRENGTH value expression
     */
    public TExpression getStrengthValue() {
        return strengthValue;
    }

    public void setStrengthValue(TExpression strengthValue) {
        this.strengthValue = strengthValue;
    }

    public void setReferencedColumnList(TObjectNameList referencedColumnList) {
        this.referencedColumnList = referencedColumnList;
    }

    /**
     * 
     * @return column name list of referenced object in reference clause when constraint type is REF constraint.
     */
    public TObjectNameList getReferencedColumnList() {

        return referencedColumnList;
    }

    private TObjectNameList referencedColumnList = null;


    public void setReferencedObject(TObjectName referencedObject) {
        this.referencedObject = referencedObject;
    }

    /**
     *
     * @return referenced object in reference clause when constraint type is REF constraint.
     */
    public TObjectName getReferencedObject() {

        return referencedObject;
    }

    private TExpression seed;

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

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

    /**
     * Used internal
     * @return
     */
    public TExpression getIncrement() {

        return increment;
    }

    /**
     * Used internal
     * @return
     */
    public TExpression getSeed() {
        return seed;
    }

    private TExpression increment;

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

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

    public void doParse(TCustomSqlStatement psql, ESqlClause plocation){
        switch (getConstraint_type()){
            case primary_key:
            case unique:
                if (getColumnList() != null){
                    for(int i=0;i<getColumnList().size();i++){
                        TColumnWithSortOrder colWithSort = getColumnList().getElement(i);
                        colWithSort.setOwnerConstraint(this);
                        if (psql instanceof TCreateTableSqlStatement){
                            colWithSort.setOwnerTable(psql.tables.getTable(0));
                            // For functional indexes, getColumnName() returns null (use getExpression() instead)
                            if (colWithSort.getColumnName() != null) {
                                psql.tables.getTable(0).getLinkedColumns().addObjectName(colWithSort.getColumnName());
                                colWithSort.getColumnName().setSourceTable(psql.tables.getTable(0));
                            }
                        }
                        psql.getIndexColumns().addElement(colWithSort);
                    }
                }
                break;
            case correlation:
                // Vertica CORRELATION constraint: link both CORRELATION and DETERMINES columns to the table
                if (getColumnList() != null){
                    for(int i=0;i<getColumnList().size();i++){
                        TColumnWithSortOrder colWithSort = getColumnList().getElement(i);
                        colWithSort.setOwnerConstraint(this);
                        if (psql instanceof TCreateTableSqlStatement){
                            colWithSort.setOwnerTable(psql.tables.getTable(0));
                            if (colWithSort.getColumnName() != null) {
                                psql.tables.getTable(0).getLinkedColumns().addObjectName(colWithSort.getColumnName());
                                colWithSort.getColumnName().setSourceTable(psql.tables.getTable(0));
                            }
                        }
                    }
                }
                if (getDeterminesColumnList() != null){
                    for(int i=0;i<getDeterminesColumnList().size();i++){
                        TObjectName colName = getDeterminesColumnList().getObjectName(i);
                        if (psql instanceof TCreateTableSqlStatement){
                            psql.tables.getTable(0).getLinkedColumns().addObjectName(colName);
                            colName.setSourceTable(psql.tables.getTable(0));
                        }
                    }
                }
                break;
            case foreign_key:
            case reference:{
                if (getColumnList() != null){
                    for(int i=0;i<getColumnList().size();i++){
                        TColumnWithSortOrder colWithSort = getColumnList().getElement(i);
                        colWithSort.setOwnerConstraint(this);
                        if (psql instanceof TCreateTableSqlStatement){
                            colWithSort.setOwnerTable(psql.tables.getTable(0));
                        }
                        psql.getIndexColumns().addElement(colWithSort);
                    }
                }

                TTable lcTable = null;
                if (referencedObject != null){
                    referencedObject.setObjectType(TObjectName.ttobjTable);

                    lcTable = new TTable(referencedObject);
                    lcTable.setPropertyFromObjectName(referencedObject,ETableEffectType.tetConstraintReference);
//                    lcTable.setStartToken(referencedObject.getStartToken());
//                    lcTable.setEndToken(referencedObject.getEndToken());
//                    lcTable.setGsqlparser(referencedObject.getGsqlparser());
//                    lcTable.setEffectType(ETableEffectType.tetConstraintReference);
//                    lcTable.setTableType(ETableSource.objectname);
                    psql.addToTables(lcTable);
                }
                if (referencedColumnList!=null){
                    for(int i=0;i<referencedColumnList.size();i++){
                        referencedColumnList.getObjectName(i).setLocation(ESqlClause.constraintRef);
                        lcTable.getLinkedColumns().addObjectName(referencedColumnList.getObjectName(i));
                    }
                }
            };
            break;
            case check:
                if ((checkCondition != null) &&(checkCondition.getBetweenOperand() == null)){
                    // missing between operand in sql like this in teradata:
                    // CREATE TABLE tab1 (Id CHAR(9) ,SalaryFactor DOUBLE PRECISION BETWEEN .1 AND 1E1 );

                    // System.out.println(checkCondition.toString());
                }
                break;
            default:;
        }
    }

    public void setCheckCondition(TExpression checkCondition) {
        this.checkCondition = checkCondition;
    }

    public void setIndexCols(TPTNodeList<TIndexColName> indexCols) {
        this.indexCols = indexCols;
    }
}