/*
    * BasicListUpdateDelegate.java
    * 
    * Copyright (c) 2006 David Holroyd
    *
    * 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 uk.co.badgersinfoil.metaas.impl.antlr;
  
  import org.asdt.core.internal.antlr.AS3Parser;
  import uk.co.badgersinfoil.metaas.impl.ASTUtils;
  import uk.co.badgersinfoil.metaas.impl.TokenBuilder;
  
  /**
   * Manages the tokens of the parent tree in the most basic way possible, simply
   * inserting the run of tokens belonging to the child into the run of tokens
   * belonging to the parent and updating start/stop tokens for the parent if
   * required.
   */
  public class BasicListUpdateDelegate implements TreeTokenListUpdateDelegate {
  
  	// TODO: delete PLACEHOLDER tokens when they are superseded by the addition of real tokens
  
  	public void addedChild(LinkedListTree parent, LinkedListTree child) {
  		if (isPlaceholder(parent)) {
  			if (isPlaceholder(child)) {
  				throw new IllegalArgumentException("The parent node ("+ASTUtils.tokenName(parent)+") has only a placeholder token, so a child which also has only a placeholder token ("+ASTUtils.tokenName(child)+") can't be added yet");
  			}
  			LinkedListToken placeholder = parent.getStartToken();
  			if (placeholder.getPrev() != null) {
  				placeholder.getPrev().setNext(child.getStartToken());
  			}
  			if (placeholder.getNext() != null) {
  				placeholder.getNext().setPrev(child.getStopToken());
  			}
  			parent.setStartToken(child.getStartToken());
  			parent.setStopToken(child.getStopToken());
  			return;
  		}
  		LinkedListToken stop = findTokenInsertionPointForChildWithinParent(parent, child);
  		if (parent.getStartToken() == null) {
  			parent.setStartToken(child.getStartToken());
  		}
  		if (stop != null) {
  			insertAfter(stop, stop.getNext(),
  			            child.getStartToken(), child.getStopToken());
  		}
  		if (child.getStopToken() != null) {
  			parent.setStopToken(child.getStopToken());
  		}
  	}
  
  	private boolean isPlaceholder(LinkedListTree ast) {
  		return ast.getStartToken()==ast.getStopToken()
  		    && ast.getStartToken()!=null
  		    && ast.getStartToken().getType()==AS3Parser.VIRTUAL_PLACEHOLDER
  		    && ((PlaceholderLinkedListToken)ast.getStartToken()).getHeld()==ast;
  	}
  
  	private LinkedListToken findTokenInsertionPointForChildWithinParent(LinkedListTree parent, LinkedListTree child) {
  		// FIXME: this fails to take into account am ancestor not
  		// having the same kind of TreeTokenListUpdateDelegate
  		while (parent != null) {
  			if (parent.getChildCount() == 1) {
  				// the just-added child is the only child of 'parent'
  				if (parent.getStopToken() != null) {
  					return parent.getStopToken();
  				}
  				if (parent.getStartToken() != null) {
  					return parent.getStartToken();
  				}
  			}
  			int index = parent.getIndexOfChild(child);
  			if (index > 0 && index < parent.getChildCount()-1) {
  				// 'child' is not the *first* child of 'parent'
  				LinkedListTree precedent = (LinkedListTree)parent.getChild(index-1);
  				if (precedent.getStopToken() == null) {
  					// TODO: loop, rather than recurse,
  					return findTokenInsertionPointForChildWithinParent(parent, precedent);
  				}
  				return precedent.getStopToken();
  			}
  			if (index==0 && parent.getStartToken()!=null) {
  				return parent.getStartToken();
  			}
  			if (parent.getStopToken() != null) {
  				return parent.getStopToken();
  			}
 			child = parent;
 			parent = parent.getParent();
 		}
 		return null;
 	}
 
 	public void addedChild(LinkedListTree parent, int index, LinkedListTree child) {
 		LinkedListToken target;
 		LinkedListToken targetNext;
 		if (index == 0) {
 			LinkedListTree prevFirstChild = (LinkedListTree)parent.getChild(1);
 			targetNext = prevFirstChild.getStartToken();
 			target = targetNext.getPrev();
 			if (targetNext == parent.getStartToken()) {
 				parent.setStartToken(child.getStartToken());
 			}
 		} else {
 			target = ((LinkedListTree)parent.getChild(index - 1)).getStopToken();
 			targetNext = target.getNext();
 		}
 		insertAfter(target, targetNext,
 		            child.getStartToken(), child.getStopToken());
 	}
 
 	protected static void insertAfter(LinkedListToken target, LinkedListToken targetNext,
 	                                LinkedListToken start, LinkedListToken stop)
 	{
 		if (target == null && targetNext == null) {
 			throw new IllegalArgumentException("At least one of target and targetNext must be non-null");
 		}
 		if (start != null) {
 //			if (start.getPrev() != null || stop.getNext() != null) {
 //				throw new IllegalArgumentException("insertAfter("+target+", "+targetNext+", "+start+", "+stop+") : start.getPrev()="+start.getPrev()+" stop.getNext()="+stop.getNext());
 //			}
 			// i.e. we're not adding an imaginary node that currently
 			//      has no real children
 			if (target != null) {
 				target.setNext(start);
 			}
 			stop.setNext(targetNext);
 			if (targetNext != null) {
 				targetNext.setPrev(stop);
 			}
 		}
 	}
 
 	public void appendToken(LinkedListTree parent, LinkedListToken append) {
 		if (parent.getStopToken() == null) {
 			parent.setStartToken(append);
 			parent.setStopToken(append);
 		} else {
 			// TODO: can this be simplified now?
 			append.setNext(parent.getStopToken().getNext());
 			parent.getStopToken().setNext(append);
 			append.setPrev(parent.getStopToken());
 			parent.setStopToken(append);
 		}
 	}
 
 	public void addToken(LinkedListTree parent, int index, LinkedListToken append) {
 		if (isPlaceholder(parent)) {
 			LinkedListToken placeholder = parent.getStartToken();
 			parent.setStartToken(append);
 			parent.setStopToken(append);
 			placeholder.setPrev(null);
 			placeholder.setNext(null);
 		}
 		if (parent.getStopToken() == null) {
 			parent.setStartToken(append);
 			parent.setStopToken(append);
 		} else {
 			LinkedListToken target;
 			LinkedListToken targetNext;
 			if (index == 0) {
 				targetNext = parent.getStartToken();
 				target = targetNext.getPrev();
 				parent.setStartToken(append);
 			} else if (index == parent.getChildCount()) {
 				target = parent.getStopToken();
 				targetNext = target.getNext();
 				parent.setStopToken(append);
 			} else {
 				LinkedListTree beforeChild = (LinkedListTree)parent.getChild(index);
 				targetNext = beforeChild.getStartToken();
 				target = targetNext.getPrev();
 			}
 			insertAfter(target, targetNext,
 			            append, append);
 		}
 	}
 
 	public void deletedChild(LinkedListTree parent, int index, LinkedListTree child) {
 		// FIXME: this should update start/stop tokens for the parent
 		//        when the first/last child is removed
 		LinkedListToken start = child.getStartToken();
 		LinkedListToken stop = child.getStopToken();
 		LinkedListToken startPrev = start.getPrev();
 		LinkedListToken stopNext = stop.getNext();
 //		if (startPrev == null) {
 //			throw new IllegalArgumentException("No start.prev: "+child);
 //		}
 //		if (stopNext == null) {
 //			throw new IllegalArgumentException("No stop.next: "+child+" (stop="+stop+")");
 //		}
 		if (parent.getChildCount() == 0
 		 && start == parent.getStartToken()
 		 && stop == parent.getStopToken())
 		{
 			// So, the child provided all the tokens that made up
 			// the parent, and removing it will leave nothing!  In
 			// this case, we insert a 'placeholder' token just so
 			// there's something in the token stream for the parent
 			// to reference, and the parent remains anchored to the
 			// appropriate location within the source code
 			LinkedListToken placeholder = TokenBuilder.newPlaceholder(parent);
 			startPrev.setNext(placeholder);
 			stopNext.setPrev(placeholder);
 		} else {
 			if (startPrev != null) {
 				startPrev.setNext(stopNext);
 			} else if (stopNext != null) {  // so try the other way around,
 				stopNext.setPrev(startPrev);
 			}
 			if (parent.getStartToken() == start) {
 				parent.setStartToken(stopNext);
 			}
 			if (parent.getStopToken() == stop) {
 				parent.setStopToken(startPrev);
 			}
 		}
 		// just to save possible confusion, break links out from the
 		// removed token list too,
 		start.setPrev(null);
 		stop.setNext(null);
 	}
 
 	public void replacedChild(LinkedListTree tree, int index, LinkedListTree child, LinkedListTree oldChild) {
 		// defensive assertions to catch bugs,
 		if (child.getStartToken() == null) {
 			throw new IllegalArgumentException("No startToken: "+child);
 		}
 		if (child.getStopToken() == null) {
 			throw new IllegalArgumentException("No stopToken: "+child);
 		}
 		// link the new child's tokens in place of the old,
 		LinkedListToken oldBefore = findOldBeforeToken(tree, index, child, oldChild);
 		LinkedListToken oldAfter = findOldAfterToken(tree, index, child, oldChild);
 		if (oldBefore != null) {
 			oldBefore.setNext(child.getStartToken());
 		}
 		if (oldAfter != null) {
 			oldAfter.setPrev(child.getStopToken());
 		}
 		// just to save possible confusion, break links out from the
 		// removed token list too,
 		oldChild.getStartToken().setPrev(null);
 		oldChild.getStopToken().setNext(null);
 
 		if (tree.getStartToken() == oldChild.getStartToken()) {
 			tree.setStartToken(child.getStartToken());
 		}
 		if (tree.getStopToken() == oldChild.getStopToken()) {
 			tree.setStopToken(child.getStopToken());
 		}
 	}
 
 	private LinkedListToken findOldBeforeToken(LinkedListTree tree, int index, LinkedListTree child, LinkedListTree oldChild) {
 		LinkedListToken oldStart = oldChild.getStartToken();
 		if (oldStart == null) {
 			throw new IllegalStateException("<"+oldChild+">, child "+index+" of <"+tree+">, had no startToken");
 		}
 		return oldStart.getPrev();
 	}
 
 	private LinkedListToken findOldAfterToken(LinkedListTree tree, int index, LinkedListTree child, LinkedListTree oldChild) {
 		LinkedListToken oldStop = oldChild.getStopToken();
 		if (oldStop == null) {
 			throw new IllegalStateException("<"+oldChild+">, child "+index+" of <"+tree+">, had no stopToken");
 		}
 		return oldStop.getNext();
 	}
 }