/*
 * JBoss, Home of Professional Open Source.
 * See the COPYRIGHT.txt file distributed with this work for information
 * regarding copyright ownership.  Some portions may be licensed
 * to Red Hat, Inc. under one or more contributor license agreements.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301 USA.
 */

package org.teiid.query.optimizer.relational.rules;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.teiid.api.exception.query.QueryMetadataException;
import org.teiid.api.exception.query.QueryPlannerException;
import org.teiid.core.TeiidComponentException;
import org.teiid.query.analysis.AnalysisRecord;
import org.teiid.query.metadata.QueryMetadataInterface;
import org.teiid.query.optimizer.capabilities.CapabilitiesFinder;
import org.teiid.query.optimizer.relational.OptimizerRule;
import org.teiid.query.optimizer.relational.RuleStack;
import org.teiid.query.optimizer.relational.plantree.NodeConstants;
import org.teiid.query.optimizer.relational.plantree.NodeEditor;
import org.teiid.query.optimizer.relational.plantree.NodeFactory;
import org.teiid.query.optimizer.relational.plantree.PlanNode;
import org.teiid.query.sql.lang.SetQuery.Operation;
import org.teiid.query.util.CommandContext;


/**
 *  Organizes union branches so that push down is possible.  This does not check to actually ensure that push down will happen.
 */
public class RulePlanUnions implements OptimizerRule {
    
    /** 
     * @see org.teiid.query.optimizer.relational.OptimizerRule#execute(org.teiid.query.optimizer.relational.plantree.PlanNode, org.teiid.query.metadata.QueryMetadataInterface, org.teiid.query.optimizer.capabilities.CapabilitiesFinder, org.teiid.query.optimizer.relational.RuleStack, org.teiid.query.analysis.AnalysisRecord, org.teiid.query.util.CommandContext)
     */
    public PlanNode execute(PlanNode plan,
                            QueryMetadataInterface metadata,
                            CapabilitiesFinder capabilitiesFinder,
                            RuleStack rules,
                            AnalysisRecord analysisRecord,
                            CommandContext context) throws QueryPlannerException,
                                                   QueryMetadataException,
                                                   TeiidComponentException {
        
        optimizeUnions(plan, metadata, capabilitiesFinder);
        
        return plan;
    }

    /** 
     * @param plan
     * @param metadata
     * @param capabilitiesFinder
     * @throws QueryMetadataException
     * @throws TeiidComponentException
     */
    private void optimizeUnions(PlanNode plan,
                                QueryMetadataInterface metadata,
                                CapabilitiesFinder capabilitiesFinder) throws QueryMetadataException,
                                                                      TeiidComponentException {
        //look for all union branches and their sources
        for (PlanNode unionNode : NodeEditor.findAllNodes(plan, NodeConstants.Types.SET_OP, NodeConstants.Types.SET_OP | NodeConstants.Types.ACCESS)) {
            List<PlanNode> accessNodes = NodeEditor.findAllNodes(unionNode, NodeConstants.Types.ACCESS);
            
            Object id = getModelId(metadata, accessNodes, capabilitiesFinder);
            
            //check to see if this union is already to the same source
            if (id != null) {
                continue;
            }
            
            //a linked hashmap is used so that the first entry is logically the first branch
            Map<Object, List<PlanNode>> sourceNodes = new LinkedHashMap<Object, List<PlanNode>>();
            
            boolean all = unionNode.hasBooleanProperty(NodeConstants.Info.USE_ALL);
            Operation op = (Operation)unionNode.getProperty(NodeConstants.Info.SET_OPERATION);
            
            collectUnionSources(metadata, capabilitiesFinder, unionNode, sourceNodes, all, op);
            
            if (sourceNodes.size() == 1) {
                continue;
            }
            
            //rebuild unions based upon the source map
            boolean shouldRebuild = false;
            
            for (Map.Entry<Object, List<PlanNode>> entry : sourceNodes.entrySet()) {
                if (entry.getKey() != null 
                		&& entry.getValue().size() > 1 
            			&& CapabilitiesUtil.supportsSetOp(entry.getKey(), (Operation)unionNode.getProperty(NodeConstants.Info.SET_OPERATION), metadata, capabilitiesFinder)) {
            		shouldRebuild = true;
            		break;
            	}
            }
            
            if (!shouldRebuild) {
                continue;
            }
            
            List<PlanNode> sourceUnions = new LinkedList<PlanNode>();
            
            for (Map.Entry<Object, List<PlanNode>> entry : sourceNodes.entrySet()) {
                List<PlanNode> sources = entry.getValue();
                
                sourceUnions.add(buildUnionTree(unionNode, sources));
            }
            
            PlanNode tempRoot = buildUnionTree(unionNode, sourceUnions);
            
            unionNode.removeAllChildren();
            unionNode.addChildren(tempRoot.removeAllChildren());
        }
    }

