/*******************************************************************************
 * Copyright (c) 2011 IBM Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package com.ibm.wala.cast.js.ipa.callgraph.correlations.extraction;

import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.ibm.wala.cast.js.ipa.callgraph.correlations.Correlation;
import com.ibm.wala.cast.js.ipa.callgraph.correlations.CorrelationSummary;
import com.ibm.wala.cast.js.ipa.callgraph.correlations.EscapeCorrelation;
import com.ibm.wala.cast.js.ipa.callgraph.correlations.ReadWriteCorrelation;
import com.ibm.wala.cast.loader.AstMethod;
import com.ibm.wala.cast.tree.CAstControlFlowMap;
import com.ibm.wala.cast.tree.CAstEntity;
import com.ibm.wala.cast.tree.CAstNode;
import com.ibm.wala.cast.tree.CAstSourcePositionMap;
import com.ibm.wala.cast.tree.CAstSourcePositionMap.Position;
import com.ibm.wala.classLoader.IMethod;
import com.ibm.wala.util.collections.HashMapFactory;
import com.ibm.wala.util.collections.HashSetFactory;
import com.ibm.wala.util.collections.Pair;

/**
 * An {@link ExtractionPolicy} that specifies that correlated pairs should be extracted.
 * 
 * In principle, extracting an arbitrary correlated pair can be very difficult. We restrict
 * our attention to the case where both read and write occur within the same block of
 * statements, with the read preceding the write. In practice, most correlations are of
 * this form.
 * 
 * TODO: The code for finding the correlated instructions is broken since Rhino only gives
 * us line number positions. Consequently, it fails to find the relevant instructions every
 * once in a while.
 * 
 * @author mschaefer
 *
 */
public class CorrelatedPairExtractionPolicy extends ExtractionPolicy {
  private static final boolean DEBUG = false;
  private final Map<CAstNode, List<ExtractionRegion>> region_map = HashMapFactory.make();
  
  private CorrelatedPairExtractionPolicy() {}

  private static void findNodesAtPos(int kind, Position pos, CAstSourcePositionMap spmap, ChildPos nodep, Set<ChildPos> res) {
    CAstNode node = nodep.getChild();
    if(node == null)
      return;
    Position ndpos = spmap.getPosition(node);
    if(ndpos != null) {
      // if we are in the wrong file or past the position pos, abort search
      if(!ndpos.getURL().equals(pos.getURL()))
        return;
      
      if(pos.getLastLine() >= 0 && ndpos.getFirstLine() > pos.getLastLine())
        return;
      
      if(node.getKind() == kind && ndpos.getFirstLine() == pos.getFirstLine() && ndpos.getLastLine() == pos.getLastLine())
        res.add(nodep);
    }
    for(int i=0;i<node.getChildCount();++i)
      findNodesAtPos(kind, pos, spmap, nodep.getChildPos(i), res);
  }
  
  private static Set<ChildPos> findNodesAtPos(int kind, Position pos, CAstEntity entity) {
    Set<ChildPos> res = HashSetFactory.make();
    CAstSourcePositionMap spmap = entity.getSourceMap();
    CAstNode ast = entity.getAST();
    for(int i=0;i<ast.getChildCount();++i)
      findNodesAtPos(kind, pos, spmap, new ChildPos(ast, i, new RootPos()), res);
    return res;
  }
  
