package gudusoft.gsqlparser.stmt;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.nodes.*;
import gudusoft.gsqlparser.nodes.mssql.TOptionClause;
import gudusoft.gsqlparser.nodes.oracle.TErrorLoggingClause;

/**
 * Merge SQL statement.
 * <br>
 * <br>{@link #getTargetTable()} returns the target table.
 * <br>{@link #getUsingTable()} returns the source table in the using clause.
 * <br>{@link #getCondition()} returns the merge search condition.
 * <br>{@link #getWhenClauses()} returns when MATCHED/NOT MATCHED clauses.
 *
 * <pre>
 *     merge into target_table [column_list]
 *     using source_table|subquery
 *     on merge_search_condition
 *     [when matched [and search_conditions ] then update set {col_name = expression} | delete]
 *     [when not matched [and search_conditions ] then insert [(column_list)] values (value_list)]
 *  </pre>
 *
 *  <p> call {@link #getTargetTable()} to return a value for target_table.
 *  <p> column_list can be fetched from {@link #getColumnList()} if any.
 *  <p> source_table in using clause can be fetched via {@link #getUsingTable()},
 *  subquery treated as a table as well.
 *  <p>  call {@link #getCondition()} to return merge_search_condition.
 *  <p> when [not] matched clause is available by calling {@link #getWhenClauses()}
 *  which is a list of type {@link TMergeWhenClause}.
 *
 * @see TMergeWhenClause
 * @see TMergeUpdateClause
 * @see TMergeDeleteClause
 * @see TMergeInsertClause
 */
public class TMergeSqlStatement extends TCustomSqlStatement {

    private TErrorLoggingClause errorLoggingClause;

    /**
     * Oracle error logging clause.
     * @return Oracle error logging clause.
     */
    public TErrorLoggingClause getErrorLoggingClause() {
        return errorLoggingClause;
    }

    private TOptionClause optionClause;

    /**
     * sql server option clause
     * @return option clause
     *
     * @see gudusoft.gsqlparser.nodes.mssql.TOptionClause
     */
    public TOptionClause getOptionClause() {
        return optionClause;
    }

    public TMergeSqlStatement(EDbVendor dbvendor) {
        super(dbvendor);
        sqlstatementtype = ESqlStatementType.sstmerge;
    }

    void buildsql() {
    }

    void clear() {
    }

    String getasprettytext() {
        return "";
    }

    void iterate(TVisitorAbs pvisitor) {
    }

    private TExpression matchedSearchCondition = null;
    private TExpression notMatchedSearchCondition = null;
    private TObjectNameList columnList = null;

    /**
     * Columns in target table.
     * @return Columns in target table.
     */
    public TObjectNameList getColumnList() {
        return columnList;
    }

    /**
     * This method is not used, use {@link #getCondition()} instead.
     * @return not used
     */
    public TExpression getMatchedSearchCondition() {
        return matchedSearchCondition;
    }

    /**
     * This method is not used, use {@link #getCondition()} instead.
     * @return not used
     */
    public TExpression getNotMatchedSearchCondition() {
        return notMatchedSearchCondition;
    }

    private TTable usingTable;

    /**
     * Source table in the using clause.
     * @return Source table in the using clause.
     */
    public TTable getUsingTable() {
        return usingTable;
    }

    private TExpression condition;

    /**
     * merge search condition.
     * @return merge search condition.
     */
    public TExpression getCondition() {
        return condition;
    }


    private TMergeUpdateClause updateClause;
    private TMergeInsertClause insertClause;

    /**
     * This method is not used, use {@link #getWhenClauses()} instead.
     * @return
     */
    public TMergeUpdateClause getUpdateClause() {
        return updateClause;
    }

    /**
     * This method is not used, use {@link #getWhenClauses()} instead.
     * @return
     */
    public TMergeInsertClause getInsertClause() {
        return insertClause;
    }

    private TPTNodeList <TMergeWhenClause> whenClauses;

    /**
     * when matched/not matched clauses.
     * @return when matched/not matched clauses.
     */
    public TPTNodeList<TMergeWhenClause> getWhenClauses() {
        return whenClauses;
    }

