package gudusoft.gsqlparser.stmt;

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

import java.util.ArrayList;

/**
 *
 * SQL delete statement.
 * <br>
 * <br>{@link #getTargetTable} returns the target table of delete statement, this table also stored in the first element of {@link #tables}.
 * <br>MySQL may contains multiple target tables, please fetch those tables from {@link #joins}.
 * <br>If there is a FROM clause in the delete statement, all those tables in the from clause can be fetched from {@link #getReferenceJoins}.
 * <br>
 *  <pre>
 *   DELETE FROM Production.ProductCostHistory
 *   WHERE StandardCost &gt; 1000.00;
 *  </pre>
 * <p>  Production.ProductCostHistory can be fetched from {@link #getTargetTable} or {@link #tables}
 * <pre>
 *  DELETE FROM Sales.SalesPersonQuotaHistory
 *  FROM Sales.SalesPersonQuotaHistory AS spqh
 *  INNER JOIN Sales.SalesPerson AS sp
 *  ON spqh.BusinessEntityID = sp.BusinessEntityID
 *  WHERE sp.SalesYTD &gt; 2500000.00;
 * </pre>
 *
 * Sales.SalesPersonQuotaHistory AS spqh should be fetched froom {@link #getReferenceJoins}
 *
 * @see TCustomSqlStatement#cteList
 * @see TCustomSqlStatement#topClause
 * @see TCustomSqlStatement#targetTable
 * @see TCustomSqlStatement#joins
 * @see TCustomSqlStatement#whereClause
 * @see TCustomSqlStatement#returningClause
 * @see TCustomSqlStatement#outputClause
 */
public class TDeleteSqlStatement extends TCustomSqlStatement  {

//    public ArrayList<TObjectName> getReferenceAttributes(){
//        return null;
//    }

//    @Override
//    public ArrayList<TAttributeNode> getAttributes(){
//        if (relationAttributes.size() != 0) return relationAttributes;
//
//        for(TTable table:getTables()){
//            relationAttributes.addAll(table.getAttributes());
//        }
//
//        return relationAttributes;
//    }


    private boolean fromKeyword = false;

    public void setFromKeyword(boolean fromKeyword) {
        this.fromKeyword = fromKeyword;
    }

    /**
     * Whether FROM keyword is used.
     *
     * @return true if FROM keyword is used after delete.
     */
    public boolean isFromKeyword() {

        return fromKeyword;
    }

    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 {@link TOptionClause option clause}
     *
     * @see gudusoft.gsqlparser.nodes.mssql.TOptionClause
     */
    public TOptionClause getOptionClause() {
        return optionClause;
    }

    private TSourceToken deleteToken = null;

    public void setDeleteToken(TSourceToken deleteToken) {
        this.deleteToken = deleteToken;
    }

    /**
     * DELETE keyword of the delete statement.
     * @return DELETE token in delete statement.
     */
    public TSourceToken getDeleteToken() {

        return deleteToken;
    }

    private TOrderBy orderByClause = null;

    /**
     * MySQL order by clause.
     * @return MySQL order by clause.
     */
    public TOrderBy getOrderByClause() {

        return orderByClause;
    }

    private TLimitClause limitClause = null;


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