  // create an ExtractRegion for the given correlation
  private boolean addCorrelation(CAstEntity entity, Correlation corr, CorrelationSummary correlations) {
    Position startPos = corr.getStartPosition(correlations.getPositions()),
             endPos = corr.getEndPosition(correlations.getPositions());
    
    // TODO: enable these assertions; currently we're getting getLastLine() == -1 a lot
    assert startPos.getFirstLine() != -1;
    //assert startPos.getLastLine() != -1;
    assert endPos.getFirstLine() != -1;
    //assert endPos.getLastLine() != -1;
    
    Set<ChildPos> startNodes = null,
                  endNodes = null;
    if(!entity.getPosition().getURL().equals(startPos.getURL()))
      return true;
    startNodes = findNodesAtPos(CAstNode.OBJECT_REF, startPos, entity);
    if(corr instanceof ReadWriteCorrelation) {
      endNodes = findNodesAtPos(CAstNode.OBJECT_REF, endPos, entity);
    } else if(corr instanceof EscapeCorrelation) {
      int arity = ((EscapeCorrelation)corr).getNumberOfArguments();
      endNodes = findNodesAtPos(CAstNode.CALL, endPos, entity);
      for(Iterator<ChildPos> iter=endNodes.iterator();iter.hasNext();) {
        CAstNode candidate = iter.next().getChild();
        // need to deduct three here: one for the function expression, one for "do"/"ctor", and one for the receiver expression
        if(candidate.getChildCount() - 3 != arity)
          iter.remove();
      }
    } else {
      throw new IllegalArgumentException("Unknown correlation type.");
    }
    if(startNodes.isEmpty() || endNodes.isEmpty()) {
      if(DEBUG)
        System.err.println("Couldn't find any start/end nodes for correlation " + corr.pp(correlations.getPositions()));
      return true;
    }
    ChildPos startNode, endNode;
    filterNames(startNodes, corr.getIndexName());
    filterNames(endNodes, corr.getIndexName());
    Iterator<ChildPos> iter = startNodes.iterator();
    if(startNodes.size() == 2 && endNodes.equals(startNodes)) {
      startNode = iter.next();
      endNode = iter.next();
    } else if(startNodes.size() > 1 || startNodes.size() == 0) {
      if(DEBUG)
        System.err.println("Couldn't find unique start node for correlation " + corr.pp(correlations.getPositions()));
      return false;
    } else if(endNodes.size() > 1 || endNodes.size() == 0) {
      if(DEBUG)
        System.err.println("Couldn't find unique end node for correlation " + corr.pp(correlations.getPositions()));
      return false;
    } else {
      startNode = startNodes.iterator().next();
      endNode = endNodes.iterator().next();
    }
    
    List<String> locals = corr.getFlownThroughLocals().size() == 1 ? Collections.singletonList(corr.getFlownThroughLocals().iterator().next()) 
                                                                   : Collections.<String>emptyList();
    Pair<CAstNode, ? extends ExtractionRegion> region_info = findClosestContainingBlock(entity, startNode, endNode, corr.getIndexName(), locals);
    if(region_info == null) {
      if(DEBUG)
        System.err.println("Couldn't find enclosing block for correlation " + corr.pp(correlations.getPositions()));
      return false;
    }
    
    List<ExtractionRegion> regions = region_map.get(region_info.fst);
    if(regions == null)
      region_map.put(region_info.fst, regions = new LinkedList<ExtractionRegion>());
    for(int i=0;i<regions.size();++i) {
      ExtractionRegion region2 = regions.get(i);
      if(region2.getEnd() <= region_info.snd.getStart())
        continue;
      if(region2.getStart() < region_info.snd.getEnd()) {
        if(region_info.snd.getParameters().equals(region2.getParameters())) {
          region2.setStart(Math.min(region_info.snd.getStart(), region2.getStart()));
          region2.setEnd(Math.max(region_info.snd.getEnd(), region2.getEnd()));
          if(DEBUG)
            System.err.println("Successfully processed correlation " + corr.pp(correlations.getPositions()));
          return true;
        }
        if(DEBUG)
          System.err.println("Overlapping regions.");
        return false;
      }
      regions.add(i, region_info.snd);
      if(DEBUG)
        System.out.println("Successfully processed correlation " + corr.pp(correlations.getPositions()));
      return true;
    }
    if(DEBUG)
      System.out.println("Successfully processed correlation " + corr.pp(correlations.getPositions()));
    regions.add(region_info.snd);
    return true;
  }
  
  private void filterNames(Set<ChildPos> nodes, String indexName) {
    for(Iterator<ChildPos> iter=nodes.iterator();iter.hasNext();) {
      CAstNode node = iter.next().getChild();
      if(node.getKind() == CAstNode.OBJECT_REF) {
        CAstNode index = node.getChild(1);
        if(index.getKind() != CAstNode.VAR || !index.getChild(0).getValue().equals(indexName)) {
          iter.remove();
        }
      }
    }
  }

