/*
 * Copyright 2009 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.dev.jjs.impl.gflow;

import com.google.gwt.dev.jjs.impl.gflow.TransformationFunction.Transformation;
import com.google.gwt.dev.util.Preconditions;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;

/**
 * A solver to solve all kinds of analyses defined in the package.
 * Uses iterative worklist algorithm. 
 * 
 * Solver might be forward or backwards working. Both directions will always 
 * produce a valid fixed point, which depends on direction. As a rule, 
 * forward analysis benefits from forward direction, backwards - from the 
 * opposite.
 *
 * @param <N> graph node type.
 * @param <E> graph edge type.
 * @param <T> graph transformer type.
 * @param <G> graph type.
 * @param <A> assumption type.
 */
public class AnalysisSolver<N, E, T, G extends Graph<N, E, T>, 
                            A extends Assumption<A>> {
  /**
   * Adapter from IntegratedFlowFunction to FlowFunction. If integrated function
   * decides to perform transformation, replacement graph is recursively 
   * analyzed and result return without actually performing transformation,  
   */
  private final class IntegratedFlowFunctionAdapter
      implements FlowFunction<N, E, G, A> {
    private IntegratedFlowFunction<N, E, T, G, A> flowFunction;

    private IntegratedFlowFunctionAdapter(
        IntegratedAnalysis<N, E, T, G, A> analysis) {
      flowFunction = analysis.getIntegratedFlowFunction();
    }

    public void interpret(final N node, G graph, 
        final AssumptionMap<E, A> assumptionMap) {
      final boolean[] mapWasModified = new boolean[1];
      Transformation<T, G> transformation = flowFunction.interpretOrReplace(
          node, graph, new AssumptionMap<E, A>() {
            public A getAssumption(E edge) {
              return assumptionMap.getAssumption(edge);
            }

            public void setAssumption(E edge, A assumption) {
              mapWasModified[0] = true;
              assumptionMap.setAssumption(edge, assumption);
            }
          });

      if (transformation == null) {
        return;
      }
      
      Preconditions.checkArgument(!mapWasModified[0]);
      
      final G newSubgraph = transformation.getNewSubgraph();

      if (debug) {
        System.err.println("Applying transformation: " + transformation);
        System.err.println("Replacing");
        System.err.println(node);
        System.err.println("With graph:");
        System.err.println(newSubgraph);
      }

      final List<E> inEdges = graph.getInEdges(node);
      final List<E> outEdges = graph.getOutEdges(node);

      Preconditions.checkArgument(newSubgraph.getGraphInEdges().size() == 
        inEdges.size());

      Preconditions.checkArgument(newSubgraph.getGraphOutEdges().size() == 
        outEdges.size());

      iterate(newSubgraph,
          new IntegratedAnalysis<N, E, T, G, A>() {
            public IntegratedFlowFunction<N, E, T, G, A> 
            getIntegratedFlowFunction() {
              return flowFunction;
            }

            public void setInitialGraphAssumptions(G graph,
                AssumptionMap<E, A> newAssumptionMap) {
              for (int i = 0; i < inEdges.size(); ++i) {
                newAssumptionMap.setAssumption(newSubgraph.getGraphInEdges().get(i),
                    assumptionMap.getAssumption(inEdges.get(i))); 
              }
              
              for (int i = 0; i < outEdges.size(); ++i) {
                newAssumptionMap.setAssumption(newSubgraph.getGraphOutEdges().get(i),
                    assumptionMap.getAssumption(outEdges.get(i))); 
              }
            }

          });

      for (int i = 0; i < inEdges.size(); ++i) {
        assumptionMap.setAssumption(inEdges.get(i), 
            getEdgeAssumption(newSubgraph, newSubgraph.getGraphInEdges().get(i)));
      }
      
      for (int i = 0; i < outEdges.size(); ++i) {
        assumptionMap.setAssumption(outEdges.get(i), 
            getEdgeAssumption(newSubgraph, newSubgraph.getGraphOutEdges().get(i)));
      }
    }
  }
  
  public static boolean debug = false;

  /**
   * Solve a non-integrated analysis.
   * 
   * @param <N> graph node type.
   * @param <E> graph edge type.
   * @param <T> graph transformer type.
   * @param <G> graph type.
   * @param <A> assumption type.
   */
  public static <N, E, T, G extends Graph<N, E, T>, A extends Assumption<A>> 
  Map<E, A> solve(G g, Analysis<N, E, G, A> analysis, boolean forward) {
    return new AnalysisSolver<N, E, T, G, A>(forward).solve(g, analysis);
  }

  /**
   * Solve a integrated analysis.
   * 
   * @param <N> graph node type.
   * @param <E> graph edge type.
   * @param <T> graph transformer type.
   * @param <G> graph type.
   * @param <A> assumption type.
   */
  public static <N, E, T, G extends Graph<N, E, T>, A extends Assumption<A>> 
  boolean solveIntegrated(G g, IntegratedAnalysis<N, E, T, G, A> analysis, 
      boolean forward) {
    return new AnalysisSolver<N, E, T, G, A>(forward).solveIntegrated(g, 
        analysis);
  }
  
  /**
   * If <code>true</code>, then we are moving forward. Moving backwards 
   * otherwise.
   */
  private final boolean forward;

  /**
   * @param forward <code>true</code> if solvers moves forward.
   */
  private AnalysisSolver(boolean forward) {
    this.forward = forward;
  }
  
  /**
   * Apply all transformations based on a found fixed point.
   */
  private boolean actualize(G graph, 
      final IntegratedAnalysis<N, E, T, G, A> analysis) {
    TransformationFunction<N, E, T, G, A> function = 
      new TransformationFunction<N, E, T, G, A>() {
      public Transformation<T, G> transform(final N node, final G graph,
          AssumptionMap<E, A> assumptionMap) {
        final boolean[] didAssumptionChange = new boolean[1];
        Transformation<T, G> transformation = analysis.getIntegratedFlowFunction().interpretOrReplace(
              node, graph, new AssumptionMap<E, A>() {
                public A getAssumption(E edge) {
                  Preconditions.checkArgument(graph.getStart(edge) == node
                      || graph.getEnd(edge) == node);
                  return getEdgeAssumption(graph, edge);
                }

                public void setAssumption(E edge, A assumption) {
                  Preconditions.checkArgument(graph.getStart(edge) == node
                      || graph.getEnd(edge) == node);
                 didAssumptionChange[0] = true;
                }
              });
        Preconditions.checkArgument(transformation == null ||
            !didAssumptionChange[0]);
        return transformation;
      }
    };
    return applyTransformation(graph, function);
  }

  private boolean applyTransformation(final G graph, 
      TransformationFunction<N, E, T, G, A> transformationFunction) {
    boolean didChange = false;

    for (final N node : graph.getNodes()) {
      Transformation<T, G> transformation = transformationFunction.transform(
          node, graph, new AssumptionMap<E, A>() {
            public A getAssumption(E edge) {
              Preconditions.checkArgument(graph.getStart(edge) == node
                  || graph.getEnd(edge) == node);
              return getEdgeAssumption(graph, edge);
            }

            public void setAssumption(E edge, A assumption) {
              throw new IllegalStateException(
                  "Transformations should not change assumptions");
            }
          });
      if (transformation != null) {
        T actualizer = transformation.getGraphTransformer();
        Preconditions.checkNotNull(actualizer, "Null actualizer from: %s",
            transformationFunction);
        didChange = graph.transform(node, actualizer) || didChange;
      }
    }

    return didChange;
  }

  private LinkedHashSet<N> buildInitialWorklist(G g) {
    ArrayList<N> nodes = new ArrayList<N>(g.getNodes());
    LinkedHashSet<N> worklist = new LinkedHashSet<N>(nodes.size());
    if (!forward) {
      Collections.reverse(nodes);
    } 
    worklist.addAll(nodes);
    return worklist;
  }

  @SuppressWarnings("unchecked")
  private A getEdgeAssumption(G graph, E edge) {
    return (A) graph.getEdgeData(edge);
  }

  private void initGraphAssumptions(Analysis<N, E, G, A> analysis, final G graph) {
    analysis.setInitialGraphAssumptions(graph, new AssumptionMap<E, A>() {
      public A getAssumption(E edge) {
        return getEdgeAssumption(graph, edge);
      }

      public void setAssumption(E edge, A assumption) {
        setEdgeAssumption(graph, edge, assumption);
      }
    });
  }
  
  /**
   * Find a fixed point of integrated analysis by wrapping it with 
   * IntegratedFlowFunctionAdapter and calling
   * {@link #solveImpl(Graph, Analysis)}. 
   */
  private void iterate(G graph,
      final IntegratedAnalysis<N, E, T, G, A> integratedAnalysis) {
    if (debug) {
      System.err.println("-----------------------------------------");
      System.err.println("Iterate started on:");
      System.err.println(graph);
      System.err.println("-----------------------------------------");
    }
    final IntegratedFlowFunctionAdapter adapter = 
      new IntegratedFlowFunctionAdapter(integratedAnalysis);

    Analysis<N, E, G, A> analysis = new Analysis<N, E, G, A>() {
      public FlowFunction<N, E, G, A> getFlowFunction() {
        return adapter;
      }

      public void setInitialGraphAssumptions(G graph,
          AssumptionMap<E, A> assumptionMap) {
        integratedAnalysis.setInitialGraphAssumptions(graph, assumptionMap);
      }
    };
    
    solveImpl(graph, analysis);
  }

  private void resetEdgeData(G graph) {
    for (N node : graph.getNodes()) {
      for (E e : graph.getInEdges(node)) {
        graph.setEdgeData(e, null);
      }
      for (E e : graph.getOutEdges(node)) {
        graph.setEdgeData(e, null);
      }
    }
    for (E e : graph.getGraphOutEdges()) {
      graph.setEdgeData(e, null);
    }
    for (E e : graph.getGraphInEdges()) {
      graph.setEdgeData(e, null);
    }
  }

  private void setEdgeAssumption(G graph, E edge, A assumption) {
    graph.setEdgeData(edge, assumption);
  }

  /**
   * Solve a non-integrated analysis.
   */
  private Map<E, A> solve(G g, Analysis<N, E, G, A> analysis) {
    solveImpl(g, analysis);

    Map<E, A> result = new HashMap<E, A>();
    
    for (N n : g.getNodes()) {
      for (E e : g.getInEdges(n)) {
        result.put(e, getEdgeAssumption(g, e));
      }
      for (E e : g.getOutEdges(n)) {
        result.put(e, getEdgeAssumption(g, e));
      }
    }
    for (E e : g.getGraphInEdges()) {
      result.put(e, getEdgeAssumption(g, e));
    }
    for (E e : g.getGraphOutEdges()) {
      result.put(e, getEdgeAssumption(g, e));
    }

    return result;
  }

  /**
   * Solve a non-integrated analysis.
   */
  private void solveImpl(final G graph, Analysis<N, E, G, A> analysis) {
    FlowFunction<N, E, G, A> flowFunction = analysis.getFlowFunction();

    final LinkedHashSet<N> worklist = buildInitialWorklist(graph);
    resetEdgeData(graph);
    initGraphAssumptions(analysis, graph);

    while (!worklist.isEmpty()) {
      Iterator<N> iterator = worklist.iterator();
      final N node = iterator.next();
      iterator.remove();

      flowFunction.interpret(node, graph, new AssumptionMap<E, A>() {
        public A getAssumption(E edge) {
          Preconditions.checkArgument(graph.getStart(edge) == node
              || graph.getEnd(edge) == node);
          return getEdgeAssumption(graph, edge);
        }

        public void setAssumption(E edge, A assumption) {
          N start = graph.getStart(edge);
          N end = graph.getEnd(edge);
          Preconditions.checkArgument(start == node || end == node);

          if (!AssumptionUtil.equals(getEdgeAssumption(graph, edge), assumption)) {
            setEdgeAssumption(graph, edge, assumption);

            if (start == node) {
              if (end != null) {
                worklist.add(end);
              }
            } else if (end == node) {
              if (start != null) {
                worklist.add(start);
              }
            } else {
              throw new IllegalStateException();
            }
          }
        }
      });
    }
  }

  /**
   * Solve an integrated analysis.
   * 
   * Finds a fixed point by using an IntegratedFlowFunctionAdapter and 
   * recursing into {@link #solve(Graph, Analysis)}. Applies analysis 
   * transformations based on the found fixed point.
   */
  private boolean solveIntegrated(G g, IntegratedAnalysis<N, E, T, G, A> analysis) {
    iterate(g, analysis);
    return actualize(g, analysis);
  }
}