        return limitClause;
    }

    private TJoinList referenceJoins = null;

    /**
     * If there is a FROM clause in delete statement, this method returns the list of join table in the from clause.
     * @return list of {@link gudusoft.gsqlparser.nodes.TJoin}
     */
    public TJoinList getReferenceJoins() {
        if (this.referenceJoins == null){
            this.referenceJoins = new TJoinList();
        }
        return referenceJoins;
    }

    public TDeleteSqlStatement(EDbVendor dbvendor) {
        super(dbvendor);
        sqlstatementtype = ESqlStatementType.sstdelete;
    }

    void buildsql() {
    }

    void clear() {
    }

    String getasprettytext() {
        return "";
    }

    void iterate(TVisitorAbs pvisitor) {
    }

    /**
     * Used internal.
     *
     * @param psql input sql.
     * @return zero if no syntax error detected.
     */
    public int doParseStatement(TCustomSqlStatement psql) {
        if (rootNode == null) return -1;
        TDeleteSqlNode deleteNode = (TDeleteSqlNode)rootNode;

        this.fromKeyword = deleteNode.isFromKeyword();

        if (this.sourcetokenlist.size() == 0){
            // subquery nested in other statements.
            this.setStartToken(deleteNode.getStartToken());
            this.setEndToken(deleteNode.getEndToken());
        }

        super.doParseStatement(psql);
        this.deleteToken = deleteNode.getDeleteToken();

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

        if (deleteNode.getTopClause() != null){
           deleteNode.getTopClause().doParse(this,ESqlClause.top);
           this.setTopClause(deleteNode.getTopClause());
        }

        TTable lcTable1 = analyzeFromTable(deleteNode.getTargetTable(),true);
        lcTable1.setEffectType(ETableEffectType.tetDelete);
        setTargetTable(lcTable1);
        this.getRelations().add(lcTable1);

        if (deleteNode.getSourceTableList() != null){
            TFromTable lcFromTable = null;
            TJoin lcJoin = null;

            for(int i=0; i<deleteNode.getSourceTableList().size();i++){
                 lcFromTable = deleteNode.getSourceTableList().getFromTable(i);
                if (lcFromTable.getFromtableType() != ETableSource.join){
                    lcJoin = new TJoin();
                    lcTable1 = analyzeFromTable(lcFromTable,true);
                    lcTable1.setEffectType(ETableEffectType.tetSelect);
                    lcJoin.setTable(lcTable1);
                    this.getRelations().add(lcTable1);
                }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);
                }
                joins.addJoin(lcJoin);
            }
        }

        if (deleteNode.getReferenceTableList() != null){
            // MySQL syntax:
            // delete table_name1.[*],table_name2.[*] ...
            // from table_references
            TFromTable lcFromTable = null;
            TJoin lcJoin = null;

            for(int i=0; i<deleteNode.getReferenceTableList().size();i++){
                lcFromTable = deleteNode.getReferenceTableList().getFromTable(i);
                if (lcFromTable.getFromtableType() != ETableSource.join){
                    lcJoin = new TJoin();
                    lcTable1 = analyzeFromTable(lcFromTable,true);
                    lcJoin.setTable( lcTable1);
                    this.getRelations().add(lcTable1);
                }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);
                }
                this.getReferenceJoins().addJoin(lcJoin);
            }

        }

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

        if (deleteNode.getWhereCondition() != null){
            deleteNode.getWhereCondition().doParse(this,ESqlClause.where);
            this.setWhereClause(deleteNode.getWhereCondition());
        }

        if (deleteNode.getReturningClause() != null){
            deleteNode.getReturningClause().doParse(this,ESqlClause.returning);
            this.setReturningClause(deleteNode.getReturningClause());
        }

        this.orderByClause = deleteNode.getOrderByClause();
        if (this.orderByClause != null){
            this.orderByClause.doParse(this,ESqlClause.orderby);
        }

        this.limitClause = deleteNode.getLimitClause();
        if (this.limitClause != null){
            this.limitClause.doParse(this,ESqlClause.limit);
        }

        this.optionClause = deleteNode.getOptionClause();

        errorLoggingClause = deleteNode.getErrorLoggingClause();

        // remove table alias A from tables like this SQL:
        // delete  A
        // from  myTable A
        // join otherTable B on A.Id=B.Id
        int deletedTables[] = new int[this.tables.size()];
        TTable lcTable = null,lcTable2 = null;
        for(int i=0;i<this.tables.size();i++){
            lcTable = this.tables.getTable(i);
            if ((lcTable.getAliasClause() == null)&&(lcTable.isBaseTable())){
                for(int j=0;j<this.tables.size();j++){
                    if (i == j) {continue;}
                    lcTable2 = this.tables.getTable(j);
                    if (lcTable2.getAliasClause() != null){
                        if (lcTable2.getAliasClause().toString().compareToIgnoreCase(lcTable.toString()) == 0){
                            deletedTables[i] = 1;
                            for(int k=0;k<lcTable.getObjectNameReferences().size();k++){
                                lcTable2.getObjectNameReferences().addObjectName(lcTable.getObjectNameReferences().getObjectName(k));
                                lcTable2.getLinkedColumns().addObjectName(lcTable.getObjectNameReferences().getObjectName(k));
                                lcTable.getObjectNameReferences().getObjectName(k).setSourceTable(lcTable2);
                               // System.out.println(lcTable.getObjectNameReferences().getAliasName(k).toString());
                            }
                            if (lcTable == getTargetTable()){
                                setTargetTable(lcTable2);
                            }
                        }
                    }

                }
            }
        }
        for(int i = this.tables.size()-1;i>=0;i--){
            if (deletedTables[i] == 1){
                this.tables.removeElementWithoutSyncTokens(i);
            }
        }

        //couchbase
        useKeyIndex = deleteNode.getUseKeyIndex();


        return 0;
    }

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

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

        if (this.getCteList() != null){
            this.getCteList().acceptChildren(v);
        }

        if (this.getTopClause() != null){
            this.getTopClause().acceptChildren(v);
        }

        this.getTargetTable().acceptChildren(v);
        if (this.joins.size() > 0){
            this.joins.acceptChildren(v);
        }

        if (this.getOutputClause() != null){
            this.getOutputClause().acceptChildren(v);
        }

        if (this.getWhereClause() != null){
            this.getWhereClause().acceptChildren(v);
        }

        if (this.getReturningClause() != null){
            this.getReturningClause().acceptChildren(v);
        }

        v.postVisit(this);
    }

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

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

    public void setOrderByClause(TOrderBy orderByClause) {
        this.orderByClause = orderByClause;
    }

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

    public void setReferenceJoins(TJoinList referenceJoins) {
        this.referenceJoins = referenceJoins;
    }

    //couchbase
    private TUseKeyIndex useKeyIndex;

    public void setUseKeyIndex(TUseKeyIndex useKeyIndex) {
        this.useKeyIndex = useKeyIndex;
    }

    /**
     * Couchbase use key index
     * @return use key index
     */
    public TUseKeyIndex getUseKeyIndex() {

        return useKeyIndex;
    }


}