package edu.stanford.nlp.parser.shiftreduce;

import java.util.List;

import edu.stanford.nlp.parser.common.ParserConstraint;
import edu.stanford.nlp.trees.Tree;

/**
 * Transition that moves a single item from the front of the queue to
 * the top of the stack without making any other changes.
 */
public class ShiftTransition implements Transition {
  /**
   * Shifting is legal as long as the state is not finished and there
   * are more items on the queue to be shifted.
   * TODO: go through the papers and make sure they don't mention any
   * other conditions where one shouldn't shift
   */
  public boolean isLegal(State state, List<ParserConstraint> constraints) {
    if (state.finished) {
      return false;
    }
    if (state.tokenPosition >= state.sentence.size()) {
      return false;
    }
    // We disallow shifting when the previous transition was a right
    // head transition to a partial (binarized) state
    // TODO: I don't have an explanation for this, it was just stated
    // in Zhang & Clark 2009
    if (state.stack.size() > 0) {
      Tree top = state.stack.peek();
      // Temporary node, eg part of a binarized sequence
      if (top.label().value().startsWith("@") && top.children().length == 2 && 
          ShiftReduceUtils.getBinarySide(top) == BinaryTransition.Side.RIGHT) {
        return false;
      }
    }

    if (constraints == null || state.stack.size() == 0) {
      return true;
    }
    final Tree top = state.stack.peek();
    // If there are ParserConstraints, you can only shift if shifting
    // will not make a constraint unsolvable.  This happens if we
    // shift beyond the right end of a constraint which is not solved.
    for (ParserConstraint constraint : constraints) {
      // either went past or haven't gotten to this constraint yet
      if (ShiftReduceUtils.rightIndex(top) != constraint.end - 1) {
        continue;
      }
      int left = ShiftReduceUtils.leftIndex(top);
      if (left < constraint.start) {
        continue;
      }
      if (left > constraint.start) {
        return false;
      }
      if (!ShiftReduceUtils.constraintMatchesTreeTop(top, constraint)) {
        return false;
      }
    }
    
    return true;
  }

  /**
   * Add the new preterminal to the stack, increment the queue position.
   */
  public State apply(State state) {
    return apply(state, 0.0);
  }

  /**
   * Add the new preterminal to the stack, increment the queue position.
   */
  public State apply(State state, double scoreDelta) {
    Tree tagNode = state.sentence.get(state.tokenPosition);
    if (!tagNode.isPreTerminal()) {
      throw new AssertionError("Only expected preterminal nodes");
    }
    Tree wordNode = tagNode.children()[0];
    String word = wordNode.label().value();
    return new State(state.stack.push(tagNode), state.transitions.push(this), state.separators, state.sentence, state.tokenPosition + 1, state.score + scoreDelta, false);
  }

  @Override
  public boolean equals(Object o) {
    if (o == this) {
      return true;
    }
    if (o instanceof ShiftTransition) {
      return true;
    }
    return false;
  }

  @Override
  public int hashCode() {
    return 900967388; // a random int
  }

  @Override
  public String toString() {
    return "Shift";
  }

  private static final long serialVersionUID = 1;  
}