    public int doParseStatement(TCustomSqlStatement psql) {
        if (rootNode == null) return -1;
        TMergeSqlNode mergeSqlNode = (TMergeSqlNode)rootNode;
        super.doParseStatement(psql);

        if (mergeSqlNode.cteList != null){
            this.setCteList( mergeSqlNode.cteList);
            this.getCteList().doParse(this, ESqlClause.cte);
        }

        TTable lcTable;
        lcTable = analyzeFromTable(mergeSqlNode.getTargetTable(),true);
        lcTable.setEffectType(ETableEffectType.tetMerge);
        setTargetTable(lcTable);
        this.getRelations().add(lcTable);

        //tables.addTable(this.getTargetTable());
//        TFromTable lcFromTable = mergeSqlNode.getUsingTable();
//        TJoin lcJoin;
//        if (lcFromTable.getFromtableType() != ETableSource.join){
//            lcJoin = new TJoin();
//            lcTable = analyzeFromTable(lcFromTable,true);
//            lcTable.setEffectType(ETableEffectType.tetSelect);
//            lcJoin.setTable(lcTable);
//            lcJoin.setStartToken(lcJoin.getTable().getStartToken());
//            lcJoin.setEndToken(lcJoin.getTable().getEndToken());
//            lcJoin.setGsqlparser(getGsqlparser());
//            this.fromSourceTable = lcTable;
//            this.getRelations().add(lcTable);
//        }else{
//            this.fromSourceJoin = lcFromTable.getJoinExpr();
//
//            this.fromSourceTable = new TTable();
//            this.fromSourceTable.setTableType(ETableSource.join);
//            this.fromSourceTable.setAliasClause(lcFromTable.getJoinExpr().getAliasClause());
//            this.fromSourceTable.setStartToken(lcFromTable.getStartToken());
//            this.fromSourceTable.setEndToken(lcFromTable.getEndToken());
//            this.fromSourceTable.setGsqlparser(lcFromTable.getGsqlparser());
//            this.fromSourceTable.setJoinExpr(this.fromSourceJoin);
//            this.getRelations().add(this.fromSourceTable);
//
//            lcJoin = analyzeJoin(lcFromTable.getJoinExpr(),null,true);
//            lcJoin.doParse(this, ESqlClause.join);
//
//            if (lcFromTable.getLateralViewList() != null){
//                for(TLateralView lateralView:lcFromTable.getLateralViewList()){
//                    addToTables(lateralView.createATable(this));
//                }
//            }
//        }

        analyzeTableOrJoin(mergeSqlNode.getUsingTable());
        this.usingTable = this.fromSourceTable;//analyzeFromTable(mergeSqlNode.getUsingTable(),true);
        //usingTable.setEffectType(ETableEffectType.tetSelect);
        this.getRelations().add(usingTable);

        //tables.addTable(this.usingTable);

        this.condition = mergeSqlNode.getCondition();
        this.condition.doParse(this, ESqlClause.joinCondition);

        if (mergeSqlNode.getColumnList() != null){
            this.columnList = mergeSqlNode.getColumnList();
            TObjectName crf ;
            for (int i=0;i< mergeSqlNode.getColumnList().size();i++){
                crf =mergeSqlNode.getColumnList().getObjectName(i);
                // link this column to last 2 tables
                crf.setLocation(ESqlClause.mergeInsert);
                getTargetTable().getObjectNameReferences().addObjectName(crf);
                getTargetTable().getLinkedColumns().addObjectName(crf);
                crf.setSourceTable(getTargetTable());
                crf.setValidate_column_status(TBaseType.COLUMN_LINKED_TO_TABLE_IN_OLD_ALGORITHM);
            }

            //insertNode.getColumnList().doParse(this,TBaseType.insertColumnClause);
        }

        this.whenClauses = mergeSqlNode.getWhenClauses();
        if (this.whenClauses != null){
            this.whenClauses.doParse(this,ESqlClause.unknown);
        }

        limitClause = mergeSqlNode.getLimitClause();
        if (limitClause != null){
            limitClause.doParse(this,ESqlClause.unknown);
        }
        returningClause = mergeSqlNode.getReturningClause();
        if (returningClause != null){
            returningClause.doParse(this,ESqlClause.unknown);
        }

        if (mergeSqlNode.getOutputClause() != null){
            mergeSqlNode.getOutputClause().doParse(this,ESqlClause.output);
            this.setOutputClause(mergeSqlNode.getOutputClause());
        }

        this.optionClause = mergeSqlNode.getOptionClause();

        errorLoggingClause = mergeSqlNode.getErrorLoggingClause();
       // tables.addTable(this.getTargetTable());

        return 0;
    }

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

    public void acceptChildren(TParseTreeVisitor v){
        v.preVisit(this);
        this.getTargetTable().acceptChildren(v);
        usingTable.acceptChildren(v);
        condition.acceptChildren(v);
        if (columnList != null) columnList.acceptChildren(v);
        if (whenClauses != null) whenClauses.acceptChildren(v);
        if (getOutputClause() != null) getOutputClause().acceptChildren(v);
        if (errorLoggingClause != null) errorLoggingClause.acceptChildren(v);
        v.postVisit(this);
    }

    public void setErrorLoggingClause(TErrorLoggingClause errorLoggingClause) {
        this.errorLoggingClause = errorLoggingClause;
    }

    public void setOptionClause(TOptionClause optionClause) {
        this.optionClause = optionClause;
    }

    public void setMatchedSearchCondition(TExpression matchedSearchCondition) {
        this.matchedSearchCondition = matchedSearchCondition;
    }

    public void setNotMatchedSearchCondition(TExpression notMatchedSearchCondition) {
        this.notMatchedSearchCondition = notMatchedSearchCondition;
    }

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

    public void setUsingTable(TTable usingTable) {
        this.usingTable = usingTable;
    }

    public void setCondition(TExpression condition) {
        this.condition = condition;
    }

    public void setUpdateClause(TMergeUpdateClause updateClause) {
        this.updateClause = updateClause;
    }

    public void setInsertClause(TMergeInsertClause insertClause) {
        this.insertClause = insertClause;
    }

    public void setWhenClauses(TPTNodeList<TMergeWhenClause> whenClauses) {
        this.whenClauses = whenClauses;
    }

    private TLimitClause limitClause;

    public void setLimitClause(TLimitClause limitClause) {
        this.limitClause = limitClause;
    }

    /**
     * Couchbase, limit clause.
     * @return Couchbase, limit clause.
     */
    public TLimitClause getLimitClause() {

        return limitClause;
    }

    private TReturningClause returningClause;

    public void setReturningClause(TReturningClause returningClause) {
        this.returningClause = returningClause;
    }

    /**
     * Couchbase, returning clause.
     * @return Couchbase, returning clause.
     */
    public TReturningClause getReturningClause() {

        return returningClause;
    }
}