  private Pair<CAstNode, ? extends ExtractionRegion> findClosestContainingBlock(CAstEntity entity, ChildPos startNode, ChildPos endNode, String parmName, List<String> locals) {
    ChildPos pos = startNode;
    CAstNode block = null;
    int start = -1, end = 0;
    int start_inner = -1, end_inner = -1;
    
    do {
      if(pos != startNode && pos.getParentPos() instanceof ChildPos)
        pos = (ChildPos)pos.getParentPos();
      // find the next closest block around the node at position "pos"
      while(pos.getParent().getKind() != CAstNode.BLOCK_STMT) {
        if(pos.getParentPos() instanceof ChildPos)
          pos = (ChildPos)pos.getParentPos();
        else
          return null;
      }
      block = pos.getParent();
      start = pos.getIndex();
      end = getCoveringChildIndex(block, start, endNode.getChild()) + 1;
    } while(end == 0);
    
    // expand region to include forward goto targets
    CAstControlFlowMap cfg = entity.getControlFlow();
    for(int i=start;i<end;++i) {
      CAstNode stmt = block.getChild(i);
      for(Object targetLabel : cfg.getTargetLabels(stmt)) {
        CAstNode target = cfg.getTarget(stmt, targetLabel);
        int targetIndex = getCoveringChildIndex(block, start, target);
        if(targetIndex >= end)
          end = targetIndex + 1;
      }
    }
    
    // special hack to handle "var p = ..., x = y[p];", where startNode = "y[p]"
    if(block.getChild(0).getKind() == CAstNode.BLOCK_STMT && start == 0) {
      for(start_inner=0;start_inner<block.getChild(0).getChildCount();++start_inner)
        if(NodePos.inSubtree(startNode.getChild(), block.getChild(0).getChild(start_inner)))
          return Pair.make(block, new TwoLevelExtractionRegion(start, end, start_inner, end_inner, Collections.singletonList(parmName), locals));
    }
    // special hack to handle the case where we're extracting the body of a local scope
    else if(block.getChild(start).getKind() == CAstNode.LOCAL_SCOPE && end == start+1) {
      return Pair.make(block, new TwoLevelExtractionRegion(start, end, 0, -1, Collections.singletonList(parmName), locals));
    }

    return Pair.make(block, new ExtractionRegion(start, end, Collections.singletonList(parmName), locals));
  }
  
  private static int getCoveringChildIndex(CAstNode parent, int start, CAstNode child) {
    for(int i=start;i<parent.getChildCount();++i)
      if(NodePos.inSubtree(child, parent.getChild(i)))
        return i;
    return -1;
  }
  
  private static CorrelatedPairExtractionPolicy addCorrelations(CAstEntity entity, Map<Position, CorrelationSummary> summaries, CorrelatedPairExtractionPolicy policy) {
    // add correlations for this entity
    if(entity.getAST() != null && summaries.containsKey(entity.getPosition())) {
      CorrelationSummary correlations = summaries.get(entity.getPosition());
      for(Correlation corr : correlations.getCorrelations())
        policy.addCorrelation(entity, corr, correlations);
    }
    // recursively add correlations for scoped entities
    Map<CAstNode, Collection<CAstEntity>> allScopedEntities = entity.getAllScopedEntities();
    for(Collection<CAstEntity> scopedEntities : allScopedEntities.values())
      for(CAstEntity scopedEntity : scopedEntities)
        if(addCorrelations(scopedEntity, summaries, policy) == null)
          return null;
    return policy;
  }
  
  public static CorrelatedPairExtractionPolicy make(CAstEntity entity, Map<IMethod, CorrelationSummary> summaries) {
    CorrelatedPairExtractionPolicy policy = new CorrelatedPairExtractionPolicy();
    Map<Position, CorrelationSummary> summary_map = HashMapFactory.make();
    for(Map.Entry<IMethod, CorrelationSummary> e : summaries.entrySet()) {
      if(e.getKey() instanceof AstMethod) {
        Position pos = ((AstMethod)e.getKey()).getSourcePosition();
        if(pos != null)
          summary_map.put(pos, e.getValue());
      }
    }
    return addCorrelations(entity, summary_map, policy);
  }
  
  @Override
  public List<ExtractionRegion> extract(CAstNode node) {
    return region_map.get(node);
  }
}