    static PlanNode buildUnionTree(PlanNode rootUnionNode,
                                List<PlanNode> sources) {
        
        PlanNode root = null;
        
        for (PlanNode source : sources) {
            if (root == null) {
                root = source;
            } else {
                PlanNode union = NodeFactory.getNewNode(NodeConstants.Types.SET_OP);
                union.setProperty(NodeConstants.Info.SET_OPERATION, rootUnionNode.getProperty(NodeConstants.Info.SET_OPERATION));
                union.setProperty(NodeConstants.Info.USE_ALL, rootUnionNode.getProperty(NodeConstants.Info.USE_ALL));
                union.addLastChild(root);
                union.addLastChild(source);
                root = union;
            }
        }
        
        return root;
    }

    /**
     * TODO: union and intersect are associative
     */
    private void collectUnionSources(QueryMetadataInterface metadata,
                                     CapabilitiesFinder capabilitiesFinder,
                                     PlanNode unionNode,
                                     Map<Object, List<PlanNode>> sourceNodes,
                                     boolean all, Operation setOp) throws QueryMetadataException,
                                                 TeiidComponentException {
        for (PlanNode child : unionNode.getChildren()) {
            if (child.getType() == NodeConstants.Types.SET_OP) {
            	if (!all && Operation.UNION == child.getProperty(NodeConstants.Info.SET_OPERATION)) {
            		//allow the parent to handle the dup removal
            		child.setProperty(NodeConstants.Info.USE_ALL, Boolean.TRUE);
            	}
                if ((!all || child.hasBooleanProperty(NodeConstants.Info.USE_ALL)) && setOp.equals(child.getProperty(NodeConstants.Info.SET_OPERATION)) && setOp != Operation.EXCEPT) { //keep collecting sources
                    List<PlanNode> accessNodes = NodeEditor.findAllNodes(child, NodeConstants.Types.ACCESS);
                    
                    Object id = getModelId(metadata, accessNodes, capabilitiesFinder);
                    
                    if (id != null) {
                        buildModelMap(metadata, capabilitiesFinder, sourceNodes, child, id);
                    } else {
                        collectUnionSources(metadata, capabilitiesFinder, child, sourceNodes, all, setOp);
                    }
                } else { //recursively optimize
                    optimizeUnions(child, metadata, capabilitiesFinder);
                }
            } else {  //this must be a source, see if it has a consistent access node
                List<PlanNode> accessNodes = NodeEditor.findAllNodes(child, NodeConstants.Types.ACCESS);
                
                Object id = getModelId(metadata, accessNodes, capabilitiesFinder);
                
                buildModelMap(metadata, capabilitiesFinder, sourceNodes, child, id);

                if (id == null) {
                    //recursively optimize below this point
                    optimizeUnions(child, metadata, capabilitiesFinder);
                }
            }
        }
    }

    private Object getModelId(QueryMetadataInterface metadata,
                            List<PlanNode> accessNodes, CapabilitiesFinder capFinder) throws QueryMetadataException,
                                             TeiidComponentException {
        Object modelID = null;
        
        for (PlanNode accessNode : accessNodes) {
        
            Object accessModelID = RuleRaiseAccess.getModelIDFromAccess(accessNode, metadata);
            
            if (accessModelID == null) {
                return null;
            }
            
            if(modelID == null) {
                modelID = accessModelID;
            } 
            
            if(! CapabilitiesUtil.isSameConnector(modelID, accessModelID, metadata, capFinder)) {
                return null;
            }
        }
        
        return modelID;
    }
    
    /**
     * Builds a mapping of models to access nodes.  The ordering of access nodes will be stable
     * and the model key takes into account whether the same connector is used.
     *  
     * @param metadata
     * @param capFinder
     * @param accessMap
     * @param node
     * @param accessModelID
     * @throws QueryMetadataException
     * @throws TeiidComponentException
     */
    static void buildModelMap(QueryMetadataInterface metadata,
                                   CapabilitiesFinder capFinder,
                                   Map<Object, List<PlanNode>> accessMap,
                                   PlanNode node,
                                   Object accessModelID) throws QueryMetadataException,
                                                        TeiidComponentException {
        List<PlanNode> accessNodes = accessMap.get(accessModelID);
        
        if (accessNodes == null) {
	        for (Map.Entry<Object, List<PlanNode>> entry : accessMap.entrySet() ) {
	            if (accessModelID == entry.getKey() || CapabilitiesUtil.isSameConnector(accessModelID, entry.getKey(), metadata, capFinder)) {
	                accessNodes = entry.getValue();
	                break;
	            }
	        }
	        
	        if (accessNodes == null) {
	            accessNodes = new ArrayList<PlanNode>();
	            accessMap.put(accessModelID, accessNodes);
	        }
        }
        accessNodes.add(node);
    }
    
    /** 
     * @see java.lang.Object#toString()
     */
    public String toString() {
        return "PlanUnions"; //$NON-NLS-1$
    }

}
