package gudusoft.gsqlparser.nodes;

import gudusoft.gsqlparser.*;

import java.util.ArrayList;

/**
 * Represents a JOIN expression in SQL statements. This class replaces {@link TJoin} as of version 2.7.4.0.
 * 
 * <p>A JOIN expression consists of:
 * <ul>
 *   <li>A left table/subquery ({@link #getLeftTable()})
 *   <li>A right table/subquery ({@link #getRightTable()}) 
 *   <li>A join type ({@link #getJointype()}) - e.g. INNER, LEFT, RIGHT, FULL, CROSS
 *   <li>An optional ON condition ({@link #getOnCondition()})
 *   <li>Optional USING columns ({@link #getUsingColumns()})
 * </ul>
 * 
 * <p>For nested joins, the left and right operands can themselves be JOIN expressions,
 * allowing representation of complex join trees. Use {@link #getLeftMostJoinExpr()} to
 * traverse to the leftmost join in a nested structure.
 *
 * <p>PostgreSQL-specific: Supports USING clause aliases via {@link #getJoin_using_alias()}.
 *
 * <p>The class implements {@link IRelation} and maintains a list of available attributes
 * from both sides of the join via {@link #getAttributes()}.
 * 
 * <p>Represents join table in parse tree.
*/
public class TJoinExpr extends TNodeWithAliasClause implements IRelation  {

    private TAliasClause join_using_alias;

    /**
     * Postgres: USING ( join_column [, ...] ) [ AS join_using_alias ]
     * @return
     */
    public TAliasClause getJoin_using_alias() {
        return join_using_alias;
    }

    public void initAttributes(int roundNo){
        if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE){
            TBaseType.log(String.format("Starting prepare attributes (num = %d) in round %s from join expr", relationAttributes.size() , roundNo),TLog.DEBUG,this.getStartToken());
        }

        TAttributeNode.addAllNodesToList(leftTable.getAttributes(),relationAttributes);
        TAttributeNode.addAllNodesToList(rightTable.getAttributes(),relationAttributes);
//        relationAttributes.addAll(leftTable.getAttributes());
//        relationAttributes.addAll(rightTable.getAttributes());

        if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE){
            TBaseType.log(String.format("Prepare attributes (num = %d) from join expr:%s", relationAttributes.size() ,this.toString()),TLog.DEBUG,this.getStartToken());
        }
        int c = 0;
        for(TAttributeNode node:relationAttributes){
            if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE){
                TBaseType.log(String.format("\t Attribute: %s",node.getName()),TLog.DEBUG,node.getTable_ref().getStartToken());
            }
            c++;
            if (c >TLog.OUTPUT_ATTRIBUTES_MAX){
                if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE){
                    TBaseType.log(String.format("\t...skipped after output %d attributes",c-1),TLog.DEBUG,this.getStartToken());
                }
                break;
            }
        }
    }

    ArrayList<TAttributeNode> relationAttributes = new ArrayList<>();
//    public ArrayList<TObjectName> getReferenceAttributes(){
//        return null;
//    }
    @Override
    public ArrayList<TAttributeNode> getAttributes(){
        return relationAttributes;
    }

    @Override
    public String getRelationName(){
        if (this.getAliasClause() != null) return this.getAliasClause().toString();
        else return null;
    }

    @Override
    public int size(){
        return relationAttributes.size();
    }

    private TTable leftTable;
    public void setLeftTable(TTable leftTable) {
        this.leftTable = leftTable;

    }
    public void setRightTable(TTable rightTable) {
        this.rightTable = rightTable;

    }

    public TTable getLeftTable() {
        return leftTable;
    }

    public TTable getRightTable() {
        return rightTable;
    }

    private TTable rightTable;

    private int nestedParen = 0;

    public void incNestedParen(){
        nestedParen++;
    }
    public int getNestedParen() {
        return nestedParen;
    }

    public TObjectNameList getUsingColumns() {
        return usingColumns;
    }

    public TExpression getOnCondition() {
        return onCondition;
    }

    /**
     * using (column list)
     */
    public TObjectNameList usingColumns;

    /**
     * on condition;
     */
    public TExpression onCondition;

    public EJoinType getJointype() {
        return jointype;
    }

    private EJoinType jointype;
    public EJoinType original_jontype; // used when this join was nested by ()

    public void setJointype(EJoinType jointype) {
        this.jointype = jointype;
    }

    private TFromTable leftOperand;

    /***
     * This method is used by parser, do not use it in your code.
     * After parsing, you can use getLeftTable() instead.
     */
    public TFromTable getLeftOperand() {
        return leftOperand;
    }

    /***
     * This method is used by parser, do not use it in your code.
     * After parsing, you can use getRightTable() instead.
     */
    public TFromTable getRightOperand() {
        return rightOperand;
    }

    private TFromTable rightOperand;

    /***
     * This method is used by parser, do not use it in your code.
     * After parsing, you can use setLeftTable() instead.
     */
    public void setLeftOperand(TFromTable leftOperand) {
        this.leftOperand = leftOperand;
    }

    /***
     * This method is used by parser, do not use it in your code.
     * After parsing, you can use setRightTable() instead.
     */
    public void setRightOperand(TFromTable rightOperand) {
        this.rightOperand = rightOperand;
    }

    //private  TJoinExpr joinExpr; //valid only when jointype = nested

    public void init(Object arg1)
    {
      //  this.joinExpr = (TJoinExpr)arg1;
        this.jointype = EJoinType.nested;
    }

    public void init(Object arg1, Object arg2)
    {
        this.leftOperand = (TFromTable)arg1;
        this.rightOperand = (TFromTable)arg2;
    }


    public void setJoinCondition(TDummy pDummy){
        if (pDummy == null) return;
        if (pDummy.node1 != null){
            this.onCondition = (TExpression)(pDummy.node1); 
        }

        else if (pDummy.list1 != null){
            this.usingColumns = (TObjectNameList)(pDummy.list1);
        }

        if (pDummy.node2 != null){
            this.join_using_alias = (TAliasClause) pDummy.node2;
        }
    }

    public void setJoinCondition(TExpression onCondition){
          this.onCondition = onCondition;
    }

    public TJoinExpr getLeftMostJoinExpr(){
        TJoinExpr ret = this;
        TFromTable fromTable = leftOperand;
        while (fromTable != null){
            if (fromTable.getFromtableType() != ETableSource.join) break;
            ret = fromTable.getJoinExpr();
            fromTable = ret.getLeftOperand();
        }

        return ret;
    }

    public void setNestedParen(int nestedParen) {
        this.nestedParen = nestedParen;
    }

    public void setUsingColumns(TObjectNameList usingColumns) {
        this.usingColumns = usingColumns;
    }

    public void setOnCondition(TExpression onCondition) {
        this.onCondition = onCondition;
    }

    private TExpression matchCondition;

    public TExpression getMatchCondition() {
        return matchCondition;
    }

    public void setMatchCondition(TExpression matchCondition) {
        this.matchCondition = matchCondition;
    }
    
    

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

    public void acceptChildren(TParseTreeVisitor v) {
        v.preVisit(this);
        leftTable.acceptChildren(v);
        rightTable.acceptChildren(v);
        if (onCondition != null) onCondition.acceptChildren(v);
        if (usingColumns != null) usingColumns.acceptChildren(v);
        v.postVisit(this);
    }
}